Pag-andar
Sa ngayon, isinusulat namin ang lahat ng aming code sa app.py, ngunit habang lumalaki ang aming mga programa, kailangan namin ng mas mahusay na paraan upang ayusin ang aming code. Kailangan nating hatiin ang ating code sa mas maliit, mas mapapamahalaan, at mas mapanatili na mga tipak na tinatawag nating mga function. Ang function ay isang lalagyan para sa ilang linya ng code na gumaganap ng isang partikular na gawain.
Halimbawa, natutunan mo na ang tungkol sa ilang mga built-in na function sa Python print()
at input()
. Ang bawat function ay may layunin at alam kung paano magsagawa ng isang partikular na gawain. Kaya, kapag bumuo tayo ng malalaking kumplikadong mga programa, dapat nating hatiin ang ating code sa mas maliliit na reusable chunks, ibig sabihin, mga function.
Unawain natin ang konseptong ito sa pamamagitan ng pagbuo ng isang programa para sa pag-print ng mensahe ng pagbati.
print('Hi there!')
print('Welcome aboard!')
Narito mayroon kaming isang simpleng programa na may dalawang linya lamang ng code. Ngayon, sabihin natin, kakailanganin natin ang mga ito sa iba pang mga program upang mailagay ang mga ito sa isang function na maaari nating gamitin muli.
Hayaan akong magpakilala ng nakalaan na keyword def
sa Python, na maikli para sa define at ginagamit para sa pagtukoy ng isang function.
def greet_user():
print('Hi there!')
print('Welcome aboard!')
Ngayon ang bloke ng code na ito ay tutukuyin ang isang function "greet_user
” na may mga linya ng code pagkatapos noon. Sa tuwing tinatawag ang function na ito, ang dalawang linyang ito ay isasagawa. Gamitin natin ito:
print('start')
greet_user()
print('finish')
Ang programa ay isinasagawa nang sunud-sunod, ibig sabihin ay kailangan mong tukuyin ang isang function bago ito tawagan sa programa.
parameter
Ang tinukoy na mga pag-andar ay gumagana nang medyo naiiba kaysa sa mga built-in na function ng Python. Halimbawa, sa kaso ng print()
isang function, ito ay nangangailangan ng ilang impormasyon na gusto naming i-print, ngunit ang aming greet function ay hindi kumukuha ng anumang impormasyon. Hindi ba't mas maganda kung maaari mong ipasa ang pangalan ng gumagamit dito at pagkatapos, sa halip na sabihin ang "hi there", maaari mong i-print ang pangalan ng gumagamit?
Magagawa mo ito sa pamamagitan ng pagdaragdag ng mga parameter sa loob ng panaklong ng tinukoy na function. Hayaan mo akong ipakita sa iyo:
def greet_user(name):
print('Hi there!')
print('Welcome aboard!')
Ngayon ang "name
” sa loob ng panaklong ay magsisilbing isang lokal na variable at maaari naming ipasa ang pangalan ng gumagamit kapag tinatawag ito.
greet_user('Shahbaz')
Ngayon ang parameter ng pangalan ay nakatakda sa "Shahbaz
”. Baguhin natin ang program para magamit ito.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
print('finish')
Ang isang mahalagang bagay na dapat tandaan ay ang "pangalan" sa unang linya ay tinatawag na isang Parameter samantalang ang pangalan na ibinigay ie Shahbaz ay tinatawag na isang argumento.
Halina't patakbuhin ang programang ito.
Kaya sa mga parameter na ito, makakatanggap kami ng impormasyon sa aming mga function.
Ngayon, gumawa tayo ng isang bagay na kawili-wili. Sabihin nating gusto mong magdagdag ng isa pang pangalan sa mensahe ng pagbati. Simple lang.
def greet_user(name):
print(f'Hi {name}')
print('Welcome aboard!')
print('start')
greet_user('Shahbaz')
greet_user('Aayush')
print('finish')
Ngayon tandaan na kapag may parameter ang isang function, obligado kaming magpasa ng value para sa parameter na iyon. Kung aalisin mo ang pangalan sa function at patakbuhin ang program, magkakaroon kami ng error. Maaari ka ring gumamit ng maraming parameter sa iisang function, na pinaghihiwalay ng kuwit.
Halimbawa, greet_user(first_name, last_name):
. Ang mga argumento ay ipo-format din nang katulad.
Mga Pangangatwiran ng Keyword
Sa ngayon, natutunan namin na sa tuwing tutukuyin namin ang mga parameter para sa aming mga pag-andar dapat kaming palaging magbigay ng mga halaga kung hindi ay magkakaroon kami ng error. Sa huling programa, ang mga argumento 'Shahbaz'
at 'Bhatti'
ay tinatawag na positional arguments, ibig sabihin ang kanilang posisyon o kaayusan ay mahalaga sa programa.
Sa Python, mayroon kaming isa pang uri ng argumento na tinatawag na keyword arguments, kung saan hindi mahalaga ang posisyon. Hayaan mong ipakita ko sa iyo kung paano sila gumagana.
Tingnan ang huling programa. Maaari naming baguhin ito tulad nito:
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')
Ngayon ang first_name
at last_name
ay ang mga parameter ng keyword. Maaari mong ilipat ang kanilang mga lugar at ang resulta ay magiging pareho.
Ngayon ay hindi nangangahulugan na dapat tayong palaging gumamit ng mga argumento ng keyword. Kadalasan, gumagamit kami ng mga positional na argumento, ngunit sa ilang partikular na sitwasyon, nakakatulong sa amin ang mga argumentong keyword na ito na pahusayin ang pagiging madaling mabasa ng aming code.
May isa pang bagay na kailangan mong malaman tungkol sa mga argumento ng keyword. Ang mga argumento ng keyword ay dapat palaging kasunod ng mga positional na argumento.
Pahayag ng Pagbabalik
Sa ngayon natutunan namin kung paano lumikha ng mga function at magpadala sa kanila ng impormasyon gamit ang kanilang mga parameter. Ngayon, alamin natin kung paano lumikha ng mga function na nagbabalik ng mga halaga. Ito ay partikular na kapaki-pakinabang kung gumagawa ka ng ilang uri ng mga kalkulasyon at gusto mong ibalik ang resulta sa sinumang gumagamit ng iyong function. Hayaan mo akong ipakita sa iyo.
Tukuyin natin ang isang function na kakalkulahin ang parisukat ng isang numero.
def square(number):
return number*number
Ginamit namin ang return statement para ibalik ang numerong ito sa labas ng function. Ngayon, kung tawagin natin ang function na ito, ito ay nagbabalik ng isang halaga tulad ng input()
function. I-print natin ito sa terminal.
Maaari kang magtaltalan na ang parehong resulta ay maaaring makuha nang hindi gumagamit ng return statement. Tignan natin.
Nakikita natin ang dalawang bagay, ang numero 9, at wala. Ano'ng nangyayari dito?
Kapag pinaandar ng Python interpreter ang code na ito, tatawagin muna nito ang square function at ang control ay lilipat sa function. Dito namin kinakalkula ang parisukat ng ibinigay na numero at pagkatapos ay i-print ito sa terminal.
Ngayon, bilang default, ibinabalik ng lahat ng function ang halagang wala. Kaya't kung wala tayong return statement dito, bilang default, walang ibinabalik ang Python. Wala ay isang bagay na kumakatawan sa kawalan ng isang halaga. Ito ay tulad ng wala o null sa C, C++, Java at Javascript.
Balutin!
Sana ay naunawaan mo ang kahalagahan ng mga function.
Ang mga ito ay isang makabuluhang aspeto ng pag-aaral ng Python kung nagpaplano kang magsulat ng malaki at kumplikadong mga programa sa panahon ng iyong coding career.
Mag-iwan ng Sagot