Loops sinn ee vun den Haaptinstrumenter vun all Sprooch. Et ginn zwou Basisschleifen am Python, eng vun deenen ass während. Betruecht et, an och fir e bessere Verständnis vum Bild, eng méi. Tatsächlech, am Verglach mat eppes ähnleches, ass et vill méi einfach all Material ze verstoen, ass et net?
D'Konzept vun engem Zyklus
Eng Loop ass gebraucht wann eng gewëssen Handlung e puer Mol muss gemaach ginn. Dëst ass ganz simplistesch, well a Wierklechkeet ass d'Palette vun Uwendungen fir Zyklen vill méi breet. Et ginn zwou Haaptarten vu Schleifen am Python: fir a während. De stäerkste populär ass fir.
Zousätzlech zu spezifeschen Aktiounen, kënnt Dir verschidde Code-Stécker bis zu engem bestëmmte Punkt schloen. Dëst kann eng gewëssen Unzuel vun Mol sinn, oder soulaang e bestëmmten Zoustand wouer ass.
Ier mer ufänken d'Zorte vu Schleifen ze verstoen a wärend, besonnesch, musse mir nach ëmmer verstoen wat Iteratioun ass. Dëst ass eng Widderhuelung vun enger Handlung oder Sequenz vun Aktiounen während dem aktuellen Zyklus bannent der aktueller Applikatioun.
Zyklus fir
Eis For Loop ass kee Konter, wéi a villen anere Sproochen. Seng Aufgab ass eng gewësse Sequenz vu Wäerter opzezielen. Wat heescht dat? Loosst eis soen datt mir eng Lëscht vun Elementer hunn. Als éischt hëlt d'Loop déi éischt, zweet, drëtt, a sou weider.
De Virdeel vun dëser Loop am Python ass datt Dir net den Index vum Element muss bestëmmen fir ze wëssen wéini Dir aus der Loop kënnt. Alles gëtt automatesch gemaach.
>>> spisok = [10, 40, 20, 30]
>>> fir Element am spisok:
… print(element + 2)
...
12
42
22
32
An eisem Beispill hu mir d'Variabel benotzt Element no der fir Kommando. Am Allgemengen kann den Numm alles sinn. Zum Beispill, eng populär Bezeechnung ass i. A mat all Iteratioun gëtt dës Variabel e spezifescht Objet aus der Lëscht zougewisen, wat mir dat entspriechend Wuert genannt hunn.
An eisem Fall ass d'Lëscht eng Sequenz vun den Zuelen 10,40,20,30. Bei all Iteratioun erschéngt de entspriechende Wäert an der Variabel. Zum Beispill, soubal d'Loop ufänkt, ass d'Variabel Element de Wäert 10 zougewisen. Op der nächster Iteratioun ginn déi zéng an d'Nummer 40, déi drëtte Kéier an d'Nummer 20, a schliisslech, op der leschter Iteratioun vun der Loop, gëtt se an 30.
D'Signal fir d'Enn vum Zyklus ass d'Enn vun den Elementer an der Lëscht.
Wann Dir d'Loop braucht fir eng klassesch Opzielung vu Wäerter auszeféieren, wéi an anere Programméierungssproochen, sollt Dir eng Lëscht mat enger Sequenz vun natierlechen Zuelen erstellen bis zum Wäert dee mir brauchen.
>>> spisok = [1,2,3,4,5]
Oder benotzt d'Funktioun len(), d'Längt vun der Lëscht ze bestëmmen. Awer an dësem Fall ass et besser eng Loop ze benotzen während, well et net néideg ass eng Variabel ze benotzen.
Wann Dir d'Sequenz vun de Wäerter an der Lëscht ännere musst, loosst fir an hei kënnt zur Rettung. Fir dëst ze maachen, bei all Iteratioun, muss all Element vun der Lëscht e passende Wäert zougewisen ginn.
Während Loop
Am Géigesaz zum Zyklus fir, déi einfach iwwer d'Wäerter vun der Sequenz, der Loop iteréiert iwwerdeems huet méi Gebrauch. Den Numm vun dëser Zort Zyklen gëtt als "nach" iwwersat. Dat heescht, "bis".
Dëst ass eng universell Loop déi an all Programméierungssprooche fonnt gëtt. An op e puer Manéier gläicht et engem bedingte Bedreiwer jo, déi e Scheck mécht fir ze kucken ob eng bestëmmte Konditioun erfëllt ass. Nëmmen am Géigesaz zum bedingte Bedreiwer, iwwerdeems mécht de Scheck bei all Iteratioun, net nëmmen eemol. A nëmmen wann d'Konditioun falsch ass, endet d'Loop an de Kommando deen et follegt gëtt ausgefouert. An einfache Wierder, wann d'Situatioun an där hie schafft net méi gëlteg ass.
Wa mir en Zyklus molen iwwerdeems simplistically, dëst ass mat esou engem Schema gemaach.
D'Haaptzweig vum Programm (deen ausserhalb vun der Loop leeft) ass an dëser Figur mat bloe Rechtecker duergestallt. Türkis stellt de Kierper vum Zyklus duer. Am Tour ass e Rhombus eng Bedingung déi bei all Iteratioun gepréift gëtt.
Cycle iwwerdeems kann zu zwou Ausnahmen féieren:
- Wann am Ufank vun der Loop de logesche Ausdrock net richteg zréckkënnt, da fänkt et einfach net un, nodeems se virum Ausféierung ofgeschloss ass. Am Allgemengen ass dës Situatioun normal, well ënner bestëmmten Ëmstänn kann d'Applikatioun net d'Präsenz vun Ausdrock am Loopkierper ubidden.
- Wann den Ausdrock ëmmer richteg ass, kann dat zu enger Loop féieren. Dat ass, zum endlosen Scrollen vum Zyklus. Dofir, an esou Programmer, soll et ëmmer eng Austrëtt Ausso vun der Loop oder Programm ginn. Wéi och ëmmer, dës Situatioun wäert entstoen wann de Programm d'Wourecht oder d'Falsitéit vun engem bestëmmten Zoustand konnt bestëmmen. Wann hatt dëst net gemaach huet, da gëtt e Feeler mat der Ofschloss vum Programm zréckginn. Oder Dir kënnt de Feeler handhaben, an dann, wann et geschitt, gëtt bestëmmte Code ausgefouert.
Et kann eng grouss Zuel vun Optiounen ginn fir wéi e Feeler ze verschaffen. Zum Beispill kann de Programm de Benotzer froen d'Donnéeën korrekt anzeginn. Also, wann eng Persoun eng negativ Zuel uginn wou et nëmme positiv ka sinn, oder Buschtawen aginn wou nëmmen Zuelen sollen sinn, kann de Programm doriwwer soen.
Wärend Loop Beispiller
Hei ass e Beispill vu Code deen e Feeler an dësem Fall behandelt.
n = input("Enter an integer: ")
während Typ(n) != int:
Probéiert:
n = int(n)
ausser ValueError:
print ("falsch Entrée!")
n = input("Enter an integer: ")
wann n % 2 == 0:
print ("Och")
anescht:
print ("Odd")
Denkt drun datt Python Colonen benotzt fir komplex Codekonstruktiounen ze deklaréieren.
Am Code hei uewen hu mir als Bedingung definéiert datt mir sollten iwwerpréiwen ob d'Zuel eng ganz Zuel ass. Wann jo, da gëtt falsch zréckginn. Wann net, dann richteg.
Am zweeten Deel vum Code, wou de Bedreiwer benotzt gëtt if, mir hunn den % Bedreiwer benotzt fir de Rescht no der Divisiounsoperatioun ze fannen. De nächste Schrëtt ass ze kontrolléieren ob d'Zuel souguer ass. Wann net, dann ass de Rescht an dësem Fall een. Deementspriechend ass d'Zuel komesch.
An einfache Begrëffer, den uewe genannte Code iwwerpréift als éischt ob d'String, déi vum Benotzer aginn ass, eng Nummer ass. Wann jo, da gëtt eng zweet Kontroll gemaach fir ze kucken ob et e Rescht vun der Divisioun duerch zwee ass. Awer den zweete Block gëtt net ausgefouert bis de Wäert, deen de Benotzer aginn huet, numeresch ass.
Dat ass, d'Loop gëtt regelméisseg ausgefouert bis d'Konditioun geschitt. An dëser Situatioun funktionnéiert et esou.
Dat ass, Dir kënnt aus dem Géigendeel goen: Loop eng gewëssen Handlung bis d'Evenement falsch ass.
Code Parsing
Loosst eis elo méi detailléiert kucken wéi dëse Code funktionnéiert. Fir dëst ze maachen, analyséiere mir et Schrëtt fir Schrëtt.
- Als éischt gitt de Benotzer eng String, déi vun der Variabel n akzeptéiert gëtt.
- Benotzt eng Loop iwwerdeems den Typ vun dëser Variabel gëtt iwwerpréift. Op der éischter Entrée ass et net gläich INT. Dofir, als Resultat vum Test, ass et festgestallt datt dës Bedingung richteg ass. Dofir gëtt de Loopkierper agefouert.
- Mat der Hëllef vun engem Bedreiwer probéieren mir probéieren eng String an eng Zuel ze konvertéieren. Wann dëst gemaach gëtt, da geschitt kee Feeler. Deementspriechend ass et net néideg et ze veraarbecht. Dofir geet den Dolmetscher zréck an den Ufank vun der Loop, an no de Resultater vum Scheck stellt sech eraus datt et en ganzt Zuel gouf. Also loosst eis op Schrëtt 7 goen
- Wann d'Konversioun net erfollegräich war, da gëtt e ValueError geworf. An dësem Fall gëtt de Programmfloss un den ausser Handler geschéckt.
- De Benotzer gitt en neie Wäert, deen d'Variabel n zougewisen gëtt.
- Den Dolmetscher geet zréck op Schrëtt 2 a kontrolléiert nach eng Kéier. Wann et en ganz Zuelenwäert ass, gitt op Schrëtt 7. Wann net, gëtt d'Konversioun nach eng Kéier no Schrëtt 3 probéiert.
- Mat der Hëllef vun engem Bedreiwer if Bestëmmt ob et e Rescht gëtt nodeems Dir eng Zuel mat 2 deelt.
- Wann net, den Text "souguer" gëtt zréck.
- Wann net, gëtt den Text "komesch" zréckginn.
Betruecht elo esou e Beispill. Probéiert ze bestëmmen wéivill Mol dësen Zyklus duerchgoe wäert?
Ganzen = 100
ech = 0
wann ech <5:
n = int(input())
Gesamt = Gesamt — n
ech = ech + 1
print(“Rescht”, total)
Déi richteg Äntwert ass 5. Ufank, de Wäert vun der Variabel i - null. Den Dolmetscher kontrolléiert ob d'Variabel gläich ass i 4 oder manner. Wann jo, da gëtt de Wäert zréck. richteg, an d'Loop gëtt deementspriechend ausgefouert. De Wäert gëtt ëm ee erhéicht.
No der éischter Iteratioun gëtt de Wäert vun der Variabel 1. E Scheck gëtt gemaach, an de Programm versteet datt dës Zuel erëm manner wéi 5 ass. Deementspriechend gëtt de Loopkierper fir d'zweete Kéier ausgefouert. Well d'Schrëtt ähnlech sinn, gëtt de Wäert och ëm ee erhéicht, an d'Variabel ass elo gläich wéi 2.
Dëse Wäert ass och manner wéi fënnef. Da gëtt d'Loop eng drëtte Kéier ausgefouert, an d'Variabel bäigefüügt i 1 an et gëtt de Wäert 3 zougewisen. Dëst ass erëm manner wéi fënnef. An esou kënnt et zu der sechster Iteratioun vun der Loop, bei där de Wäert vun der Variabel i entsprécht 5 (schliisslech war et ursprénglech null, souwäit mir eis erënneren). Deementspriechend passéiert dës Bedingung net den Test, an d'Loop gëtt automatesch ofgeschloss an den Iwwergank op den nächste Schrëtt, deen dobaussen ass (oder Programmterminatioun, wann déi folgend Schrëtt net virgesinn sinn), gëtt duerchgefouert.
Den Zyklus kann och an der Géigendeel Richtung optrieden. Hei ass e Beispill vu Code wou, mat all spéider Iteratioun, een vum aktuelle Wäert vun der Variabel subtrahéiert gëtt.
Ganzen = 100
während total > 0:
n = int(input())
Gesamt = Gesamt — n
print ("Ressource ausgeschwat")
Probéiert ze roden wat dëse Programm mécht! Stellt Iech dat an enger Variabel total Informatioun iwwer de Programmressource gëtt gespäichert. All Kéiers kontrolléiert den Dolmetscher ob d'Ressource existéiert. Wann net, da gëtt den Text "Ressource erschöpft" ugewisen an de Programm mécht zou. A mat all Iteratioun vun der Loop reduzéiert d'Ressource mat der Zuel déi de Benotzer spezifizéiert.
An elo Hausaufgaben. Probéiert den uewe genannte Code z'änneren sou datt d'Variabel net kierperlech negativ ka ginn.
si Code ahaan usoo gudbi
иси
Hallo
lol