Back to the topics list

pagtukoy ng mga function

Pagtukoy sa mga Function

Sa araling ito, malalaman natin ang tungkol sa mga function. Ang isang function ay isang maliit na bloke ng mga tagubilin, tulad ng isang recipe, na nagsasabi sa computer kung ano ang gagawin. Tinutulungan tayo ng mga function na hatiin ang malalaking problema sa maliliit na piraso. Pinapadali nila ang ating trabaho at mas malinaw ang ating mga programa. Ngayon, makikita natin kung ano ang mga function, bakit natin ginagamit ang mga ito, at kung paano tayo tinutulungan ng mga ito na lumikha ng mga program sa simpleng paraan.

Panimula

Isipin na mayroon kang isang laruang makina na palaging gumagawa ng parehong trabaho. Kapag pinindot mo ang isang pindutan, kumakanta ang makina ng isang kanta. Ang isang function sa isang computer program ay gumagana sa katulad na paraan. Ito ay isang hanay ng mga tagubilin na maaari mong gamitin nang paulit-ulit. Tinukoy mo ang function nang isang beses, at pagkatapos ay maaari mo itong tawagan tuwing kailangan mo itong gamitin. Ang ideyang ito ay ginagawang mas madaling maunawaan at mas mabilis ang pagbuo ng mga programa.

Sa ating pang-araw-araw na buhay, sinusunod natin ang mga hakbang upang gawin ang mga bagay. Halimbawa, kapag nagsipilyo ka o gumawa ng sandwich, sinusunod mo ang mga simpleng hakbang sa pagkakasunud-sunod. Ang isang function ay tulad ng mga hakbang na iyon. Sa halip na paalalahanan ang iyong sarili kung paano gawin ang mga trabahong ito sa bawat oras, natatandaan mo ang mga hakbang o pindutin ang isang pindutan na gumagawa nito para sa iyo.

Ano ang isang Function?

Ang isang function ay isang pinangalanang bloke ng code na nagsasagawa ng isang partikular na gawain. Maaari mong isipin ito bilang isang mini-program sa loob ng iyong mas malaking programa. Ang mga function ay isinulat upang maisagawa ang isang maliit na gawain. Maaari silang magdagdag ng mga numero, kamustahin ang isang tao, o kahit na gumuhit ng mga larawan sa screen. Ang ideya ay upang itago ang mga detalye ng gawain sa loob ng function. Sa ganoong paraan, kailangan mo lamang na tawagan ang function sa pamamagitan ng pangalan nito kapag kailangan mong gawin ang gawain.

Halimbawa, ang isang simpleng function ay maaaring magmukhang switch ng ilaw. Kapag pinindot mo ang switch, bumukas ang ilaw. Katulad nito, kapag tumawag ka ng isang function, ginagawa ng computer ang mga aksyon sa loob nito. Pinapanatili nitong maayos ang iyong trabaho at ginagawa itong simple upang mahanap at ayusin ang anumang mga problema.

Bakit Namin Gumagamit ng Mga Pag-andar?

Maraming magandang dahilan para gumamit ng mga function sa programming. Una, tinutulungan kami ng mga function na ayusin ang aming trabaho. Sa halip na isulat ang parehong mga tagubilin nang maraming beses, isinusulat namin ang mga ito nang isang beses sa isang function at pagkatapos ay tinatawagan ang function kapag kinakailangan. Makakatipid ito ng oras at maiiwasan ang mga pagkakamali. Pangalawa, tinutulungan kami ng mga function na muling gamitin ang code. Kapag natukoy na ang isang function, maaari itong magamit sa maraming bahagi ng aming programa. Pangatlo, pinapadali ng mga function na basahin ang mga programa. Kapag ang isang gawain ay nahahati sa mas maliliit na function, maaari mong tingnan ang mga pangalan ng mga function upang maunawaan kung ano ang ginagawa ng program.

Isipin na nagtatayo ka ng isang malaking kastilyo ng LEGO. Gumagamit ka ng maliliit na bloke para itayo ang buong kastilyo. Ang bawat maliit na bloke ay tulad ng isang function na gumaganap ng isang partikular na trabaho. Kapag pinagsama-sama ang lahat ng mga bloke, mayroon kang kumpletong kastilyo. Sa parehong paraan, ang mga indibidwal na function ay bumubuo ng isang kumpletong programa.

Paano Tukuyin ang isang Function

Maaari naming tukuyin ang isang function gamit ang isang espesyal na code. Sa maraming programming language, gumagamit kami ng keyword na nagsasabi sa computer na gumagawa kami ng function. Ang isang tanyag na wika na ginagamit sa pagtuturo ng programming ay Python. Sa Python, ginagamit namin ang salitang def upang magsimula ng isang function. Narito ang isang simpleng halimbawa:

Halimbawa:

 def say_hello():
    print ("Kumusta, kaibigan!")
  

Sa halimbawang ito, ang function ay tinatawag say_hello . Ang salitang def ay nagsasabi sa computer na kami ay tumutukoy sa isang function. Ang function ay gumagawa ng isang bagay: ito ay nagpi-print ng isang friendly na mensahe sa screen.

Kapag natukoy na natin ang function na ito, magagamit natin ito sa ibang pagkakataon sa ating programa. Ito ay tinatawag na pagtawag sa function. Ipapatupad ng computer ang lahat ng hakbang sa loob ng function sa tuwing tatawagin ito.

Mga Simpleng Halimbawa ng Mga Pag-andar

Ngayon, titingnan natin ang tatlong simpleng halimbawa ng mga function. Madaling maunawaan ang mga ito at tinutulungan kaming matutunan ang mga pangunahing ideya.

Halimbawa 1: Function ng Pagbati

Sa unang halimbawa, lumikha kami ng isang function na bumabati sa isang tao sa pamamagitan ng pangalan. Kapag tinawagan namin ang function, ito ay makikipag-hello sa isang kaibigan.

Code:

 def greet(pangalan):
    print("Hello, " + pangalan + "!")
  
# Pagtawag sa function na may pangalang "Alice"
batiin("Alice")
  

Hakbang-hakbang na Paliwanag:

• Ang function greet ay tinukoy sa isang parameter na tinatawag na pangalan .
• Kapag tinawag ang function, kailangan nito ang value na ipinasa mo (tulad ng "Alice") at nagpi-print ng "Hello, Alice!" sa screen.
• Ang function ay maaaring tawagan sa anumang pangalan, at ito ay palaging magpapakita ng isang magiliw na pagbati.

Halimbawa 2: Pag-andar ng Pagdaragdag

Sa pangalawang halimbawa, nagsusulat kami ng isang function na nagdaragdag ng dalawang numero. Ito ay tulad ng isang mini calculator na nagdaragdag ng mga numero nang magkasama.

Code:

 def add_numbers(num1, num2):
    resulta = num1 + num2
    print("Ang kabuuan ay:", resulta)
  
# Pagtawag sa function na may mga numero 3 at 5
add_numbers(3, 5)
  

Hakbang-hakbang na Paliwanag:

• Ang function na add_numbers ay tinukoy na may dalawang parameter: num1 at num2 .
• Sa loob ng function, ang dalawang numero ay idinagdag nang magkasama. Ang kabuuang ito ay nakaimbak sa isang variable na tinatawag na resulta .
• Ang function ay pagkatapos ay nagpi-print ng "Ang kabuuan ay:" na sinusundan ng halaga ng resulta .
• Kapag tinawag namin ang add_numbers(3, 5) , ang function ay nagdaragdag ng 3 at 5 upang magbigay ng 8, na pagkatapos ay naka-print.

Halimbawa 3: Multiplication Function

Sa ikatlong halimbawa, gagawa kami ng function na nagpaparami ng numero sa 2. Ipinapakita ng function na ito kung paano makakapagbalik ng value ang isang function para magamit sa ibang pagkakataon.

Code:

 def multiply_by_two(x):
    new_value = x * 2
    ibalik ang new_value
  
# Pagtawag sa function at pag-save ng resulta
resulta = multiply_by_two(4)
print("4 na pinarami ng 2 ay", resulta)
  

Hakbang-hakbang na Paliwanag:

• Ang function na multiply_by_two ay tinukoy sa isang parameter x .
• Sa loob ng function, ang halaga ng x ay pinarami ng 2 at nakaimbak sa isang variable na tinatawag na new_value .
• Ginagamit ng function ang return keyword upang ipasa ang resulta pabalik sa kung saan tinawag ang function.
• Kapag tinawag namin ang multiply_by_two(4) , kinakalkula ng function na ang 4 na pinarami ng 2 ay 8 at ibinabalik ang halagang ito.
• Ang ibinalik na halaga ay naka-imbak sa isang variable na pinangalanang resulta , na pagkatapos ay naka-print.

Pag-unawa sa Mga Parameter at Mga Halaga ng Pagbabalik

Ang mga function ay maaaring tumanggap ng impormasyon mula sa labas sa pamamagitan ng mga parameter . Ang parameter ay isang variable na nagtataglay ng data kapag tinawag ang isang function. Sa aming mga halimbawa, name , num1 , num2 , at x ay mga parameter.

Ang ilang mga function ay nagbabalik ng mga halaga. Ang isang return value ay ang resulta na ibinalik ng function pagkatapos gawin ang trabaho nito. Sa Halimbawa 3, ang function na multiply_by_two ay nagbabalik ng isang halaga na pagkatapos ay maiimbak sa isang variable.

Ang ideya ng paggamit ng mga parameter at return value ay ginagawang flexible at malakas ang mga function. Maaari mong baguhin ang input upang makakuha ng iba't ibang mga output, tulad ng pagpapalit ng mga sangkap sa isang recipe ay maaaring humantong sa iba't ibang panlasa.

Modular Programming: Paghiwa-hiwalay ng mga Problema

Ang mga function ay isang mahalagang ideya sa modular programming . Ang modular programming ay nangangahulugan ng paghahati ng isang malaking programa sa mas maliit, mapapamahalaang bahagi o module. Ang bawat function ay parang isang module na gumagawa ng isang simpleng gawain. Kapag ang lahat ng mga module ay nagtutulungan, sila ay bumubuo ng isang kumpletong programa.

Mag-isip ng pagbuo ng isang palaisipan. Ang bawat piraso ay maliit at simple. Ngunit kapag pinagsama mo ang lahat ng mga piraso, makikita mo ang isang kumpletong larawan. Sa programming, ang paggamit ng mga function ay hinahayaan kang magtrabaho sa isang maliit na piraso sa isang pagkakataon. Sa ganitong paraan, mas madaling bumuo, maunawaan, at ayusin ang mga programa.

Nakakatulong ang modular programming na bawasan ang pag-uulit. Kung ang isang bahagi ng iyong programa ay kailangang gawin ang parehong trabaho nang paulit-ulit, sumulat ka ng isang function para dito. Pagkatapos sa tuwing kailangan mong gawin ang trabahong iyon, tatawagan mo lang ang function sa halip na isulat ang parehong code.

Ang diskarte na ito ay tulad ng pagkakaroon ng isang katulong na marunong magtali ng mga sintas ng sapatos, kaya hindi mo na kailangang muling matutunan kung paano ito gawin sa tuwing makakakuha ka ng bagong pares ng sapatos.

Relatable Araw-araw na Halimbawa

Ihambing natin ang mga function sa pang-araw-araw na gawain. Isipin na marami kang gawain sa bahay. Isa sa mga gawain mo ay ang pagdidilig ng mga halaman. Sa halip na isipin ang lahat ng mga hakbang sa bawat oras, maaari mong tandaan, "Diligan ang mga halaman." Sa bawat oras na nagtatrabaho ka sa mga halaman, ginagamit mo ang iyong sariling function.

Ang isa pang halimbawa ay ang paggawa ng sandwich. Una, kumuha ka ng dalawang hiwa ng tinapay. Pagkatapos, magdagdag ka ng mantikilya, keso, at maaaring isang slice ng ham. Sa wakas, pinagsama mo ang dalawang hiwa. Ang bawat hakbang ay malinaw at simple, tulad ng mga linya ng isang function. Sa pamamagitan ng pagsunod sa mga hakbang sa bawat oras, lumikha ka ng masarap na sandwich nang hindi kinakailangang isipin ang bawat hakbang mula sa simula.

Ang mga pang-araw-araw na halimbawang ito ay nagpapakita na ang mga function ay tumutulong sa amin na gawin ang maraming gawain sa pamamagitan ng paghahati-hati sa mga ito sa malinaw at simpleng mga bahagi.

Higit Pa Tungkol sa Pagtukoy ng Mga Function

Kapag nagsimula kang matuto tungkol sa mga function, mapapansin mo na ang bawat function ay may pangalan , isang listahan ng mga parameter sa loob ng mga panaklong, at isang bloke ng code sa loob. Maaaring ganito ang hitsura nito sa isang simpleng format:

Pangkalahatang Istraktura:

 def function_name(parameter1, parameter2, ...):
    # block ng code
    ibalik ang some_value # kung kinakailangan
  

Dito, ang function_name ay ang pangalan ng function. Ang mga parameter ay mga input na ginagamit ng function. Ang code block ay ang hanay ng mga tagubilin na isasagawa ng function. Sa wakas, ibabalik ang resulta.

Minsan maaari kang makakita ng mga function na walang anumang mga parameter. Kapag ang isang function ay hindi nangangailangan ng anumang karagdagang impormasyon, isinusulat mo pa rin ang mga panaklong, ngunit nananatiling walang laman ang mga ito. Katulad nito, maraming mga function ang nagsasagawa ng mga aksyon tulad ng pag-print ng mga mensahe at hindi nagbabalik ng anumang halaga.

Mahahalagang Katangian ng Mga Pag-andar

Narito ang ilang mahahalagang katangian ng mga function na dapat mong tandaan:

• Reusability: Kapag natukoy na ang isang function, maaari mo itong gamitin nang maraming beses nang hindi muling isinusulat ang parehong code.
• Modularity: Tumutulong ang mga function na hatiin ang program sa mas maliliit na bahagi. Ang bawat bahagi ay gumagawa ng isang partikular na trabaho.
• Pagpapanatili: Kung may error o kailangan ng pagbabago, maaari mong ayusin ang isang function lang sa halip na maraming linya ng code.
• Kalinawan: Ginagawang madaling basahin ng mga function ang program. Sa halip na magbasa ng maraming code, makakakita ka ng malinaw na mga pangalan ng function na nagsasabi sa iyo kung ano ang ginagawa ng bawat bahagi.

Sa pamamagitan ng pagsunod sa mga katangiang ito, makakagawa ang mga programmer ng mga program na mas madaling maunawaan, i-debug, at mapabuti sa paglipas ng panahon. Tulad ng pagpapanatiling malinis sa iyong silid sa pamamagitan ng pag-uuri ng iyong mga laruan sa mga kahon, pinapanatili ng mga function ang mga programa na maayos at maayos.

Mga Variation at Higit pang Advanced na Ideya

Habang nagiging mas komportable ka sa ideya ng mga function, maaari kang makatagpo ng ilang mga pagkakaiba-iba. Minsan ang mga pag-andar ay hindi nagbabalik ng anuman; kilos lang ang ginagawa nila. Sa ibang pagkakataon, maaaring tumawag ang mga function sa iba pang function. Ito ay kilala bilang nesting function o function composition.

Halimbawa, maaaring tumawag ang isang function sa isang greeting function bago ito magsimulang gumawa ng isa pang gawain. Hinahayaan ka ng layering na ito ng mga function na bumuo ng mga kumplikadong programa mula sa maraming maliliit at simpleng gawain.

Sa susunod na yugto, maaari mong tuklasin ang mga paksa tulad ng mga recursive function . Ang recursive function ay isa na tumatawag sa sarili nito. Bagama't medyo nakakalito ang ideyang ito, isa lang itong paraan para hatiin ang mga problema sa maliliit na bahagi. Sa ngayon, sapat na na malaman na ang mga function ay nakakatulong sa iyo na magsulat ng matalino at malinis na code.

Mga Karagdagang Halimbawa at Step-by-Step na Solusyon

Tingnan natin ang dalawang mas detalyadong halimbawa na nagpapakita kung paano gumagana ang mga function nang sunud-sunod.

Halimbawa 4: Isang Pag-andar upang Suriin ang Mga Even Number

 def is_even(number):
    # Suriin kung pantay ang numero
    kung numero % 2 == 0:
        ibalik ang Totoo
    iba pa:
        ibalik Mali

# Gamit ang function upang suriin ang numero 6
resulta = is_even(6)
print("Ang 6 ba ay pantay?", resulta)
  

Hakbang-hakbang na Paliwanag:

• Ang function na is_even ay tumatagal ng isang parameter na pinangalanang numero .
• Sinusuri nito kung ang numerong hinati sa 2 ay walang natitira gamit ang modulus operator % .
• Kung walang natitira, ibabalik ng function ang True , na nangangahulugang pantay ang numero.
• Kung may natitira, ibabalik ng function ang False .
• Kapag tinawag ang is_even(6) , sinusuri ng function at nalaman na ang 6 ay pantay, kaya nagbabalik ito ng True .

Halimbawa 5: Isang Function para Kalkulahin ang Lugar ng isang Square

 def area_of_square(side_length):
    # Kalkulahin ang lugar gamit ang formula: area = side_length * side_length
    area = side_length * side_length
    lugar ng pagbabalik

# Gamit ang function upang kalkulahin ang lugar ng isang parisukat na may haba ng gilid na 5
square_area = area_of_square(5)
print("Ang lugar ng parisukat ay", square_area)
  

Hakbang-hakbang na Paliwanag:

• Ang function na area_of_square ay gumagamit ng side_length bilang isang parameter.
• Sa loob ng function, pinaparami nito ang haba ng gilid sa pamamagitan ng sarili nito. Ito ay sumusunod sa mathematical formula \(\textrm{Lugar} = \textrm{gilid\_haba} \times \textrm{gilid\_haba}\) .
• Ang kinakalkula na lugar ay ibabalik sa pangunahing bahagi ng programa.
• Kapag tinawag namin ang area_of_square(5) , kino-compute ng function \(5 \times 5\) upang magbigay ng 25.

Halimbawa 6: Isang Tungkulin upang Matukoy ang Mas Malaki sa Dalawang Numero

 def mas malaking_number(a, b):
    # Ihambing ang dalawang numero at ibalik ang mas malaki
    kung a > b:
        ibalik a
    iba pa:
        bumalik b

# Gamit ang function upang mahanap ang mas malaking numero sa pagitan ng 7 at 10
pinakamalaking = mas malaking_number(7, 10)
print("Ang mas malaking bilang ay", pinakamalaki)
  

Hakbang-hakbang na Paliwanag:

• Ang function na greater_number ay tumatagal ng dalawang parameter: a at b .
• Inihahambing nito ang dalawang numero.
• Kung ang a ay mas malaki kaysa sa b , ito ay nagbabalik ng a . Kung hindi, ito ay nagbabalik b .
• Sa halimbawa, ang large_number(7, 10) ay nagbabalik ng 10 dahil ang 10 ay mas malaki sa 7.

Bakit Mahalaga ang Mga Function para sa Modularity

Ang mga function ay isang mahusay na tool na tumutulong sa amin na bumuo ng mga programa sa isang modular na paraan. Gamit ang mga function, maaari kang lumikha ng mga hiwalay na bahagi ng iyong programa na gumagana nang nakapag-iisa. Nangangahulugan ito na kung ang isang bahagi ng iyong programa ay may pagkakamali o nangangailangan ng pagpapabuti, kailangan mo lang ayusin ang isang function na iyon sa halip na tumingin sa isang malaking masa ng code.

Ang modular programming ay parang pagbuo gamit ang mga bloke ng LEGO. Ang bawat bloke ay independyente at maaaring ikonekta sa iba't ibang paraan upang lumikha ng iba't ibang mga istraktura. Kung masira ang isang bloke, maaari mo itong palitan nang hindi na muling itayo ang buong kastilyo. Gamit ang mga function, ang bawat maliit na seksyon ng iyong programa ay maaaring buuin, subukan, at ayusin sa sarili nitong.

Ang ganitong paraan ng programming ay tumutulong sa iyo na maunawaan ang mga problema nang mas mahusay at ginagawang mas madali ang mga kumplikadong gawain. Itinuturo din nito sa iyo kung paano mag-isip nang lohikal tungkol sa mga problema at kung paano lutasin ang mga ito nang hakbang-hakbang.

Buod ng Mga Pangunahing Punto

• Kahulugan: Ang isang function ay isang bloke ng code na nagsasagawa ng isang partikular na gawain.
• Reusability: Kapag natukoy na ang isang function, maaari itong magamit nang maraming beses sa isang programa.
• Structure: Tinutukoy ang mga function gamit ang isang espesyal na keyword (tulad ng def sa Python) at maaaring magsama ng mga parameter at return value.
• Mga Simpleng Halimbawa: Tumingin kami sa mga function para batiin ang isang tao, magdagdag ng mga numero, paramihin ang isang numero sa dalawa, tingnan kung pantay ang isang numero, kalkulahin ang isang lugar, at paghambingin ang dalawang numero.
• Modular Programming: Tumutulong ang mga function na hatiin ang isang malaking problema sa mas maliliit at mas madaling bahagi. Ginagawa nitong mas madaling isulat, basahin, at ayusin ang mga program.
• Pang-araw-araw na Paghahambing: Tulad ng pagsunod sa isang recipe o paggamit ng maliliit na bloke ng LEGO upang bumuo ng isang malaking istraktura, tinutulungan tayo ng mga function na ayusin ang mga gawain sa ating pang-araw-araw na buhay.
• Kakayahang umangkop: Ang mga parameter ay nagbibigay-daan sa mga function na gumana sa iba't ibang mga input, at ang mga return value ay nagbibigay sa amin ng kakayahang gamitin ang mga resulta.
• Real-World Impact: Ang mga function at modular programming ay ang pagbuo ng modernong teknolohiya, na ginagamit sa mga laro, app, at maraming pang-araw-araw na sistema ng buhay.

Sa konklusyon, ang mga function ay isang mahalagang bahagi ng programming. Nagbibigay-daan sila sa amin na magsulat ng malinis, malinaw, at madaling maunawaang code. Sa pamamagitan ng paggamit ng mga function, malulutas natin ang malalaking problema sa pamamagitan ng paghahati-hati sa mga ito sa maliliit, mapapamahalaang gawain. Kung ito man ay pagbati sa isang kaibigan, pagsasagawa ng kalkulasyon, o pagsuri kung ang isang numero ay pantay, ang mga function ay nakakatulong na gawing simple at masaya ang aming mga programa.

Laging tandaan: ang bawat malaking gawain ay maaaring gawing mas madali sa pamamagitan ng paggamit ng maliliit na hakbang, at ang maliliit na hakbang na iyon ay ang mga function sa iyong programa.

Patuloy na matuto, mag-explore, at magsaya sa programming. Ang mga function ay ang unang hakbang sa pagsulat ng malikhain at kapaki-pakinabang na code!