TOC

So schreiben Sie bedingte Anweisungen in Python 3

Einführung

Bedingte Anweisungen sind Teil jeder Programmiersprache. Mit bedingten Anweisungen können wir Code haben, der je nach den Bedingungen des Programms zu diesem Zeitpunkt manchmal ausgeführt wird und zu anderen Zeiten nicht ausgeführt wird.

Wenn wir jede Anweisung eines Programms vollständig ausführen und mit jeder ausgeführten Zeile von oben nach unten gehen, fordern wir das Programm nicht auf, bestimmte Bedingungen auszuwerten. Mithilfe von bedingten Anweisungen können Programme ermitteln, ob bestimmte Bedingungen erfüllt sind, und dann erfahren, was als Nächstes zu tun ist.

Schauen wir uns einige Beispiele an, in denen wir bedingte Anweisungen verwenden würden:

  • Wenn die Schülerin bei ihrem Test mehr als 65% erhält, geben Sie an, dass ihre Note bestanden wurde. Wenn nicht, melde, dass ihre Note nicht bestanden hat

  • Wenn er Geld auf seinem Konto hat, berechnen Sie die Zinsen. Wenn dies nicht der Fall ist, wird eine Strafgebühr erhoben

  • Wenn sie 10 Orangen oder mehr kaufen, berechnen sie einen Rabatt von 5%; Wenn sie weniger kaufen, dann nicht

Durch Auswerten der Bedingungen und Zuweisen von Code zur Ausführung basierend darauf, ob diese Bedingungen erfüllt sind oder nicht, schreiben wir bedingten Code.

In diesem Tutorial werden Sie durch das Schreiben von bedingten Anweisungen in der Programmiersprache Python geführt.

If-Anweisung

Wir beginnen mit der Anweisung + if +, die bewertet, ob eine Anweisung wahr oder falsch ist, und führen den Code nur für den Fall aus, dass die Anweisung wahr ist.

Öffnen Sie in einem Nur-Text-Editor eine Datei und schreiben Sie den folgenden Code:

grade = 70

if grade >= 65:
   print("Passing grade")

Mit diesem Code haben wir die Variable "+ grade " und geben ihr den ganzzahligen Wert " 70 ". Wir verwenden dann die Anweisung " if ", um zu bewerten, ob die variable Note größer oder gleich ("> = ") zu " 65 " ist. Wenn diese Bedingung erfüllt ist, wird das Programm angewiesen, die https://www.digitalocean.com/community/tutorial_series/working-with-strings-in-python-3[string] ` Passing grade +` auszudrucken.

Speichern Sie das Programm als + grade.py + und führen Sie es unter https://www.digitalocean.com/community/tutorial_series/how-to-install-and-set-up-a-local-programming-environment-for aus -python-3 [lokale Programmierumgebung aus einem Terminalfenster] mit dem Befehl + python grade.py +.

In diesem Fall erfüllt die Note 70 die Bedingung größer oder gleich 65, sodass Sie die folgende Ausgabe erhalten, sobald Sie das Programm ausführen:

OutputPassing grade

Ändern wir nun das Ergebnis dieses Programms, indem wir den Wert der Variablen "+ grade " in " 60 +" ändern:

grade.py

grade = 60

if grade >= 65:
   print("Passing grade")

Wenn wir diesen Code speichern und ausführen, erhalten wir keine Ausgabe, da die Bedingung nicht erfüllt war und wir das Programm nicht angewiesen haben, eine andere Anweisung auszuführen.

Um ein weiteres Beispiel zu geben, lassen Sie uns berechnen, ob ein Bankkontostand unter 0 liegt. Erstellen wir eine Datei mit dem Namen "+ account.py +" und schreiben das folgende Programm:

account.py

balance = -5

if balance < 0:
   print("Balance is below 0, add funds now or you will be charged a penalty.")

Wenn wir das Programm mit "+ python account.py +" ausführen, erhalten wir die folgende Ausgabe:

OutputBalance is below 0, add funds now or you will be charged a penalty.

Im Programm haben wir die Variable "+ balance " mit dem Wert " -5 " initialisiert, der kleiner als 0 ist. Da der Saldo die Bedingung der Anweisung " if " (" balance <0 +") erfüllt, erhalten wir nach dem Speichern und Ausführen des Codes die Zeichenfolgenausgabe. Auch hier erhalten wir keine Ausgabe, wenn wir den Saldo auf 0 oder eine positive Zahl ändern.

Sonst Aussage

Es ist wahrscheinlich, dass wir wollen, dass das Programm etwas tut, auch wenn eine "+ if +" - Anweisung "false" ergibt. In unserem Notenbeispiel möchten wir die Ausgabe unabhängig davon, ob die Note bestanden wurde oder nicht.

Dazu fügen wir der obigen Notenbedingung eine + else + -Anweisung hinzu, die wie folgt aufgebaut ist:

grade.py

grade = 60

if grade >= 65:
   print("Passing grade")

else:
   print("Failing grade")

Da die Notenvariable oben den Wert "+ 60 " hat, wird die " if " - Anweisung als falsch ausgewertet, sodass das Programm nicht " Passing grade +" ausgibt. Die folgende + else + -Anweisung weist das Programm an, trotzdem etwas zu tun.

Wenn wir das Programm speichern und ausführen, erhalten wir die folgende Ausgabe:

OutputFailing grade

Wenn wir dann das Programm umschreiben, um der Note einen Wert von "+ 65 " oder höher zu geben, erhalten wir stattdessen die Ausgabe " Bestehen der Note +".

Um dem Bankkontobeispiel ein "+ else +" - Statement hinzuzufügen, schreiben wir den Code wie folgt um:

account.py

balance = 522

if balance < 0:
   print("Balance is below 0, add funds now or you will be charged a penalty.")

else:
   print("Your balance is 0 or above.")
OutputYour balance is 0 or above.

Hier haben wir den Variablenwert "+ balance " in eine positive Zahl geändert, sodass die Anweisung " else " ausgegeben wird. Um die erste " if +" - Anweisung zu drucken, können wir den Wert in eine negative Zahl umschreiben.

Indem Sie eine "+ if " - Anweisung mit einer " else " - Anweisung kombinieren, erstellen Sie eine zweiteilige bedingte Anweisung, die den Computer anweist, bestimmten Code auszuführen, unabhängig davon, ob die " if +" - Bedingung erfüllt ist oder nicht.

Andernfalls if-Anweisung

Bisher haben wir eine boolesche Option für bedingte Anweisungen vorgestellt, bei der jede "+ if " - Anweisung entweder "true" oder "false" ergibt. In vielen Fällen möchten wir ein Programm, das mehr als zwei mögliche Ergebnisse bewertet. Dazu verwenden wir eine * else if * -Anweisung, die in Python als ` elif ` geschrieben ist. Die ' elif'- oder' if'-Anweisung sieht aus wie die '+ if'-Anweisung und wertet eine andere Bedingung aus.

Im Bankkontoprogramm möchten wir möglicherweise drei diskrete Ausgaben für drei verschiedene Situationen haben:

  • Der Saldo liegt unter 0

  • Der Saldo ist gleich 0

  • Der Saldo liegt über 0

Die + elif + -Anweisung wird wie folgt zwischen die + if + -Anweisung und die + else + -Anweisung gesetzt:

account.py

. . .
if balance < 0:
   print("Balance is below 0, add funds now or you will be charged a penalty.")

elif balance == 0:
   print("Balance is equal to 0, add funds soon.")

else:
   print("Your balance is 0 or above.")

Jetzt gibt es drei mögliche Ausgaben, die auftreten können, wenn wir das Programm ausführen:

  • Wenn die Variable "+ balance " gleich " 0 " ist, erhalten wir die Ausgabe von " elif " (" balance ist gleich 0, füge bald Geld hinzu. +")

  • Wenn die Variable "+ balance " auf eine positive Zahl gesetzt ist, erhalten wir die Ausgabe der Anweisung " else " (" Ihr Kontostand ist 0 oder höher. +").

  • Wenn die Variable "+ balance " auf eine negative Zahl gesetzt ist, ist die Ausgabe die Zeichenfolge aus der " if " - Anweisung (" balance ist unter 0", fügen Sie jetzt Geld hinzu, oder Sie werden mit einer Strafe belastet + ").

Was ist, wenn wir mehr als drei Möglichkeiten haben wollen? Wir können dies tun, indem wir mehr als eine "+ elif +" - Anweisung in unseren Code schreiben.

Schreiben wir den Code im Programm "+ grade.py +" so, dass es ein paar Buchstabengrade gibt, die Bereichen numerischer Grade entsprechen:

  • 90 oder höher entspricht einer A-Note

  • 80-89 entspricht einer B-Note

  • 70-79 entspricht einer C-Note

  • 65-69 entspricht einer D-Note

  • 64 oder weniger entspricht einer F-Note

Um diesen Code auszuführen, benötigen wir eine + if + -Anweisung, drei + elif + -Anweisungen und eine + else + -Anweisung, die alle fehlgeschlagenen Fälle behandelt.

Schreiben wir den Code aus dem obigen Beispiel neu, um Zeichenfolgen zu erhalten, mit denen die einzelnen Buchstabenklassen gedruckt werden. Wir können unsere + else + -Anweisung beibehalten.

grade.py

. . .
if grade >= 90:
   print("A grade")

elif grade >=80:
   print("B grade")

elif grade >=70:
   print("C grade")

elif grade >= 65:
   print("D grade")

else:
   print("Failing grade")

Da "+ elif +" - Anweisungen in der richtigen Reihenfolge ausgewertet werden, können wir unsere Anweisungen ziemlich einfach halten. Dieses Programm führt die folgenden Schritte aus:

  1. Wenn die Note größer als 90 ist, gibt das Programm "+ A Note +" aus. Wenn die Note kleiner als 90 ist, fährt das Programm mit der nächsten Anweisung fort.

  2. Wenn die Note größer oder gleich 80 ist, gibt das Programm "+ B Note +" aus. Wenn die Note 79 oder weniger ist, fährt das Programm mit der nächsten Anweisung fort.

  3. Wenn die Note größer oder gleich 70 ist, gibt das Programm "+ C Note +" aus. Wenn die Note 69 oder weniger ist, fährt das Programm mit der nächsten Anweisung fort.

  4. Wenn die Note größer oder gleich 65 ist, gibt das Programm "+ D Note +" aus. Wenn die Note 64 oder niedriger ist, fährt das Programm mit der nächsten Anweisung fort.

  5. Das Programm gibt "+ Bewertung nicht bestanden +" aus, da nicht alle der oben genannten Bedingungen erfüllt wurden.

Verschachtelte If-Anweisungen

Sobald Sie sich mit den Anweisungen "+ if", "+ elif" und "+ else" vertraut gemacht haben, können Sie mit verschachtelten bedingten Anweisungen fortfahren. Wir können geschachtelte "+ if" -Anweisungen für Situationen verwenden, in denen wir nach einer Sekundärbedingung suchen möchten, wenn die erste Bedingung als wahr ausgeführt wird. Dafür können wir eine if-else-Anweisung innerhalb einer anderen if-else-Anweisung haben. Sehen wir uns die Syntax einer verschachtelten "+ if +" - Anweisung an:

if statement1:              #outer if statement
   print("true")

   if nested_statement:    #nested if statement
       print("yes")

   else:                   #nested else statement
       print("no")

else:                       #outer else statement
   print("false")

Einige mögliche Ausgaben können sich aus diesem Code ergeben:

  • Wenn "+ Anweisung1 " als wahr ausgewertet wird, wertet das Programm aus, ob das " verschachtelte_Anweisung +" ebenfalls als wahr ausgewertet wird. Wenn beide Fälle zutreffen, lautet die Ausgabe:

_ _

Outputtrue
yes

_ _

  • Wenn jedoch "+ Anweisung1 " als wahr ausgewertet wird, " verschachtelte_Anweisung +" jedoch als falsch ausgewertet wird, lautet die Ausgabe:

_ _

Outputtrue
no

_ _

  • Und wenn "+ statement1 " false ergibt, wird die verschachtelte if-else-Anweisung nicht ausgeführt, sodass die " else +" - Anweisung alleine ausgeführt wird, und die Ausgabe lautet:

_ _

Outputfalse

_ _

Es können auch mehrere "+ if +" - Anweisungen im gesamten Code verschachtelt sein:

if statement1:                  #outer if
   print("hello world")

   if nested_statement1:       #first nested if
       print("yes")

   elif nested_statement2:     #first nested elif
       print("maybe")

   else:                       #first nested else
       print("no")

elif statement2:                #outer elif
   print("hello galaxy")

   if nested_statement3:       #second nested if
       print("yes")

   elif nested_statement4:     #second nested elif
       print("maybe")

   else:                       #second nested else
       print("no")

else:                           #outer else
   statement("hello universe")

In dem obigen Code gibt es eine geschachtelte "+ if " - Anweisung in jeder " if" -Anweisung zusätzlich zu der "+ elif" -Anweisung. Dies ermöglicht mehr Optionen innerhalb jeder Bedingung.

Schauen wir uns ein Beispiel für verschachtelte "+ if " - Anweisungen mit unserem " grade.py " - Programm an. Wir können prüfen, ob eine Note zuerst besteht (größer oder gleich 65%) und dann bewerten, welcher Buchstabennote die numerische Note entsprechen soll. Wenn die Note nicht bestanden wird, müssen wir die Buchstabennoten nicht durchlaufen. Stattdessen kann das Programm melden, dass die Note nicht bestanden wird. Unser modifizierter Code mit der verschachtelten " if +" - Anweisung sieht folgendermaßen aus:

grade.py

. . .
if grade >= 65:
   print("Passing grade of:")

   if grade >= 90:
       print("A")

   elif grade >=80:
       print("B")

   elif grade >=70:
       print("C")

   elif grade >= 65:
       print("D")

else:
   print("Failing grade")

Wenn wir den Code mit der Variable "+ grade " ausführen, die auf den ganzzahligen Wert " 92 " gesetzt ist, ist die erste Bedingung erfüllt und das Programm gibt " Passing grade of: " aus. Als nächstes wird geprüft, ob die Note größer oder gleich 90 ist, und da diese Bedingung ebenfalls erfüllt ist, wird " A +" ausgegeben.

Wenn wir den Code mit der Variable "+ grade " auf " 60 " ausführen, ist die erste Bedingung nicht erfüllt, sodass das Programm die verschachtelten " if " - Anweisungen überspringt und zur " else " - Anweisung wechselt , wobei das Programm " Fehlnote +" ausgibt.

Wir können dem natürlich noch weitere Optionen hinzufügen und eine zweite Schicht verschachtelter if-Anweisungen verwenden. Vielleicht wollen wir die Noten A +, A und A- getrennt bewerten. Wir können dies tun, indem wir zuerst prüfen, ob die Note bestanden wird, dann prüfen, ob die Note 90 oder höher ist, und dann prüfen, ob die Note zum Beispiel für ein A + über 96 liegt:

grade.py

. . .
if grade >= 65:
   print("Passing grade of:")

   if grade >= 90:
       if grade > 96:
           print("A+")

       elif grade > 93 and grade <= 96:
           print("A")

       elif grade >= 90:
           print("A-")
. . .

Im obigen Code führt das Programm für eine Variable "+ grade ", die auf " 96 +" gesetzt ist, Folgendes aus:

  1. Überprüfen Sie, ob die Note größer oder gleich 65 ist (wahr)

  2. Ausdrucken + Bestehen der Note von: +

  3. Überprüfen Sie, ob die Note größer oder gleich 90 ist (wahr)

  4. Überprüfen Sie, ob die Note größer als 96 ist (falsch)

  5. Überprüfen Sie, ob die Note größer als 93 und auch kleiner oder gleich 96 (wahr) ist.

  6. Drucken Sie + A +

  7. Belassen Sie diese verschachtelten bedingten Anweisungen und fahren Sie mit dem verbleibenden Code fort

Die Ausgabe des Programms für eine Note von 96 sieht also so aus:

OutputPassing grade of:
A

Verschachtelte "+ if +" - Anweisungen bieten die Möglichkeit, Ihrem Code mehrere spezifische Bedingungen hinzuzufügen.

Fazit

Durch die Verwendung von bedingten Anweisungen wie der "+ if +" - Anweisung haben Sie eine bessere Kontrolle über die Ausführung Ihres Programms. Bedingte Anweisungen weisen das Programm an, zu bewerten, ob eine bestimmte Bedingung erfüllt ist. Wenn die Bedingung erfüllt ist, wird ein bestimmter Code ausgeführt. Wenn sie jedoch nicht erfüllt ist, wird das Programm weiter zu einem anderen Code verschoben.

Verwenden Sie zum Üben bedingter Anweisungen verschiedene operators, und kombinieren Sie die Operatoren mit + und + `oder + oder + `und Verwendung von bedingten Anweisungen neben loops. Sie können auch unser Tutorial unter How To Make a Simple Calculator Program durchgehen. um sich mit bedingten Aussagen vertraut zu machen.

Related