habang loop sa Python. Paano ito gumagana, mga halimbawa ng paggamit

Ang mga loop ay isa sa mga pangunahing tool ng anumang wika. Mayroong dalawang pangunahing mga loop sa Python, ang isa ay habang. Isaalang-alang ito, at para sa mas mahusay na pag-unawa sa larawan, isa pa. Sa katunayan, kung ihahambing sa isang katulad na bagay, mas madaling maunawaan ang anumang materyal, hindi ba?

Ang konsepto ng isang cycle

Ang isang loop ay kinakailangan kapag ang isang partikular na aksyon ay kailangang isagawa nang maraming beses. Ito ay napaka-simplistic, dahil sa katotohanan ang hanay ng mga aplikasyon para sa mga cycle ay mas malawak. Mayroong dalawang pangunahing uri ng mga loop sa Python: para at habang. Ang pinakasikat ay para sa.

Bilang karagdagan sa mga partikular na pagkilos, maaari kang mag-loop ng iba't ibang piraso ng code hanggang sa isang partikular na punto. Ito ay maaaring isang tiyak na bilang ng beses, o hangga't ang isang partikular na kundisyon ay totoo.

Bago natin simulan upang maunawaan ang mga uri ng mga loop at habang, sa partikular, kailangan pa rin nating maunawaan kung ano ang pag-ulit. Ito ay isang pag-uulit ng isang aksyon o pagkakasunod-sunod ng mga aksyon sa panahon ng kasalukuyang cycle sa loob ng kasalukuyang pagtakbo ng application.

Ikot Para sa

Ang aming For loop ay hindi isang counter, tulad ng sa maraming iba pang mga wika. Ang gawain nito ay magbilang ng isang tiyak na pagkakasunud-sunod ng mga halaga. Anong ibig sabihin nito? Sabihin nating mayroon tayong listahan ng mga elemento. Una, ang loop ay tumatagal ng una, pangalawa, pangatlo, at iba pa.

Ang bentahe ng loop na ito sa Python ay hindi mo kailangang matukoy ang index ng elemento upang malaman kung kailan lalabas sa loop. Lahat ay awtomatikong gagawin.

>>> spisok = [10, 40, 20, 30]

>>> para sa elemento sa spisok:

… print(elemento + 2)

...

12

42

22

32

Sa aming halimbawa, ginamit namin ang variable sangkap pagkatapos ng para sa utos. Sa pangkalahatan, ang pangalan ay maaaring kahit ano. Halimbawa, ang isang tanyag na pagtatalaga ay i. At sa bawat pag-ulit, ang variable na ito ay bibigyan ng isang partikular na bagay mula sa listahan, na tinawag naming naaangkop na salita.

Sa aming kaso, ang listahan ay isang pagkakasunud-sunod ng mga numero 10,40,20,30. Sa bawat pag-ulit, lumilitaw ang katumbas na halaga sa variable. Halimbawa, sa sandaling magsimula ang loop, ang variable sangkap ang halaga 10 ay itinalaga. Sa susunod na pag-ulit, ang sampu ay nagiging numero 40, sa pangatlong beses na ito ay nagiging numero 20, at sa wakas, sa huling pag-ulit ng loop, ito ay nagiging 30.

Ang signal para sa pagtatapos ng cycle ay ang pagtatapos ng mga elemento sa listahan.

Kung kailangan mo ang loop upang magsagawa ng isang klasikong enumeration ng mga halaga, tulad ng sa iba pang mga programming language, dapat kang lumikha ng isang listahan na may pagkakasunod-sunod ng mga natural na numero hanggang sa halaga na kailangan namin.

>>> sambit = [1,2,3,4,5]

O gamitin ang function len(), upang matukoy ang haba ng listahan. Ngunit sa kasong ito ay mas mahusay na gumamit ng isang loop habang, dahil hindi na kailangang gumamit ng variable.

Kung kailangan mong baguhin ang pagkakasunud-sunod ng mga halaga sa listahan, loop para at narito ang pagliligtas. Upang gawin ito, sa bawat pag-ulit, ang bawat elemento ng listahan ay dapat na italaga ng isang naaangkop na halaga.

Habang Loop

Hindi tulad ng cycle para, na umuulit lamang sa mga halaga ng sequence, ang loop habang ay may mas maraming gamit. Ang pangalan ng ganitong uri ng mga cycle ay isinalin bilang "pa". Ibig sabihin, "hanggang".

Ito ay isang unibersal na loop na matatagpuan sa lahat ng mga programming language. At sa ilang mga paraan ito ay kahawig ng isang conditional operator yew, na nagsasagawa ng pagsusuri upang makita kung natutugunan ang isang partikular na kundisyon. Tanging sa kaibahan sa conditional operator, habang nagsasagawa ng pagsusuri sa bawat pag-ulit, hindi lamang isang beses. At kung mali lamang ang kundisyon, magtatapos ang loop at ang utos na kasunod nito ay isasagawa. Sa madaling salita, kung hindi na valid ang sitwasyon kung saan siya nagtatrabaho.

Kung gumuhit tayo ng isang cycle habang sa simpleng paraan, ito ay ginagawa gamit ang gayong pamamaraan.

Ang pangunahing sangay ng programa (na tumatakbo sa labas ng loop) ay inilalarawan sa figure na ito na may mga asul na parihaba. Ang turkesa ay kumakatawan sa katawan ng cycle. Sa turn, ang rhombus ay isang kondisyon na sinusuri sa bawat pag-ulit.

cycle habang maaaring magresulta sa dalawang pagbubukod:

1. Kung sa simula ng loop ang lohikal na expression ay hindi nagbabalik ng totoo, kung gayon hindi ito magsisimula, na nakumpleto bago ang pagpapatupad. Sa pangkalahatan, ang sitwasyong ito ay normal, dahil sa ilalim ng ilang mga pangyayari, ang application ay maaaring hindi magbigay ng pagkakaroon ng mga expression sa loop body.
2. Kung palaging totoo ang expression, maaari itong humantong sa isang loop. Iyon ay, sa walang katapusang pag-scroll ng cycle. Samakatuwid, sa mga naturang programa, dapat palaging may exit statement mula sa loop o program. Gayunpaman, ang sitwasyong ito ay lilitaw kung natukoy ng programa ang katotohanan o kamalian ng isang partikular na kondisyon. Kung nabigo siyang gawin ito, may ibabalik na error sa pagwawakas ng programa. O maaari mong pangasiwaan ang error, at pagkatapos, kung mangyari ito, isasagawa ang ilang code.

Maaaring mayroong isang malaking bilang ng mga pagpipilian para sa kung paano pangasiwaan ang isang error. Halimbawa, maaaring hilingin ng program sa user na magpasok ng data nang tama. Kaya, kung ang isang tao ay nagpahiwatig ng isang negatibong numero kung saan maaari lamang itong maging positibo, o nagpasok ng mga titik kung saan ang mga numero lamang ang dapat, ang programa ay maaaring magsabi tungkol dito.

Habang Mga Halimbawa ng Loop

Narito ang isang halimbawa ng code na humahawak ng error sa kasong ito.

n = input(“Magpasok ng integer: “) 

while type(n) != int:

    Subukan:

        n = int(n)

    maliban sa ValueError:

        print("Maling entry!")

        n = input(“Magpasok ng integer: “) 

kung n % 2 == 0:

    print("Kahit na")

kung hindi:

    print ("Kakaiba")

Tandaan na ang Python ay gumagamit ng mga tutuldok upang magdeklara ng mga kumplikadong konstruksyon ng code.

Sa code sa itaas, tinukoy namin bilang isang kundisyon na dapat naming suriin kung ang numero ay isang integer. Kung oo, ibabalik ang false. Kung hindi, totoo.

Sa ikalawang bahagi ng code, kung saan ginagamit ang operator if, ginamit namin ang % operator upang mahanap ang natitira pagkatapos ng operasyon ng paghahati. Ang susunod na hakbang ay upang suriin kung ang numero ay pantay. Kung hindi, ang natitira ay isa sa kasong ito. Alinsunod dito, ang bilang ay kakaiba. 

Sa madaling salita, sinusuri muna ng code sa itaas kung ang string na ipinasok ng user ay isang numero. Kung oo, pagkatapos ay isang pangalawang pagsusuri ay ginawa upang makita kung may natitira sa dibisyon sa pamamagitan ng dalawa. Ngunit ang pangalawang bloke ay hindi isasagawa hanggang ang halaga na ipinasok ng gumagamit ay numero.

Iyon ay, ang loop ay regular na isasagawa hanggang sa mangyari ang kundisyon. Sa sitwasyong ito, ito ay gumagana tulad nito. 

Iyon ay, maaari kang pumunta mula sa kabaligtaran: i-loop ang isang partikular na aksyon hanggang sa maging mali ang kaganapan.

Pag-parse ng code

Ngayon tingnan natin nang mas detalyado kung paano gumagana ang code na ito. Upang gawin ito, susuriin namin ito nang sunud-sunod.

1. Una, ang gumagamit ay nagpasok ng isang string, na tinatanggap ng variable n. 
2. Gamit ang isang loop habang ang uri ng variable na ito ay sinusuri. Sa unang entry, hindi ito pantay int. Samakatuwid, bilang isang resulta ng pagsubok, nalaman na ang kundisyong ito ay totoo. Samakatuwid, ang katawan ng loop ay ipinasok.
3. Sa tulong ng isang operator sumubok sinusubukan naming i-convert ang isang string sa isang numero. Kung ito ay tapos na, pagkatapos ay walang error na nangyayari. Alinsunod dito, hindi na kailangang iproseso ito. Samakatuwid, ang interpreter ay bumalik sa simula ng loop, at ayon sa mga resulta ng tseke, lumalabas na ito ay naging isang integer. Kaya pumunta tayo sa hakbang 7
4. Kung hindi matagumpay ang conversion, may itatapon na ValueError. Sa kasong ito, ang daloy ng programa ay ipinadala sa maliban sa handler.
5. Ang gumagamit ay nagpasok ng isang bagong halaga, na itinalaga sa variable n.
6. Ang interpreter ay bumalik sa hakbang 2 at muling susuriin. Kung ito ay isang integer na halaga, pumunta sa hakbang 7. Kung hindi, susubukan muli ang conversion ayon sa hakbang 3.
7. Sa tulong ng isang operator if Tinutukoy kung may natitira pagkatapos hatiin ang isang numero sa 2. 
8. Kung hindi, ibabalik ang text na "even".
9. Kung hindi, ibabalik ang text na "kakaiba".

Isaalang-alang ngayon ang gayong halimbawa. Subukang tukuyin kung ilang beses dadaan ang cycle na ito?

kabuuan = 100 

i = 0

habang ako <5:

    n = int(input())

    kabuuan = kabuuan - n

    i = i + 1 

print("Natitira", kabuuan)

Ang tamang sagot ay 5. Sa una, ang halaga ng variable i – sero. Tinitingnan ng interpreter kung pantay ang variable i 4 o mas mababa. Kung oo, ibabalik ang halaga. totoo, at ang loop ay isinasagawa nang naaayon. Ang halaga ay tumaas ng isa.

Pagkatapos ng unang pag-ulit, ang halaga ng variable ay magiging 1. Ang isang pagsusuri ay isinasagawa, at nauunawaan ng programa na ang numerong ito ay muli na mas mababa sa 5. Alinsunod dito, ang loop body ay isinasagawa sa pangalawang pagkakataon. Dahil magkapareho ang mga hakbang, ang halaga ay tumaas din ng isa, at ang variable ay katumbas na ngayon ng 2.

Ang halagang ito ay mas mababa din sa lima. Pagkatapos ang loop ay naisakatuparan sa pangatlong beses, idinagdag sa variable i 1 at ito ay itinalaga ng halaga 3. Ito ay muli na mas mababa sa lima. At kaya pagdating sa ikaanim na pag-ulit ng loop, kung saan ang halaga ng variable i katumbas ng 5 (pagkatapos ng lahat, ito ay orihinal na zero, sa pagkakatanda natin). Alinsunod dito, ang kundisyong ito ay hindi pumasa sa pagsubok, at ang loop ay awtomatikong tinapos at ang paglipat sa susunod na hakbang, na nasa labas nito (o pagwawakas ng programa, kung ang mga sumusunod na hakbang ay hindi ibinigay), ay isinasagawa.

Ang cycle ay maaari ding mangyari sa kabaligtaran ng direksyon. Narito ang isang halimbawa ng code kung saan, sa bawat kasunod na pag-ulit, ang isa ay ibabawas mula sa kasalukuyang halaga ng variable. 

kabuuan = 100 

habang kabuuan > 0:

    n = int(input())

    kabuuan = kabuuan - n 

print ("Naubos na ang mapagkukunan")

Subukang hulaan kung ano ang ginagawa ng program na ito! Isipin na sa isang variable total nakaimbak ang impormasyon tungkol sa mapagkukunan ng programa. Sa bawat oras na titingnan ng interpreter kung mayroon ang mapagkukunan. Kung hindi, ang tekstong "Naubos na ang mapagkukunan" ay ipinapakita at ang programa ay magsasara. At sa bawat pag-ulit ng loop, bumababa ang mapagkukunan sa bilang na tinukoy ng user.

At ngayon takdang-aralin. Subukang baguhin ang code sa itaas upang ang variable ay hindi pisikal na maging negatibo.