ფუნქციები
აქამდე ჩვენ მთელ ჩვენს კოდს ვწერდით app.py-ში, მაგრამ რაც უფრო იზრდება ჩვენი პროგრამები, ჩვენ გვჭირდება უკეთესი გზა ჩვენი კოდის ორგანიზებისთვის. ჩვენ უნდა დავყოთ ჩვენი კოდი პატარა, უფრო მართვად და უფრო შენარჩუნებულ ნაწილებად, რომლებსაც ჩვენ ვუწოდებთ ფუნქციებს. ფუნქცია არის კონტეინერი კოდის რამდენიმე სტრიქონისთვის, რომელიც ასრულებს კონკრეტულ დავალებას.
მაგალითად, თქვენ უკვე შეიტყვეთ რამდენიმე ჩაშენებული ფუნქციის შესახებ Python-ში print()
მდე input()
. თითოეულ ფუნქციას აქვს დანიშნულება და იცის როგორ შეასრულოს კონკრეტული დავალება. ასე რომ, როდესაც ჩვენ ვაშენებთ დიდ კომპლექსურ პროგრამებს, ჩვენ უნდა დავყოთ ჩვენი კოდი მცირე მრავალჯერად გამოყენებად ნაწილებად, ანუ ფუნქციებად.
მოდით გავიგოთ ეს კონცეფცია მისალოცი შეტყობინების დასაბეჭდად პროგრამის შექმნით.
print('Hi there!')
print('Welcome aboard!')
აქ გვაქვს მარტივი პროგრამა კოდის მხოლოდ ორი ხაზით. ახლა, ვთქვათ, ჩვენ დაგვჭირდება ისინი სხვა პროგრამებში, რათა ჩავდოთ ისეთ ფუნქციაში, რომელიც შეგვიძლია ხელახლა გამოვიყენოთ.
ნება მომეცით შემოგთავაზოთ დაცული საკვანძო სიტყვა def
პითონში, რომელიც შემოკლებულია define და გამოიყენება ფუნქციის განსაზღვრისათვის.
def greet_user():
print('Hi there!')
print('Welcome aboard!')
ახლა კოდის ეს ბლოკი განსაზღვრავს ფუნქციას "greet_user
” ამის შემდეგ კოდების ხაზებით. როდესაც ეს ფუნქცია გამოიძახება, ეს ორი ხაზი შესრულდება. მოდით გამოვიყენოთ ეს:
print('start')
greet_user()
print('finish')
პროგრამა შესრულებულია თანმიმდევრობით, რაც ნიშნავს, რომ თქვენ უნდა განსაზღვროთ ფუნქცია, სანამ პროგრამაში გამოიძახებთ.
პარამეტრები
განსაზღვრული ფუნქციები ცოტა განსხვავებულად მუშაობს, ვიდრე პითონის ჩაშენებული ფუნქციები. მაგალითად, იმ შემთხვევაში print()
ფუნქცია, მას სჭირდება გარკვეული ინფორმაცია, რომლის დაბეჭდვაც გვინდა, მაგრამ ჩვენი მისალმების ფუნქცია არ იღებს ინფორმაციას. არ იქნება უკეთესი, თუ აქ მომხმარებლის სახელს გადასცემთ და შემდეგ, იმის ნაცვლად, რომ თქვათ "გამარჯობა", მომხმარებლის სახელი დაბეჭდოთ?
ამის გაკეთება შეგიძლიათ განსაზღვრული ფუნქციის ფრჩხილებში პარამეტრების დამატებით. ნება მომეცით გაჩვენოთ:
def greet_user(name):
print('Hi there!')
print('Welcome aboard!')
ახლა "name
” ფრჩხილებში იმოქმედებს ლოკალური ცვლადის მსგავსად და ჩვენ შეგვიძლია გადავიტანოთ მომხმარებლის სახელი მისი დარეკვისას.
greet_user('Shahbaz')
ახლა სახელის პარამეტრი დაყენებულია "Shahbaz
“. მოდით შევცვალოთ პროგრამა, რომ გამოვიყენოთ იგი.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
print('finish')
მნიშვნელოვანია აღინიშნოს, რომ პირველ სტრიქონში „სახელს“ ეწოდება პარამეტრი, ხოლო მოწოდებულ სახელს, ანუ შაჰბაზს, ეწოდება არგუმენტი.
მოდით წავიდეთ წინ და გავუშვათ ეს პროგრამა.
ასე რომ, ამ პარამეტრებით, ჩვენ შეგვიძლია მივიღოთ ინფორმაცია ჩვენს ფუნქციებში.
ახლა მოდით გავაკეთოთ რაიმე საინტერესო. დავუშვათ, რომ გსურთ მისალოცი შეტყობინებას სხვა სახელის დამატება. Ეს მარტივია.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
greet_user('Aayush')
print('finish')
ახლა გაითვალისწინეთ, რომ როდესაც ფუნქციას აქვს პარამეტრი, ჩვენ ვალდებულნი ვართ გადავცეთ მნიშვნელობა ამ პარამეტრისთვის. თუ ფუნქციიდან სახელს ამოიღებთ და პროგრამას გაუშვით, შეცდომას მივიღებთ. თქვენ ასევე შეგიძლიათ გამოიყენოთ მრავალი პარამეტრი ერთ ფუნქციაში, გამოყოფილი მძიმით.
მაგალითად, greet_user(first_name, last_name):
. არგუმენტები ასევე იქნება ფორმატირებული ანალოგიურად.
საკვანძო სიტყვების არგუმენტები
ჯერჯერობით, ჩვენ ვისწავლეთ, რომ როდესაც ჩვენ განვსაზღვრავთ პარამეტრებს ჩვენი ფუნქციებისთვის, ყოველთვის უნდა მივაწოდოთ მნიშვნელობები, წინააღმდეგ შემთხვევაში მივიღებთ შეცდომას. ბოლო პროგრამაში არგუმენტები 'Shahbaz'
მდე 'Bhatti'
ეწოდება პოზიციური არგუმენტები, რაც ნიშნავს მათ პოზიციას ან წესრიგის საკითხებს პროგრამაში.
პითონში გვაქვს სხვა სახის არგუმენტი, სახელწოდებით საკვანძო სიტყვების არგუმენტები, რომლის პოზიციას მნიშვნელობა არ აქვს. ნება მომეცით გაჩვენოთ, როგორ მუშაობენ ისინი.
გადახედე ბოლო პროგრამას. ჩვენ შეგვიძლია შევცვალოთ იგი შემდეგნაირად:
def greet_user(first_name, last_name):
print(f'Hi {first_name} {last_name}')
print('Welcome aboard!')
print('start')
greet_user(first_name='Shahbaz', last_name='Bhatti')
print('finish')
ახლა first_name
მდე last_name
არის საკვანძო სიტყვის პარამეტრები. თქვენ შეგიძლიათ შეცვალოთ მათი ადგილები და შედეგი იგივე იქნება.
ახლა ეს არ ნიშნავს, რომ ყოველთვის უნდა გამოვიყენოთ საკვანძო სიტყვების არგუმენტები. უმეტესად ჩვენ ვიყენებთ პოზიციურ არგუმენტებს, მაგრამ გარკვეულ სიტუაციებში, ეს საკვანძო არგუმენტები გვეხმარება გავაუმჯობესოთ ჩვენი კოდის წაკითხვა.
კიდევ ერთი რამ უნდა იცოდეთ საკვანძო სიტყვების არგუმენტების შესახებ. საკვანძო სიტყვის არგუმენტები ყოველთვის უნდა მოდიოდეს პოზიციური არგუმენტების შემდეგ.
დაბრუნების განცხადება
აქამდე ჩვენ ვისწავლეთ როგორ შევქმნათ ფუნქციები და გავაგზავნოთ ინფორმაცია მათი პარამეტრების გამოყენებით. ახლა მოდით ვისწავლოთ როგორ შევქმნათ ფუნქციები, რომლებიც აბრუნებენ მნიშვნელობებს. ეს განსაკუთრებით სასარგებლოა, თუ თქვენ აკეთებთ რაიმე სახის გამოთვლებს და გსურთ დააბრუნოთ შედეგი მას, ვინც იყენებს თქვენს ფუნქციას. ნება მომეცით გაჩვენოთ.
განვსაზღვროთ ფუნქცია, რომელიც გამოთვლის რიცხვის კვადრატს.
def square(number):
return number*number
ჩვენ გამოვიყენეთ დაბრუნების განცხადება ამ ნომრის დასაბრუნებლად ფუნქციის გარეთ. ახლა, თუ ჩვენ მოვუწოდებთ ამ ფუნქციას, ის აბრუნებს მნიშვნელობას, ისევე როგორც input()
ფუნქცია. მოდით დავბეჭდოთ ტერმინალზე.
შეგიძლიათ ამტკიცებდეთ, რომ იგივე შედეგის მიღება შესაძლებელია დაბრუნების განცხადების გამოყენების გარეშე. მოდით შევამოწმოთ.
ჩვენ ვხედავთ ორ რამეს, რიცხვს 9 და არცერთს. რა ხდება აქ?
როდესაც პითონის თარჯიმანი შეასრულებს ამ კოდს, ჯერ გამოიძახებს კვადრატულ ფუნქციას და კონტროლი გადადის ფუნქციაზე. აქ ვიანგარიშებთ მოცემული რიცხვის კვადრატს და შემდეგ ვბეჭდავთ მას ტერმინალზე.
ახლა, ნაგულისხმევად, ყველა ფუნქცია არ აბრუნებს მნიშვნელობას არცერთი. ასე რომ, თუ ჩვენ არ გვაქვს დაბრუნების განცხადება აქ, ნაგულისხმევად Python არ აბრუნებს არცერთს. არცერთი არ არის ობიექტი, რომელიც წარმოადგენს მნიშვნელობის არარსებობას. ეს არაფერია ან ნულოვანია C, C++, Java და Javascript-ში.
Გახვევა!
იმედი მაქვს, გესმით ფუნქციების მნიშვნელობა.
ისინი პითონის სწავლის მნიშვნელოვანი ასპექტია, თუ თქვენ გეგმავთ დიდი და რთული პროგრამების დაწერას თქვენი კოდირების კარიერის განმავლობაში.
დატოვე პასუხი