Paano Gumawa ng isang Numerical Integration Program sa Python: 10 Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:14

Ito ay isang tutorial sa kung paano lumikha at magpatakbo ng isang programa na susuriin ang mga tiyak na pagsasama gamit ang isang numerong pagsasama ng algorithm. Hinati ko ang mga hakbang sa 3 seksyon: pag-unawa sa algorithm na gagamitin upang gawin ang programa, pag-coding ng programa gamit ang wika ng programa ng Python, at pagpapatakbo ng programa. Ang tutorial na ito ay inilaan para sa isang tao na maaaring mangailangan upang mabilis na makagawa ng isang calculator upang suriin ang mga tiyak na integral, o marahil ay nangangailangan ng algorithm para magamit sa isang mas malaking programa sa scale. Inaasahan ang pangunahing kaalaman sa calculus, ngunit ang nauugnay na impormasyon sa matematika ay susuriin. Ang kaalaman sa pagprograma ay hindi inaasahan, ngunit kapaki-pakinabang dahil sa maikling pagsasalarawan ko lamang kung paano talaga gumagana ang programa.

Ano ang kakailanganin mo:

Isang personal na computer na may access sa internet

Hakbang 1: Pag-unawa sa Algorithm Bahagi 1: ang Tiyak na Integral at Paggamit nito

Ipagpalagay kong alam mo nang kaunti ang kung ano ang isang integral ay sa konteksto ng pangunahing calculus. Mahalaga ang mga integral sapagkat pinapayagan ka nilang magsama ng isang hanay ng mga halagang pinarami ng isang haba na walang hanggan; kapaki-pakinabang ito sa maraming larangan ng pananalapi, teorya ng bilang, pisika, kimika, pati na rin maraming iba pang mga larangan. Gayunpaman, papayagan ka ng program na ito na kalkulahin ang lugar sa ilalim ng isang kurba para sa isang may hangganan na agwat, o sa madaling salita, hindi nito sinusuri ang mga anti-derivatives - kinakailangan ng mas malakas na algorithm para doon. Kapaki-pakinabang ang algorithm na ito kung kailangan mong suriin ang isang tiyak na integral sa isang mas malaking program na tinukoy patungo sa iba pa, o kung nais mong suriin ang iyong sagot para sa anumang tiyak na integral na ginawa ng kamay.

Ang isang pangunahing tiyak na integral ay kumakatawan sa lugar sa ilalim ng isang curve na tinukoy ng isang pagpapaandar hal. f (x). Para sa isang tiyak na integral, hinahanap namin ang lugar sa pagitan ng dalawang puntos (may label na a at b ayon sa pagkakabanggit). Sa larawan, ang rehiyon ng turkesa ang lugar na tinutukoy ko, at ang equation para sa pagtukoy nito ay ipinapakita rin sa rehiyon na iyon. Ang pagpapaandar na ipinakita sa larawan ay arbitraryo.

Hakbang 2: Pag-unawa sa Algorithm Bahagi 2: Paglalahad sa Numero

Ang isang computer ay nangangailangan ng isang malawak na hanay ng mga tagubilin para sa pagkalkula ng lugar na iyon sa ilalim ng isang di-makatwirang pag-andar na gagana para sa anumang pagpapaandar, kaya't ang mga pamamaraang analitikal na maaaring pamilyar sa iyo ay walang silbi dahil masyadong partikular sila. Ang isang paraan upang makalkula ang mga integral na tinatayang, na ang isang computer ay maaaring hawakan, ay ginagawa sa pamamagitan ng pagpuno sa lugar ng interes ng isang tinukoy ng gumagamit na dami ng mga parihaba ng pantay na lapad at variable na taas pagkatapos ay ibubuod ang lahat ng mga lugar ng rektanggulo. Ang matibay na mga katangian ng mga parihaba ay mag-iiwan ng ilan sa kabuuang lugar na hindi nagalaw, samakatuwid kung bakit ito ay itinuturing na isang approximation; gayunpaman, mas maraming mga parihaba na maaari mong mag-cram sa pagitan ng mga hangganan (a at b), mas tumpak ang pagtatantas dahil ang mga hindi nagalaw na mga rehiyon ay naging mas kalat-kalat. Dahil gagawin ng isang computer ang gawain, maaari mong itakda ang bilang ng mga parihaba sa nais na rehiyon na maging isang napakalaking numero, na ginagawang lubos na tumpak ang pagtatantya. Sa sumusuporta na larawan, isipin na ang bawat rektanggulo sa itinalagang lugar ay pantay ang lapad. Ginawa ko ang aking makakaya upang gawin silang pantay na lapad sa Microsoft Paint, ngunit hindi ginawa ang pinakamahusay na trabaho.

Hakbang 3: Pag-unawa sa Algorithm Bahagi 3: ang Midpoint Rule

Itinatalaga ng panuntunang ito kung paano ginawa ang mga rektanggulo at ginamit sa paglapit. Ang bawat rektanggulo sa labas ng "N" na mga parihaba ay dapat magkaroon ng pantay na lapad, Δx, ngunit ang bawat nth rektanggulo ay hindi maaaring maging eksaktong pareho: ang magkakaibang kadahilanan ay ang taas na nag-iiba habang sinusuri ang pagpapaandar sa isang tiyak na punto. Ang panuntunan sa midpoint ay nakukuha ang pangalan nito mula sa katotohanan na sinusuri mo ang taas ng bawat rektanggulo bilang f (x_n), kung saan ang "x_n" ay ang kani-isang gitnang-point ng bawat rektanggulo, tulad ng nakadikit sa kaliwa o kanan ng rektanggulo. Ang paggamit ng midpoint ay tulad ng pagpapatupad ng isang average na gagawing mas tumpak ang approximation kaysa sa kung gagamit ka ng kanan o kaliwa. Ang sumusuporta sa larawan para sa hakbang na ito ay nagbubuod kung paano ang tuntunin ng midpoint ay tinukoy sa matematika.

Hakbang 4: Paglikha ng Bahagi ng Programa 1: Pag-download ng isang Python Compiler / Editor

Ngayon na naiintindihan mo ang algorithm na kailangang ipatupad, isang bagay ng pagkuha ng isang computer upang maisagawa ang pagkalkula para sa iyo. Ang unang hakbang upang sabihin sa isang computer kung ano ang dapat gawin ay ang pagkuha ng mga tool upang magawa ito. Ang algorithm na ito ay maaaring naka-code sa anumang wika; para sa pagiging simple, ang program na ito ay naka-code sa wika ng Python. Upang utusan ang iyong computer na magsagawa ng mga pagpapatakbo sa Python, kakailanganin mo ang isang editor na kumukuha ng mga tagubilin na nakasulat sa wikang iyon na pagkatapos ay maiipon sa wika ng makina na mauunawaan ng iyong computer upang maisagawa nito ang mga gawaing sinabi mong gawin nito. Sa panahon ngayon, ang isang editor at tagatala ay karaniwang isinasama, subalit hindi palaging iyon ang kaso. Maaari kang gumamit ng anumang editor / tagatala na komportable ka, ngunit ipapakita ko sa iyo kung paano makukuha ang aking personal na paborito para sa Python: Canopy. Kung mayroon ka nang isang editor / tagatala, maaari mong laktawan ang mga hakbang na ito.

1. Pumunta sa
2. I-click ang Download Canopy

3. I-click ang pindutan ng pag-download na naaayon sa iyong operating system

   Awtomatikong magsisimula ang pag-download

4. Sundin ang mga tagubilin sa pagtatanim pagkatapos simulan ang file ng pagpapatupad
5. Patakbuhin ang Program
6. I-click ang "Editor" mula sa pangunahing menu ng programa
7. I-click ang "lumikha ng isang bagong file" sa gitna ng screen

Mula sa puntong ito dapat mong makita ang isang blangkong puting bintana na may isang cursor na kahawig ng isang pangunahing dokumento sa pagproseso ng salita. Handa ka na ngayon upang simulang i-coding ang numerong pagsasama ng algorithm para sa paglutas ng mga tiyak na integral. Ang mga hakbang sa pagpapatuloy ay magkakaroon ng isang snippet ng code na iyong kokopyahin at isang paliwanag kung ano ang ginagawa ng snippet na iyon para sa isang kabuuan ng programa.

Hakbang 5: Paglikha ng Bahagi ng Programa 2: Pag-import ng Mga Pag-andar at Pagtukoy sa Mga variable

Kopyahin ang code sa larawan.

Para sa anumang programa na maaari mong makita ang iyong sarili sa pag-coding, magkakaroon ng mga variable. Ang variable ay isang pangalan na ibinigay sa isang halagang ipapatakbo at maaaring magbago. Sa karamihan ng mga wika ng programa (kung hindi lahat) kailangan mong simulan ang isang variable bago ang programa ay maaaring gumawa ng mga pagbabago dito. Sa kaso ng program na ito, pinangalanan ko ang mga variable na "N," "a," at "b." Ang mga halagang ito ay kumakatawan sa bilang ng mga pag-ulit (bilang ng mga parihaba ng AKA), mas mababang hangganan, at itaas na hangganan ayon sa pagkakabanggit. Maaari mong pangalanan ang anumang nais mo, ngunit upang maitugma ang mga formula na ibinigay sa "Pag-unawa sa Algorithm Bahagi 3: Ang Midpoint Rule," pinakamahusay na panatilihin silang pareho. Pansinin na hindi lamang nakatakda ang mga ito sa isang tukoy na halaga. Ito ay sapagkat ginawa silang mga input na, kapag pinatakbo ang programa, maaaring tukuyin ng gumagamit ng programa kung ano ang magiging halaga. Ang teksto sa mga quote, pagkatapos ng utos ng pag-input, ay lilitaw kapag pinatakbo mo ang programa na nagsasabi sa iyo kung anong uri ng halagang dapat i-type. Mapapansin mo rin na ang "int" at "float" ay ginagamit bago ang mga pagtatalaga ng input. Ang mga term na ito ay nagsasabi sa computer kung anong uri ng variable ang magiging halaga na ito. Ang isang "int" ay isang integer, at ang isang "float" ay isang lumulutang na puntos na halaga (ibig sabihin isang decimal). Dapat itong maging malinaw kung bakit ang mga ito ay itinalaga tulad nito.

Anumang teksto na naroroon pagkatapos ng isang "#" ay isang puna na nagbibigay-daan sa programmer na sundin ang code sa isang makataong paraan; Gumawa ako ng ilang mga puna sa aking code na iyong kokopya, ngunit huwag mag-atubiling magdagdag ng anumang mga puna na partikular na makakatulong sa iyo. Ang programa ay hindi magbabasa ng anumang may "#" bago ito bilang isang utos.

Ang bahagi ng code na binabasa "mula sa pag-import ng matematika *" ay nagsasabi sa programa na mag-import ng isang hanay ng mga pagpapaandar sa matematika na maaaring magamit nang hindi kinakailangang i-program ang mga ito sa iyong sarili. Ang ibig sabihin ng "*" ay "lahat." Basahin ang bahaging ito ng code bilang: mula sa library ng matematika i-import ang lahat ng mga pag-andar. Pinapayagan kang gumamit ng mga pagpapaandar sa matematika tulad ng sine, cosine, log, exp, atbp. Ang pagpapaandar na ito ay maaaring maisama sa matematika sa loob ng code.

Hakbang 6: Paglikha ng Programa Bahagi 3: Lumilikha ng isang Pag-andar para sa Pagsasama

Kopyahin ang code sa larawan sa ibaba ng nakaraang code.

BABALA: Ang seksyon na ito ay siksik, at nais kong limasin ang ilang mga bagay na maaaring maging nakalilito. Kapag pinag-uusapan ang tungkol sa programa, maraming lumalabas ang salitang "pagpapaandar". Ang term na ito ay maraming pop up kapag pinag-uusapan mo ang tungkol sa matematika. Kaya, mula sa puntong ito, kapag pinag-uusapan ko ang tungkol sa isang pagpapaandar sa kahulugan ng programa, susulat ako ng "Python function," at kapag pinag-uusapan ko ang tungkol sa pag-andar ng matematika, sasabihin ko na "pagpapaandar sa matematika." Sa ilang mga point gagamitin namin ang isang pag-andar ng Python bilang isang representasyon para sa pag-andar sa matematika na pinag-uusapan.

Ang susunod na snippet ng code na ito ang puso ng programa. Dito, tinukoy ang isang pagpapaandar ng Python na nagdadala ng algorithm ng pagsasama-bilang sa bilang gamit ang panuntunan sa midpoint. Ang "def Integrate (N, a, b)" ay binabasa bilang: tukuyin ang isang pagpapaandar na tinatawag na "Pagsamahin" na tumatanggap ng mga variable na "N," "a," at "b," at ibabalik ang lugar sa ilalim ng kurba (ang pag-andar ng matematika) na tinukoy din sa loob ng "Isama" na pag-andar ng Python. Maaari mong tawagan ang pag-andar ng Python na ito ng anumang bagay kapag ginawa mo ang pag-coding, ngunit makatuwiran na tawagan itong isama dahil ito ay isang pagpapaandar na sumasama talaga sa isang pag-andar sa matematika.

Sa puntong ito sulit na magkomento sa kung paano pinaghiwalay ng Python ang mga bloke ng code. Ang isang bloke ng code ay isang buong seksyon na gumaganap ng isang tiyak na gawain. Ang magkakaibang mga wika sa pagprograma ay magtatalaga ng mga paraan upang makilala ang mga "bloke." Para sa Python, ang isang bloke ay nakikilala sa pamamagitan ng mga indentation: ang bawat seksyon na gumaganap ng gawain ay may sariling indent, at maaaring may mga naka-indent na bloke sa loob ng iba pang mga naka-indent na bloke. Kinakatawan nito ang mga gawain sa loob ng mga gawain, at mahalagang sinasabi sa pagkakasunud-sunod kung saan kailangang maisagawa ang code. Sa kaso ng tinukoy na pag-andar ng Python na "Pagsamahin," ang lahat sa loob ng pagpapaandar na iyon ay naka-indent out sa isang bloke kung kaya nakikilala ang mga gawain na isasagawa sa loob ng pagpapaandar na iyon. Mayroong mga naka-indent na bahagi sa loob ng pag-andar ng Python na ito na nagsasagawa din ng kanilang sariling mga gawain. Ito ay pupunta tulad ng sumusunod: isang utos (gawain) ay itinakda, isang colon ang sumusunod sa utos, at kung ano ang ginagawa ng utos ay naka-indent sa ilalim.

Kaagad pagkatapos matukoy ang "isama" na pagpapaandar ng Python, tutukuyin mo ang isa pang pagpapaandar ng Python na tinatawag na f (x). Kinakatawan nito ang pag-andar ng matematika na isasama. Para sa bawat magkakaibang pag-andar sa matematika na nais mong isama, kailangan mong gawin sa linya ng program na ito upang baguhin ito (hindi katulad ng mga variable na tinukoy kapag ang programa ay pinatakbo). Ang bawat pag-andar ng Python ay magkakaroon ng halaga ng pagbabalik, ito ang ibabalik ng pagpapaandar kapag itinapon mo ito ng isang halaga. Sa kasong ito, ang itinapon na halaga ay "x," at ang term na "x" na ito ay kukuha ng halaga ng kung ano ang itapon mo - ito ay isang pansamantalang halaga.

Susunod, ang isang for-loop ay gumaganap bilang pagbubuod na tinukoy sa mga formula sa seksyong "Pag-unawa sa Algorithm" ng tutorial na ito. Ang pagbubuod na ito ay nangangailangan ng isang pares ng higit pang mga variable, ang isa sa mga ito ay gaganap bilang halaga ng pagbalik para sa buong "Isama" na pag-andar ng Python. Bago ang for-loop, itinalaga ko ang mga variable na ito bilang "halaga," at "halaga2." ang gawain ng for-loop ay upang umulit sa isang saklaw ng mga halaga para sa isang itinalagang variable, na maginhawang maaaring tukuyin sa loob ng for-loop command; sa kasong ito, ang variable na iyon ay "n." Ang saklaw kung saan nangyayari ang pag-ulit ay 1 hanggang N + 1. Dapat mong mapansin na ang pagbubuod na tinukoy sa nabanggit na mga formula ay mula sa 1 hanggang N. Tinukoy namin ito sa ganitong paraan dahil binibilang ng wika ng Python ang bawat umuulit na halaga na nagsisimula mula sa zero, kaya mahalagang kailangan nating ilipat ang saklaw ng mga halaga upang magkasya sa aming ninanais saklaw Pinapayagan ng for-loop ang pagbubuod ng lahat ng taas ng rektanggulo na magkasama at iniimbak ang halagang iyon sa variable na tinawag kong "halaga." Makikita ito sa piraso ng code na lalabas bilang: halaga + = f (a + ((n- (1/2)) * ((b-a) / N))).

Mula doon, ang susunod na piraso ng code ay gumagamit ng variable na tinatawag na "halaga2" na kung saan ay itinalaga upang maging kabuuan ng lahat ng taas ng bawat rektanggulo na pinarami ng pamantayan ng lapad ng bawat rektanggulo - ito ang aming huling sagot na nais namin ipinakita ng aming programa, at sa gayon ay ang halaga ng pagbabalik ng "Isama" na pag-andar ng Python.

Hakbang 7: Paglikha ng Programa Bahagi 4: Pagpapakita ng Sagot

Kopyahin ang code sa larawan sa ibaba ng nakaraang code.

Ngayon na ang sagot ay maaaring makuha sa pamamagitan ng "Isama" na pagpapaandar ng Python, nais naming maipakita ito. Ito ay isang bagay lamang ng paglalagay ng mga halaga na na-input ng gumagamit ("N," "a," at "b") sa "Isama" na Python function at i-print ito sa screen. Ang utos na ito ay ipinapakita sa linya 21, at talagang ang lahat ng kailangan mong gawin upang matapos ang hakbang na ito. Ang code sa mga linya na 19 at 20 ay naroroon lamang upang "paandarin" ang output ng buong programa. "print (" ………………………. ")" pinaghihiwalay ang seksyon ng pag-input ng programa mula sa seksyon ng output, at ang "print (" Narito ang iyong sagot: ")" ay isang pagtatalaga lamang na ang sagot ay mai-print pagkatapos ng linya ng teksto.

Hakbang 8: Pagpapatakbo ng Programa Bahagi 1: Pagpapatakbo ng Programa Tulad Ng Ay

Kung hindi ka gumagamit ng Canopy, malamang na hindi mo na kailangang sundin ang hakbang na ito sa lahat at ang pagpapatakbo ng programa ay maaaring mangailangan ng iba't ibang mga pamamaraan. Sa Canopy, bago mo mapatakbo ang programa, kakailanganin mong i-save ito. Ang uri ng file para sa isang programa ng Python ay isang.py file - awtomatiko itong nai-save. Piliin kung saan mo nais na mai-save ang file, pagkatapos ay magagawa mong patakbuhin ang programa.

Pagpapatakbo ng Programa:

1. Pindutin ang berdeng pindutan na mukhang isang "pindutan ng pag-play" na matatagpuan sa tool bar sa itaas lamang kung saan lalabas ang iyong pangalan ng file (sumangguni sa larawan).
2. Tatakbo ang programa sa ibabang screen ng editor na kilala bilang Canopy data-analysis environment. Ipagpalagay na nakopya mo ang mga senyas habang isinulat ko ang mga ito, dapat mong makita sa ilalim ng kapaligiran ng pagtatasa ng data ng Canopy ang prompt: "Ipasok kung gaano karaming beses na nais mong mag-sum (mas maraming beses = mas tumpak):." (sumangguni sa larawan)
3. Magpasok sa isang halaga para sa kung gaano karaming beses nais mong gawin ang pag-ulit ite 10000 (kung gaano karaming mga parihaba na nais mong itulak sa iyong lugar), pagkatapos ay pindutin ang enter.
4. Maraming mga senyas ang lilitaw na may mga pahayag na dapat maging pamilyar na mga senyas ng pag-input na naka-code sa iyo sa programa sa hakbang na 5. Punan ang mga ito nang naaangkop tulad ng sa bilang 3 sa itaas.
5. Ang integral ay dapat suriin, at isang resulta ay dapat lumitaw.

Kung naka-code ang programa tulad ng ipinakita sa naunang mga larawan, isinama mo lamang ang f (x) = x ^ 2 sa ilang mga hangganan. Ang integral ng x ^ 2 ay isang madaling suriin sa pamamagitan ng kamay, samakatuwid dapat mong suriin at siguraduhin na ang programa ay nagbigay ng isang napakalapit na sagot sa tamang halaga ng analytical na tinutukoy ng kamay. Kapag pinatakbo ko ang programa sa mga halagang N = 10000, a = 0, at b = 10, nakukuha ko ang sagot na 333.33333249999964. Ang tamang sagot na pansulat, ay 333.333. Ito ay hindi kapani-paniwalang tumpak at mabilis. Mahalagang pinisil mo ang 10, 000 na mga parihaba sa pagitan ng 0 at 10 sa x axis at ginamit ang mga ito upang tantyahin ang lugar sa ilalim ng curve x ^ 2!

Hakbang 9: Pagpapatakbo ng Programa Bahagi 2: Pagsasama ng Iba Pang Mga Pag-andar ng Matematika

Sa nakaraang hakbang, kung sumusunod ka ng matapat, isinama mo ang f (x) = x ^ 2. Hindi lamang iyon ang pag-andar sa matematika na maaaring maisama ng program na ito. Alalahanin mula sa hakbang 5 na-import mo ang array ng library ng matematika ng mga pagpapaandar ng Python sa programa. Pinapayagan kang gumamit ng mas kumplikadong mga pagpapaandar sa matematika na maaaring isama. Bigyan natin ang isang shot. Siyempre, maaari mong gamitin ang anumang pagpapaandar na nais mo, ngunit ipapakita ko pa rin ang akuridad ng code na ito sa pamamagitan ng pagsasama ng isang partikular na pagpapaandar sa matematika na magbubunga ng isang kilalang halaga kapag isinama sa isang tiyak na saklaw. Ang pagpapaandar na iyon ay f (x) = Kasalanan [x]. Ang pagpapaandar na matematika na ito ay ipinapakita sa unang kasamang larawan, na naka-plot mula 0 hanggang 2π, at ang lugar ng interes ay na-shade sa turkesa. Mayroong pantay na halaga ng positibong lugar dahil may negatibong lugar sa agwat na ito, kaya't kung idagdag mo ang kabuuang lugar, dapat kang makakuha ng zero. Tingnan natin kung totoong nangyari ito:

Ang paglalagay ng pagpapaandar sa matematika f (x) = Kasalanan [x] sa programa:

1. Bago patakbuhin muli ang programa, sa ilalim ng komentong "#type ang iyong pagpapaandar pagkatapos bumalik," i-type ang: sin (x) kung saan kasalukuyang matatagpuan ang x ** 2. (sumangguni sa larawan).
2. Patakbuhin ang programa sa pamamagitan ng pagpindot muli sa berdeng pindutan ng pag-play.
3. Mag-type ng 10000 para sa halagang N (kung ilang beses mo nais na kabuuan).
4. ilagay ang "0" para sa mas mababang hangganan.
5. Ilagay ang 6.2832 para sa itaas na hangganan (tinatayang 2π).
6. Tingnan kung anong halaga ang makukuha mo.

Nang gawin ko ito, natapos ko ang pagkuha ng isang halaga ng 1.079e-10: ito ay katumbas ng.0000000001079, na talagang malapit sa zero, kaya't mukhang tumpak ito, at ipinapakita na sapat na pinangangasiwaan ng algorithm ang negatibong lugar.

Hakbang 10: Pagpapatakbo ng Programa Bahagi 3: Pagpapalawak ng Programa

Sa puntong ito tapos ka na: mayroon kang isang gumaganang tiyak na integral algorithm na naka-code sa Python na tumatakbo nang maayos at nagbibigay ng tumpak na mga sagot. Gayunpaman, ang program na ito ay maaaring mapabuti. Hindi ako isang programmer, at mayroon akong kaunting karanasan sa Python. Sa katunayan, kinailangan kong i-refresh ang aking sarili sa paggamit ng Python upang makumpleto ang tutorial na ito, ngunit dapat magbigay sa iyo ng kumpiyansa na ang Python ay isang madaling wika upang malaman. Ang punto ko ay maaari mong palawakin ang program na ito sa pamamagitan ng paggawa ng mas mahusay na ito, marahil magpatupad ng ilang GUI, at gawin itong mas madaling gamitin ng gumagamit.

Ang aking saloobin sa pagpapalawak ng programa:

• Pagpapatupad ng isang graphic user interface na nagbibigay-daan sa iyo upang patakbuhin ang programa nang hindi ginagamit ang Canopy interactive na data-analysis na kapaligiran
• Gawin ito upang ang pag-andar ng matematika na isasama ay hindi kailangang maging input sa loob ng programa, ngunit maaaring maging input pagkatapos na maipatakbo ang programa (una kong sinusubukan na gawin ito, ngunit hindi ko ito mawari).
• Tukuyin ang isang "Isama" na pag-andar ng Python kaya't tumatagal ang f (x) na paggana tulad ng naaplay sa pagkakaroon ng f (x) na tinukoy na pagpapaandar sa loob nito.

Ito ay ilan lamang sa mga halimbawa ng mga lugar ng pagpapabuti, ngunit ginagarantiyahan ko na maraming iba pang mga lugar na maaari itong mapahusay. Kaya't iniiwan ko ang hakbang na ito bilang isang halimbawa ng mga kamalian na mayroon ang program na ito at marahil isang ehersisyo sa sinumang nais na mapabuti ang programa nang higit pa.