Inhalter
Am Prozess fir ze programméieren ass et dacks néideg Programmer ze kreéieren déi net sou einfach sinn am richtege Liewen ze gëllen. No all, vun Zäit zu Zäit musst Dir d'Instruktioune nëmmen ënner bestëmmte Konditiounen verfollegen. Fir dëst am Programm ëmzesetzen, hunn all Sprooche Kontroll Aussoen. Mat hirer Hëllef kënnt Dir de Flux vun der Code Ausféierung kontrolléieren, Schleifen erstellen oder bestëmmten Aktiounen ausféieren nëmmen wann e bestëmmten Zoustand wouer ass.
Haut wäerte mir iwwer d'Aussoe schwätzen, déi d'aktuell Situatioun fir e bestëmmten Zoustand kontrolléiert, a baséiert op dëser Informatioun, Entscheedungen iwwer weider Aktiounen hëlt.
Zorte vu Kontroll Aussoen
Am Allgemengen, wann ass net déi eenzeg Ausso déi de Flux vun engem Programm kontrolléiert. Wéi och hien selwer kann e Bestanddeel vun enger méi grousser Kette vu Betreiber sinn.
Et ginn och Loops an Aussoen déi de Prozess vu senger Ausféierung kontrolléieren. Haut schwätze mir nëmmen iwwer de bedingte Bedreiwer an d'Ketten, an deenen et matmaachen kann.
Beim Programméiere gëtt et sou eppes wéi Verzweigung. Genau dat heescht eng Sequenz vu Kommandoen déi nëmmen ausgefouert gëtt wann eng bestëmmte Conditioun wouer ass. D'Critèrë selwer kënnen ënnerschiddlech sinn:
- Gläichheet vun enger Variabel zu engem bestëmmte Wäert.
- Eng spezifesch Aktioun ausféieren.
- Applikatioun Staat (zesummegefall oder net).
De Spektrum ka vill méi grouss sinn. Conditional Aussoe kommen a verschiddenen Typen:
- Mat enger Branche. Dat ass, gëtt eng eenzeg Kontroll duerchgefouert, als Resultat vun deem bestëmmte Aktiounen duerchgefouert ginn.
- Mat zwee oder méi Branchen. Wann de Critère 1 wouer ass, da kontrolléiert de Critère 2. Wann et richteg ass, da kontrolléiert 3. An esou, maacht esou vill Kontrollen wéi néideg.
- Mat verschiddene Konditiounen. Alles ass einfach hei. Den Dolmetscher kontrolléiert op verschidde Konditiounen oder ee vun hinnen.
wann Ausso
D'Struktur vun der If Ausso ass ähnlech an alle Sproochen. Wéi och ëmmer, am Python ass seng Syntax e bëssen anescht wéi all deenen aneren:
wann Konditioun:
<входящее выражение 1>
<входящее выражение 2>
<net входящее выражение>
Als éischt gëtt de Bedreiwer selwer deklaréiert, duerno gëtt d'Konditioun geschriwwen, ënner deenen et ufänkt ze schaffen. D'Konditioun kann entweder richteg oder falsch sinn.
Dëst ass gefollegt vun engem Block mat Kommandoen. Wann et direkt e Critère follegt deen erfëllt muss ginn, da gëtt déi entspriechend Sequenz vun Kommandoen en If Block genannt. Dir kënnt all Zuel vu Befehle benotzen.
Opgepasst! D'Entéierung an all wann Blockbefehle muss déiselwecht Gréisst sinn. D'Blockgrenze ginn duerch d'Indents festgeluecht.
No der Sproochdokumentatioun ass d'Abréckung 4 Plazen.
Wéi funktionéiert dësen Operateur? Wann den Dolmetscher d'If-Wuert gesäit, kontrolléiert hien direkt den Ausdrock géint d'Benotzerspezifizéierte Critèren. Wann dat de Fall ass, da fänkt hien no Instruktiounen ze sichen an se ze verfollegen. Soss ginn all Kommandoen aus dësem Block iwwersprangen.
Wann eng Ausso no der Bedingung net agedréckt ass, gëtt se net als If Block behandelt. An eiser Situatioun ass dës Linn
Hei ass e Code Snippet fir e Beispill wéi dësen Bedreiwer funktionnéiert.
number = int(input(“Enter a number: “))
wann Zuel > 10:
print ("D'Zuel ass méi wéi 10")
Dëse Programm freet de Benotzer fir eng Zuel a kontrolléiert ob se méi grouss ass wéi 10. Wann jo, gëtt et déi entspriechend Informatioun zréck. Zum Beispill, wann de Benotzer d'Nummer 5 agitt, da wäert de Programm einfach ophalen, an dat ass et.
Awer wann Dir d'Zuel 100 spezifizéiert, da versteet den Dolmetscher datt et méi wéi zéng ass, a mellt et.
Opgepasst! An eisem Fall, wann d'Konditioun falsch ass, stoppt de Programm, well keng Kommandoen no der Instruktioun ginn.
Et gëtt nëmmen ee Kommando am uewe genannte Code. Mee et gi vill méi vun hinnen. Déi eenzeg Fuerderung ass entréieren.
Loosst eis elo dës Sequenz vu Kommandoen analyséieren.
number = int(input ("Schreift eng Zuel:"))
wann Zuel > 10:
print ("éischt Zeil")
print ("zweet Zeil")
print ("drëtt Linn")
print ("D'Linn déi ausgefouert gëtt, onofhängeg vun der aginn Zuel")
print ("Enn Applikatioun")
Probéiert ze roden wat d'Ausgab wäert sinn wann Dir d'Wäerter 2, 5, 10, 15, 50 aginn.
Wéi Dir gesitt, wann d'Zuel, déi vum Benotzer aginn ass, méi wéi zéng ass, da ginn dräi Zeilen erausginn + eng mam Text "All Kéier lafen ..." an eng "Enn", a wa manner wéi zéng, dann nëmmen eng, mat en aneren Text. Nëmme Linnen 3,4,5 ginn ausgefouert wann et richteg ass. Wéi och ëmmer, déi lescht zwou Zeilen wäerte geschriwwe ginn egal wéi eng Zuel de Benotzer spezifizéiert.
Wann Dir d'Aussoen direkt an der Konsole benotzt, da wäert d'Resultat anescht sinn. Den Dolmetscher schalt direkt de Multi-Line Modus un, wann, nodeems Dir de Verifizéierungscritère uginn hutt, Enter dréckt.
Ugeholl datt mir déi folgend Sequenz vu Kommandoen geschriwwen hunn.
>>>
>>> n = 100
>>> wann n > 10:
...
Duerno gesi mer datt >>> duerch Ellipsis ersat gouf. Dëst bedeit datt de Multiline Input Modus aktivéiert ass. An einfache Wierder, wann Dir Enter dréckt, gitt Dir op den Input vun der zweeter Stuf vun der Instruktioun transferéiert.
A fir aus dësem Block erauszekommen, musst Dir nach eng Konstruktioun op de Block addéieren if.
>>>
>>> n = 100
>>> wann n > 10:
… print(«nv 10»)
...
Wann d'Konditioun net stëmmt, geet de Programm op. Dëst ass e Problem, well de Benotzer kann esou e Programm gesinn als zougemaach wéinst engem Feeler. Dofir ass et néideg fir de Benotzer Feedback ze ginn. Fir dëst gëtt e Link benotzt wann-anescht.
Ausdrock Bedreiwer wann-anescht
Dëse Bedreiwer erlaabt Iech e Link ëmzesetzen: wann den Ausdrock mat enger bestëmmter Regel entsprécht, maacht dës Aktiounen, a wann net, dann anerer. Dat ass, et erlaabt Iech de Flux vum Programm an zwou Stroossen opzedeelen. D'Syntax ass intuitiv:
wann Konditioun:
# wann blockéieren
Ausso 1
Ausso 2
an esou weider
anescht:
# anescht blockéieren
Ausso 3
Ausso 4
a sou weider:
Loosst eis erkläre wéi dësen Bedreiwer funktionnéiert. Als éischt gëtt d'Standard Ausso am Fuedem ausgefouert jo, kontrolléieren ob et passt Zoustand "richteg oder falsch". Weider Aktiounen hänkt vun de Resultater vum Scheck of. Wann richteg, gëtt d'Instruktioun déi an der Sequenz vun den Instruktiounen no der Bedingung ass direkt ausgefouert. jo, wann et falsch ass, dann aneren.
Op dës Manéier kënnt Dir Feeler behandelen. Zum Beispill muss de Benotzer e Radius aginn. Natierlech kann et nëmmen eng Zuel mat engem Plus Zeechen sinn, oder et ass en Nullwäert. Wann et manner wéi 0 ass, da musst Dir e Message erausginn fir Iech eng positiv Zuel anzeginn.
Hei ass de Code deen dës Aufgab implementéiert. Mee et gëtt ee Feeler hei. Probéiert ze roden wéi eng.
radius = int(input("Enter radius: "))
wann Radius >= 0:
print("Circumference = ", 2 * 3.14 * Radius)
print("Area = ", 3.14 * Radius ** 2)
anescht:
print ("Gitt w.e.g. eng positiv Zuel un")
Indentatioun Mëssverständnis Feeler. Wann ech Aner muss ouni si lokaliséiert sinn oder mat der selwechter Zuel vun hinnen (je no ob se nestéiert sinn oder net).
Loosst eis en anere Benotzungsfall ginn (wou alles richteg ass mat der Bedreiwerausrichtung) - en Applikatiounselement dat e Passwuert iwwerpréift.
Passwuert = Input ("Enter Passwuert: ")
wann Passwuert == «sshh»:
print ("Wëllkomm")
anescht:
print ("Zougang refuséiert")
Dës Instruktioun spréngt d'Persoun weider wann d'Passwuert sshh ass. Wann eng aner Kombinatioun vu Buschtawen an Zuelen, dann weist et de Message "Zougang refuséiert".
Ausso-Ausdrock wann-elif-aner
Nëmme wann verschidde Konditioune net stëmmen, gëtt d'Ausso déi am Block ass ausgefouert. aneren. Dësen Ausdrock funktionnéiert esou.
wann Konditioun_1:
# wann blockéieren
Ausso
Ausso
méi Ausso
elif Zoustand_2:
# éischten elif Block
Ausso
Ausso
méi Ausso
elif Zoustand_3:
# zweet elif Block
Ausso
Ausso
méi Ausso
...
aneren
Ausso
Ausso
méi Ausso
Dir kënnt all Zuel vun zousätzlech Konditiounen uginn.
Nested Aussoen
En anere Wee fir verschidde Konditiounen ëmzesetzen ass zousätzlech Conditiounschecken am If Block anzeginn.
Betreiber if an engem anere Conditiounsblock
gre_score = int(input(“Gitt Är aktuell Kreditlimit an”))
per_grad = int(input ("Gitt Är Kredittbewäertung un:"))
wann per_grad > 70:
# baussenzege wann Block
wann gre_score > 150:
# banneschten wann Block
print ("Félicitatiounen, Dir hutt e Prêt kritt")
anescht:
print ("Entschëllegt, Dir sidd net berechtegt fir e Prêt")
Dëse Programm mécht e Kredittbewäertungscheck. Wann et manner wéi 70 ass, bericht de Programm datt de Benotzer net fir Kreditt berechtegt ass. Wann et méi grouss ass, gëtt eng zweet Kontroll gemaach fir ze kucken ob déi aktuell Kreditlimit méi grouss ass wéi 150. Wann jo, da gëtt e Message ugewisen datt de Prêt ausgestallt gouf.
Wa béid Wäerter falsch sinn, gëtt e Message ugewisen datt de Benotzer net d'Méiglechkeet huet e Prêt ze kréien.
Loosse mer dee Programm e bëssen ëmschaffen.
gre_score = int(input ("Enter aktuell Limit: "))
per_grad = int(input(“Enter Credit Score: “))
wann per_grad > 70:
wann gre_score > 150:
print ("Félicitatiounen, Dir hutt e Prêt kritt")
anescht:
print ("Är Kredittlimit ass niddereg")
anescht:
print ("Entschëllegt, Dir sidd net berechtegt fir Kreditt")
De Code selwer ass ganz ähnlech, awer nested if bitt och en Algorithmus am Fall wou d'Conditioun dovunner falsch ass. Dat ass, d'Limite op der Kaart ass net genuch, awer d'Kreditgeschicht ass gutt, de Message "Dir hutt eng niddreg Kredittbewäertung" gëtt ugewisen.
wann-soss Ausso bannent engem Zoustand aneren
Loosst eis en anere Programm maachen, deen de Grad vun engem Student baséiert op Tester Scores bestëmmt.
score = int(input ("Gitt Äre Score an:"))
wann Score >= 90:
print ("Super! Äre Grad ass A")
anescht:
wann Score >= 80:
print ("Super! Äre Grad ass B")
anescht:
wann Score >= 70:
print ("Gutt! Äre Grad ass C")
anescht:
wann Score >= 60:
print ("Äre Grad ass D. Et ass derwäert d'Material ze widderhuelen.")
anescht:
print ("Dir hutt den Examen gescheitert")
D'Applikatioun iwwerpréift als éischt fir ze kucken ob de Score méi grouss ass wéi oder gläich wéi 90. Wann jo, da gëtt et en A Grad zréck. Wann dës Konditioun falsch ass, da gi spéider Kontrollen duerchgefouert. Mir gesinn datt den Algorithmus op den éischte Bléck bal d'selwecht ass. Also amplaz bannen ze kontrolléieren aneren besser eng Kombinatioun ze benotzen wann-elif-aner.
Also de Bedreiwer if mécht eng ganz wichteg Funktioun - et mécht sécher datt bestëmmte Code Stécker nëmmen ausgefouert ginn wann et néideg ass. Et ass onméiglech virzestellen ouni et ze programméieren, well och déi einfachst Algorithmen erfuerderen Gabel wéi "wann Dir no lénks gitt, fannt Dir et, a wann Dir no riets gitt, da musst Dir dat an dat maachen."