Ang mga function at modular programming ay mahalagang bahagi ng computer programming. Tinutulungan nila kaming lumikha ng malinaw at madaling maunawaan na mga programa. Ipapaliwanag ng araling ito kung ano ang ibig sabihin ng mga function at modular programming, gamit ang simpleng wika at pang-araw-araw na mga halimbawa. Ang bawat konsepto ay ipinaliwanag nang hakbang-hakbang. Malalaman mo kung ano ang mga function, kung bakit namin ginagamit ang mga ito, at kung paano nila ginagawang organisado at masaya ang aming code. Tuklasin din namin kung paano hinahati ng modular programming ang isang malaking problema sa mas maliit, mapapamahalaang mga piraso.
Ang isang function ay tulad ng isang maliit na makina na gumagawa ng isang trabaho. Sa programming, ang isang function ay isang bloke ng code na nagsasagawa ng isang partikular na gawain kapag ito ay tinawag. Mag-isip tungkol sa isang vending machine. Kapag naglagay ka ng pera, binibigyan ka ng makina ng meryenda. Ang mga hakbang (paglalagay ng pera, pagpili ng meryenda, at pagkuha ng meryenda) ay lahat ng bahagi ng function na ito.
Ang isang function ay kumukuha ng input, pinoproseso ito, at pagkatapos ay nagbabalik ng isang output. Halimbawa, kung ang isang function ay nagdaragdag ng dalawang numero, kinukuha nito ang mga numero bilang input at binibigyan ang kabuuan bilang output. Ang ideyang ito ay katulad ng kung paano mo maaaring paghaluin ang dalawang kulay upang makakuha ng bagong kulay sa sining. Ang mga input ay ang mga kulay, at ang output ay ang bagong kulay.
Ang bawat function ay may ilang mahahalagang bahagi:
Halimbawa, ang isang simpleng function na pinangalanang greet ay maaaring kumuha ng isang pangalan bilang input at magbalik ng isang friendly na pagbati. Ang mga hakbang sa function ay gumagana tulad ng paggawa ng sandwich: pipiliin mo ang iyong mga sangkap, paghaluin ang mga ito, at pagkatapos ay i-enjoy ang sandwich.
Tingnan natin ang isang halimbawa. Ipagpalagay na gusto mo ng isang function na tinatanggap ang isang tao sa pamamagitan ng pangalan. Narito ang hitsura ng function:
def greet(pangalan):
ibalik ang "Hello, " + name + "!"
Sa function na ito:
Ang modular programming ay tungkol sa paghahati ng isang malaking problema sa mas maliit, madaling lutasin na mga bahagi. Ang bawat bahagi ng programa ay ginawa bilang isang hiwalay na module o function. Sa ganitong paraan, ang programa ay nagiging parang palaisipan kung saan magkatugma ang bawat piraso upang mabuo ang buong larawan.
Isipin na gusto mong bumuo ng isang LEGO castle. Sa halip na subukang itayo ang buong kastilyo nang sabay-sabay, hiwalay kang magtatayo ng mga tore, pader, at pinto. Sa ibang pagkakataon, sasali ka sa mga pirasong ito para mabuo ang kumpletong kastilyo. Sa programming, ang modular programming ay parang pagbuo ng mga piraso ng LEGO. Ang bawat piraso (function o module) ay gumagawa ng sarili nitong trabaho.
Maraming dahilan para gumamit ng mga function at modular programming:
Ang mga ideyang ito ay tumutulong sa mga programmer na pamahalaan ang mga kumplikadong problema at bumuo ng mas malalaking proyekto sa simpleng paraan.
Narito ang higit pang mga halimbawa na nagpapakita sa iyo ng iba't ibang mga function at kung paano gumagana ang mga ito.
Ang function na ito ay magdaragdag ng dalawang numero. Ito ay tulad ng isang magic box na kumukuha ng dalawang numero at nagbibigay sa iyo ng kanilang kabuuan.
Halimbawa, ang paglalagay ng 3 at 2 ay nagbibigay ng 5 bilang resulta. Tingnan ang code sa ibaba:
def add(a, b):
ibalik ang a + b
Ang function na ito ay tumutulong sa anumang oras na kailangan mong pagsamahin ang dalawang numero. Katulad ng paghahalo ng dalawang magkaibang kulay para makagawa ng bagong kulay, dito mo paghaluin ang dalawang numero para makuha ang kabuuan ng mga ito.
Ang function na ito ay nagsasabi sa iyo kung ang isang numero ay pantay o kakaiba. Ang isang even na numero ay maaaring hatiin nang pantay-pantay ng 2, habang ang isang kakaibang numero ay hindi maaaring.
Isipin na mayroon kang isang basket ng mansanas. Kung susubukan mong ilagay ang mga mansanas sa mga pares at isang mansanas ang naiwan, kung gayon ang bilang na iyon ay kakaiba. Ang function ay gumagana tulad ng isang simpleng pagsubok:
def check_number(num):
kung bilang % 2 == 0:
ibalik ang "kahit"
iba pa:
ibalik ang "kakaiba"
Kapag nag-input ka ng isang numero, ang function ay nagsasagawa ng pagsusuri gamit ang modulo operator (na hahanapin ang natitira pagkatapos ng dibisyon). Kung ang natitira kapag hinati sa 2 ay zero, ito ay nagbabalik ng "kahit"; kung hindi, ito ay nagbabalik ng "kakaiba".
Ang function na ito ay tumatagal ng isang pangalan bilang input at nagbabalik ng isang personalized na pagbati. Halimbawa, kung ibibigay mo ang pangalang "Alice", ang magiging output ay "Hello, Alice!"
def create_greeting(pangalan):
ibalik ang "Hello, " + name + "!"
Ang simpleng halimbawang ito ay nagpapakita kung paano magagamit ang mga function upang lumikha ng mga friendly na mensahe. Gumagana ang bawat function call tulad ng pag-ring ng doorbell at pagtanggap ng mainit na pagtanggap.
Sa modular programming, madalas kang gumagamit ng mga function sa loob ng iba pang function. Ito ay tinatawag na "composition ng function." Ito ay katulad ng paggawa ng sandwich gamit ang iba't ibang sangkap.
Isaalang-alang ang isang programa na lumilikha ng isang buong pagkain. Maaaring mayroon kang hiwalay na mga function upang gumawa ng salad at sandwich. Pagkatapos, isa pang function ang tumatawag sa mga function na ito upang maghatid ng kumpletong pagkain.
def make_salad():
ibalik ang "Fresh salad"
def make_sandwich():
ibalik ang "Masarap na sandwich"
def make_meal():
salad = make_salad()
sandwich = gumawa_sandwich()
ibalik ang salad + " na may " + sandwich
Sa pamamagitan ng pagsasama-sama ng maliliit na function make_salad at make_sandwich , ang make_meal function ay gumagawa ng kumpletong mensahe. Kung kailangan mong baguhin ang recipe ng sandwich, babaguhin mo lang ang function na make_sandwich , hindi ang buong code ng pagkain.
Kapag mayroon kang malaking problema, mas madaling malutas sa pamamagitan ng paghahati-hati nito sa mga bahagi. Ang bawat maliit na bahagi ay maaaring malutas sa pamamagitan ng isang function. Ito ang pangunahing ideya ng modular programming.
Isipin na mayroon kang isang napakagulong silid. Sa halip na linisin ito nang sabay-sabay, maaari kang gumawa ng plano:
Ang bawat hakbang ay simple at madali. Kapag natapos mo ang lahat ng mga hakbang, ang iyong silid ay malinis. Sa programming, ang bawat hakbang ay pinamamahalaan ng isang function. Ginagawa nitong mas madali ang paglutas ng problema.
Ang module ay isang file na naglalaman ng ilang function. Kapag gumawa ka ng module, gagawin mong magagamit muli at organisado ang iyong code. Halimbawa, maaari kang lumikha ng isang module na tinatawag na math_tools na mayroong mga function para sa pangunahing arithmetic.
Sa math_tools , maaaring mayroon kang mga function tulad ng add , subtract , multiply , at divide . Pagkatapos, maaari mong gamitin ang math_tools sa maraming iba't ibang mga programa nang hindi muling sinusulat ang code.
# Ito ay isang halimbawa ng isang module na pinangalanang math_tools.py
def add(a, b):
ibalik ang a + b
def subtract(a, b):
ibalik ang a - b
def multiply(a, b):
ibalik ang isang * b
def divide(a, b):
kung b != 0:
ibalik ang a / b
iba pa:
bumalik "Hindi mahati sa zero!"
Sa pamamagitan ng pag-import ng module na ito sa iyong program, maaari mong tawagan ang mga function sa tuwing kailangan mo ang mga ito. Makakatipid ito ng oras at mapanatiling maayos ang iyong trabaho.
Kapag gumamit ka ng ilang function nang magkasama, nakakatulong ito sa iyong bumuo ng mas malalaking program. Ang bawat function ay gumagana nang nakapag-iisa, tulad ng mga manggagawa sa isang team. Kung ang isang manggagawa ay hindi gumagana nang maayos, maaari mong palitan ang bahaging iyon nang hindi naaapektuhan ang buong pangkat.
Halimbawa, ang isang simpleng laro ay maaaring may mga function tulad ng move_player , check_collision , at update_score . Ang bawat function ay responsable para sa isang gawain. Sama-sama, ginagawa nilang maayos ang laro.
Napakahalaga ng pagpili ng malinaw at simpleng mga pangalan para sa mga function. Ang isang magandang pangalan ay nagsasabi sa iyo kung ano ang nagagawa ng function. Kapag nakakita ka ng function na pinangalanang kalkulado_total , malalaman mo kaagad na nagdaragdag ito ng mga halaga. Ang mga simple at malinaw na pangalan ay ginagawang mas madaling basahin, maunawaan, at gamitin ang code.
Iwasang gumamit ng mahaba o nakakalito na mga pangalan. Gumamit ng mga salita na direktang nauugnay sa gawain na ginagawa ng function. Nakakatulong ang ugali na ito kahit na ang mga bagong programmer na maunawaan kung ano ang ginagawa ng bawat function.
Minsan ang mga function ay maaaring makaharap ng mga problema, tulad ng paghahati sa zero. Mahalagang pangasiwaan ang mga error na ito nang maayos. Sinusuri ng maraming mga function ang mga naturang error at nagbibigay ng kapaki-pakinabang na mensahe kung may mali.
Halimbawa, sa ating divide function makikita natin ang:
def divide(a, b):
kung b != 0:
ibalik ang a / b
iba pa:
bumalik "Hindi mahati sa zero!"
Sinusuri ng code na ito kung ang b ay zero. Kung ito ay, ang function ay nagsasabi sa iyo na hindi mo maaaring hatiin sa zero. Pinipigilan nito ang pag-crash ng program at tinutulungan kang maunawaan kung ano ang naging mali.
Ang mga parameter ay mga placeholder sa loob ng isang function. Kapag tinawag mo ang function, ipinapasa mo ang mga halaga na tinatawag na mga argumento. Halimbawa, sa function add(a, b) , ang a at b ay mga parameter. Kapag tinawag mo ang function na may add(10, 5) , ang mga halaga 10 at 5 ay magiging mga argumento.
Ginagawang flexible ng pamamaraang ito ang function. Maaari kang gumamit ng iba't ibang mga argumento sa tuwing tatawagan mo ang function. Ito ay tulad ng isang recipe. Kahit na gumamit ka ng iba't ibang prutas sa isang salad, ang mga hakbang ay nananatiling pareho, at nakakakuha ka pa rin ng masarap na salad.
Maraming pang-araw-araw na teknolohiya ang umaasa sa mga function at modular programming. Narito ang ilang mga halimbawa mula sa totoong buhay:
Nakakatulong ang modular programming na lumikha ng mga system na flexible at madaling i-update. Kapag ang isang bahagi ay nangangailangan ng pagbabago o pag-aayos, ang kaugnay na modyul lamang ang inaayos. Sa ganitong paraan, ang pangkalahatang sistema ay patuloy na gumagana nang maayos.
Mayroong ilang mga karaniwang pagkakamali na maaaring gawin ng mga bagong programmer kapag nagsusulat ng mga function. Sa pamamagitan ng pag-alam sa mga ito, maiiwasan mo ang mga ito:
Sa pamamagitan ng pag-iwas sa mga pagkakamaling ito, maaari kang sumulat ng mas malinis at mas mahusay na code. Ginagawa nitong mas madaling mapanatili at maunawaan ang iyong mga programa.
Ang mga pag-andar ay ang mga bloke ng gusali ng mga module. Ang isang module ay parang isang toolbox na naglalaman ng maraming function. Tulad ng pagsasama-sama mo ng mga katulad na tool, pinapangkat mo ang mga nauugnay na function sa isang module. Sa ganitong paraan, kapag kailangan mong gawin ang isang partikular na gawain, alam mo nang eksakto kung saan titingnan.
Halimbawa, maaari kang magkaroon ng isang module para sa mathematical operations, isang module para sa paghawak ng mga string, at isa pa para sa pagtatrabaho sa mga petsa. Ang bawat module ay nag-aayos ng mga function na nauugnay sa lugar nito. Malaking tulong ang istrukturang ito kapag lumalaki ang mga proyekto.
Sa tuwing nahaharap ka sa isang malaking problema sa programming, ang pinakamahusay na diskarte ay hatiin ito sa mas maliliit na problema. Ang bawat maliit na problema ay maaaring malutas sa pamamagitan ng pagsulat ng isang function. Kapag ang lahat ng maliliit na bahagi ay nalutas, sila ay pinagsama-sama upang mabuo ang kumpletong solusyon.
Ang diskarte na ito ay katulad ng paglutas ng isang jigsaw puzzle. Magsisimula ka sa mga piraso at pagkatapos ay ikonekta ang mga ito nang paisa-isa upang makita ang buong larawan. Ang pag-alam na gumagana nang tama ang bawat maliit na bahagi ay ginagawang malakas at maaasahan ang huling resulta.
Narito ang ilang simpleng tip kapag isinusulat ang iyong mga function:
Gamit ang mga tip na ito, maaari kang bumuo ng malakas at madaling maunawaan na mga function na maaaring magamit muli sa maraming proyekto.
Dumaan tayo sa isang simpleng hakbang-hakbang na proseso upang magsulat at gumamit ng mga function sa isang programa:
Tinutulungan ka ng prosesong ito na bumuo ng mga programa sa modular na paraan. Ang bawat maliit na bahagi ay ginagawa sa pamamagitan ng isang function, at lahat ng bahagi ay nagsasama-sama para sa panghuling programa.
Suriin natin ang mga pangunahing ideya mula sa araling ito:
Ang araling ito ay nagpakita kung paano ang paggamit ng mga function at modular programming ay maaaring gawing mas simple at mas masaya ang iyong buhay sa coding. Ang bawat function ay parang isang kapaki-pakinabang na tool na kumukumpleto ng bahagi ng isang malaking proyekto. Kapag pinagsama mo ang mga tool na ito, bubuo ka ng mga program na maayos, organisado, at madaling maunawaan.
Tandaan, ang susi sa mahusay na programming ay ang paghiwa-hiwalay ng mga problema sa maliliit, mapapamahalaang mga bahagi. Nagdaragdag ka man ng mga numero, bumabati sa isang tao, o gumagawa ng laro, tinutulungan ka ng mga function na gawin ito nang sunud-sunod. Ang modular programming ay ang diskarte na nagbibigay-daan sa iyong bumuo ng mga kumplikadong system gamit ang simple at malinaw na mga bahagi.
Habang nagsasanay ka sa pagsusulat ng mga function at paglalagay ng iyong code sa mga module, magiging mas mahusay ka sa paglutas ng mga problema. Ang bawat maliit na function na iyong isusulat ay isang hakbang patungo sa paglikha ng mas malaki at mas kahanga-hangang mga programa. Patuloy na mag-eksperimento, subukan, at pahusayin ang iyong code tulad ng gagawin mo sa anumang nakakatuwang puzzle o set ng gusali!