Python-Schleifen - Für, während, verschachtelte Schleifen mit Beispielen

python loops while

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

Wählen Sie Das Betriebssystem Aus Wählen Sie Ein Projektionsprogramm (Optional)

Beschreiben Sie Ihr Problem

In diesem Video-Tutorial wird die Rolle von Loops in Python und ihre Typen erläutert: Für, While, verschachtelte Loops mit Syntax und praktischen Programmierbeispielen:

Wir haben etwas über die vier verschiedenen gelernt Bedingte Anweisungen in Python in unserem vorherigen Tutorial.

Loops sind leistungsstarke Programmierkonzepte, die von fast allen modernen Programmiersprachen unterstützt werden. Es ermöglicht einem Programm, Iterationen zu implementieren, was im Grunde bedeutet, dass derselbe Codeblock zwei- oder mehrmals ausgeführt wird.

Obwohl sie von allen modernen Programmiersprachen unterstützt werden und ähnliche Grundfunktionen bieten, können sich ihre Implementierungen und Syntax unterscheiden.

Das Vollständige Trainingsreihe zu Python gibt Ihnen eine kurze Vorstellung davon, worum es bei Python geht.

Schleifen in Python

Was du lernen wirst:

Python Loops Video Tutorial

Was sind Python-Schleifen?

In Python werden Anweisungen sequentiell ausgeführt, d. H. Wenn unser Code aus mehreren Codezeilen besteht, beginnt die Ausführung in der ersten Zeile, gefolgt von der zweiten usw.

Es wird jedoch Fälle geben, in denen ein Codeblock möglicherweise mehrmals ausgeführt werden soll, bis eine Bedingung erfüllt ist. Dank Schleifenanweisungen können wir genau das tun.

Im Folgenden finden Sie ein Flussdiagramm, das die Funktionsweise einer Schleifenanweisung veranschaulicht.

Flussdiagramm einer Schleifenanweisung

Basierend auf dem obigen Diagramm startet ein Python-Programm um Start (Kreis), und die Ausführung fährt mit der Bedingungsanweisung (Diamant) fort. Wenn die Bedingung WAHR ist, führt das Programm den Codeblock aus.

Die Ausführung wird erneut mit der Bedingungsanweisung fortgesetzt, und der gleiche Vorgang wird jedes Mal fortgesetzt, wenn die Bedingung WAHR ist. Es bricht nur dann aus der Schleife aus oder stoppt die Ausführung des Codeblocks, wenn die Bedingung FALSE ist. In diesem Fall setzt das Programm die Ausführung nacheinander fort.

Python hat zwei Arten von Schleifen.

#	Schleifentyp	Beschreibung
1	für Schleife	Ist eine iteratorbasierte Schleife, die die Elemente iterierbarer Objekte wie Listen, Tupel, Zeichenfolgen durchläuft und einen Code mehrmals wiederholt ausführt, basierend auf der Anzahl der Elemente in diesem iterierbaren Objekt.
zwei	while-Schleife	Führt einen Anweisungsblock wiederholt aus, solange die Bedingung TRUE ist.

Diese beiden Arten von Schleifen können zum Generieren ineinander verwendet werden verschachtelte Schleifen (dazu später mehr).

Allgemeine Verwendung von Python-Schleifen

In Python können Schleifen verwendet werden, um großartige und komplexe Probleme zu lösen. Wahrscheinlich treten Probleme auf, bei denen Sie eine Aktion wiederholen müssen, bis eine Bedingung erfüllt ist (während die Schleife hier am besten funktioniert), oder ein Problem, bei dem Sie eine Aktion für eine Reihe von Elementen ausführen müssen (for-Schleife funktioniert hier am besten).

Für Loop In Python

Das für Schleife funktioniert gut mit iterierbaren Objekten wie Listen , Tupel , Saiten usw. Auf diese Weise können wir die Elemente dieses Objekts durchgehen und ihre Werte basierend auf unserer Verknüpfung bearbeiten.

Das für Schleife ist nullindiziert und hat die folgende Syntax.

for in n:

Der Zustand in der für Schleife bleibt nur dann WAHR, wenn nicht alle Elemente im iterierbaren Objekt (n) durchlaufen wurden. Um das besser zu verstehen für Schleife Wir werden einige Beispiele ansprechen und schließlich an einem praktischen Beispiel arbeiten.

Beispiel 1:Drucknummern von Anfang bis Ende

Um dies zu erreichen, werden wir den Python verwenden Reichweite Funktion.

So sieht das Flussdiagramm aus:

Flussdiagramm der for-Schleife

def range_from_start_to_end(start, end): for i in range(start, end+1): print(i) if __name__ == '__main__': start = int(input('Enter a start number: ')) end = int(input('Enter an end number: ')) # Call our function to print the ranges range_from_1_to_20(start, end)

Ausgabe

for_loop

Im obigen Beispiel haben wir den Python-Bereich verwendet, eine Funktion, die eine Folge von Zahlen beginnend mit a zurückgibt Start Zahl (standardmäßig 0), inkrementiert um a Schritt (Standardmäßig 1) und stoppt vor einem Ende Nummer.

Für dieses Beispielhaben wir folgendes:

Parameter und Werte für die Python-Bereichsfunktion

Parameter	Wert
Start	1
Ende	zwanzig
Schritt	1 (Standardwert)

So unser für Schleife durchläuft eine Folge von Zahlen von 1 bis 20 und druckt für jede Iteration die Zahl. Die Iteration wird beendet, wenn alle Nummern in der Sequenz besucht wurden.

Beispiel 2:Bestimmen Sie, ob eine Zahl eine Primzahl ist.

In diesem Beispiel werden wir sehen, warum die für Schleife ist so mächtig und nützlich. Hier werden wir eine Folge von Zahlen durchlaufen und für jede Zahl eine Berechnung durchführen, um festzustellen, ob eine Bedingung WAHR oder FALSCH ist.

Es kann hilfreich sein, die Bedingungen zu kennen, unter denen eine Zahl eine Primzahl sein kann.

Die Zahl ist immer positiv, größer als 1.
Hat keine anderen positiven Teiler als 1 und sich selbst.

def isPrime(number): # rule 1: number should be positive, and greater than 1. if number > 1: # iterate over a range from 2 to half the number. for i in range(2, number//2): # rule 2: shouldn't have any positive divisor # order than 1 and itself. if(number % i) ==0: return False return True else: return False if __name__ == '__main__': number = int(input('Enter number to check if it's prime: ')) if isPrime(number): print('{} is a prime number'.format(number)) else: print('{} is not a prime number'.format(number))

Ausgabe bei Eingabe 13

Überprüfen Sie, ob es sich um eine Primzahl handelt

Ausgabe bei Eingabe 10

Überprüfen Sie, ob es sich nicht um eine Primzahl handelt

Hinweis: Das ansonsten Im obigen Beispiel wird eine bedingte Anweisung und keine Schleife verwendet. Aber genau wie die while-Schleife (was wir bald behandeln werden), verwendet es die Vergleichsoperatoren für seinen Zustand.

Beispiel - Finden der Wortanzahl in einem Text mithilfe der for-Schleife

In diesem Beispiel geht es darum zu zählen, wie oft jedes Wort in einem Text vorkommt. Es gibt so viele Möglichkeiten, wie dies erreicht werden kann, aber für dieses Beispiel werden wir die verwenden für Schleife .

Wir werden die Wörter aus dem folgenden Text zählen.

Hallo, willkommen in der Software Testing Help. In diesem Artikel: 'Schleifen in Python' erfahren Sie mehr über Schleifen mit praktischen Beispielen. Großartig, oder? Folgen Sie uns, wenn wir gemeinsam lernen.

Viel Spaß beim Codieren!

Das erste, was wir tun werden, ist, Interpunktionen, Leerzeichen und alle Kleinbuchstaben zu entfernen. Wir werden Interpunktion auf herkömmliche Weise entfernen, indem wir identifizieren, welche Interpunktionen in unserem Text vorhanden sind, und dann die verwenden für Schleife um sie durch eine leere Zeichenfolge zu ersetzen.

Da der Text nicht viel ist, sehen wir, dass die Interpunktionen sind Kommas (,), Zeitraum (.), Fragezeichen (?), Doppelpunkt (:), doppeltes Anführungszeichen (') und Apostroph (‘).

Unten ist der Code angegeben, um sie durch eine leere Zeichenfolge zu ersetzen. Beachten Sie, dass wir Apostroph nicht ersetzen.

# replace punctuation(except apostrophe) and white spaces for punc in '.,
?!'': text = text.replace(punc, '') # lowercase all letters. text = text.lower()

Ausgabe

Zähle das Wort

Als nächstes teilen wir den Text in eine Liste von Wörtern auf, die durch Leerzeichen getrennt sind.

# Split text into list of words separated by whitespaces(tab, newline) text = text.split()

Ausgabe

Teilen Sie den Text

Schließlich werden wir zählen und sehen, wie oft jedes Wort im geteilten Text vorkommt.

# initialize a dictionary to hold words:count wordsCount = {} # if a word is already a key in our dictionary, increment it's value. # If not, initialize it's value to 1. for word in text: wordsCount(word) = wordsCount.get(word, 0) + 1

Ausgabe

praktische_WordCount_count

Wir können deutlich sehen, dass einige Wörter zweimal und einige nur einmal vorkommen. Sortieren wir dieses Wörterbuch nach seinem Wert in absteigender Reihenfolge, damit wir klar unterscheiden können. Hier haben wir den Python verwendet sortierte Funktion , Lambda-Ausdruck , und Wörterbuchverständnis .

bester wow server für neue spieler 2017

# Sort dictionary by value, in descending order wordsCount = {w: c for w, c in sorted(wordsCount.items(), key=lambda item: item(1), reverse=True)}

Schließlich haben wir die verwendet für Schleife um die Wörter in unserem Text zu bereinigen, zu zählen und zu sortieren.

Unten ist der vollständige Code angegeben.

def word_count(text): # initialize a dictionary to hold words:count wordsCount = {} # replace punctuation(except apostrophe) and white spaces for punc in '.,
?!'': text = text.replace(punc, '') # lowercase all letters. text = text.lower() # Split text into list of words separated by whitespaces(tab, newline) and apostrophe(') text = text.split() # if a word is already a key in our dictionary, increment it's value. # If not, initialize it's value to 1. for word in text: wordsCount(word) = wordsCount.get(word, 0) + 1 # Sort dictionary by value, in descending order wordsCount = {w: c for w, c in sorted(wordsCount.items(), key=lambda item: item(1), reverse=True)} print(wordsCount) if __name__ == '__main__': text = 'Hello, welcome to Software Testing Help. In this article: 'Loops in Python',  you'll learn about loops with practical examples.  Great right? Make sure to follow along as we learn together. 
  Happy coding!' word_count(text)

Endgültige Ausgabe

Praktische Wortzahl - Endausgabe

Die While-Schleife

Der Python while-Schleife führt einen Anweisungsblock wiederholt aus, solange die Bedingung TRUE ist. Wir bemerken, dass es ein bisschen ähnlich ist wie das if-Anweisung . Im Gegensatz zu den while-Schleife Die if-Anweisung wird nur einmal ausgeführt, wenn ihre Bedingung TRUE ist.

Die while-Schleife hat die folgende Syntax:

While condition: expression(block of code)

nicht so wie für Schleife , das while-Schleife iteriert nicht über eine Sequenz. Es verwendet die Vergleichsoperatoren und Booleschen Werte für seine Bedingung.

Schauen wir uns einige Beispiele an, um besser zu verstehen, wie es verwendet wird.

Beispiel 1:Drucken Sie 'Hallo Welt!' eine Anzahl von Malen

Das while-Schleife prüft den Zustand (countHallo Welt! ”Und erhöht die Anzahl.

So sieht das Flussdiagramm aus:

Flussdiagramm der while-Schleife

def print_count_times(n): # set count to 0 count = 0 while count  Ausgabe: 
  
  Beispiel 2:Finden Sie die Fakultät einer Zahl 
 Die Fakultät einer Zahl wird dargestellt als n! und es hat die Formel
1*2*...*(n-1)Das Programm prüft, ob die Zahl 0 ist und gibt 1 zurück (Fakultät 0 ist 1). Dann ist die while-Schleife Überprüft die Bedingung (n> = 1), um festzustellen, ob unser n gleich 1 oder größer als 1 ist. Jedes Mal, wenn diese Bedingung WAHR ist, berechnet unser Programm die Formel im Schleifenblock
  Verwenden wir die while-Schleife, um das Fakultätsproblem zu lösen 
def factorial(n): if n == 0: # The factorial of 0 is 1. return 1 else: fac = 1 while n >= 1: # while this condition is TRUE # 1*2*3*...*(n-1) fac *= n # same as 'fac = fac * n' n -= 1 # same as 'n = n - 1' return fac if __name__ =='__main__': n = int(input('Find factorial of: ')) fac = factorial(n) print('Factorial of {} is {} '.format(n,fac))  Ausgabe 
  
 Beispiel - Finden Sie eine Fibonacci-Sequenz bis zum n-ten Term mithilfe der While-Schleife
 Eine Fibonacci-Sequenz hat die Formel.
0,1,1,...((n-1)th + (n-2)th)Die ersten beiden Zahlen sind 0 und 1, dann sind die nächsten Zahlen die Summe der beiden vorherigen Zahlen (n-1) und (n-2).
 Die Fibonacci-Folge von 8 ist 0,1,1,2,3,5,8,13
def fibonacci(n_term): n1 = 0 # (n-1)th if n_term == 1: # if n_term term is 1, print 0 print(n1) else: count = 0 n2 = 1 # (n-2)th # Loop while 'count Ausgabe 
  
 Unser Programm definiert zuerst den ersten n-ten Wert (n1 = 0) und prüft dann, ob das als Argument übergebene n_term gleich 1 ist. Wenn TRUE, gibt es 0 zurück.
  Andernfalls werden zwei Variablen definiert: 
  count = 0: Dies wird in der verwendet while-Schleife um die Bedingung zu überprüfen, wenn die Anzahl kleiner als n_term ist (Anzahl 
n2 = 1: Dies ist unser zweiter n-ter Wert.
 
  Bisher haben wir 0,1 in unserer Sequenz (n1, n2). Während die Bedingung WAHR ist: 
  Der Wert von n2 wird einer temporären Variablen zugewiesen (temp = n2).
 Die Summe der beiden vorherigen Zahlen wird berechnet und n2 zugewiesen (n2 = n1 + n2).
 Unser temporärer Wert (n2 alter Wert) wird n1 zugewiesen (n1 = temp).
 Unsere Anzahl wird erhöht (Anzahl + = 1) und die Bedingung wird erneut überprüft.
 
 Am Ende der ersten Iteration haben wir 0,1,1, wobei:
  n1 = 1 (die erste 1)
 n2 = 1 (die zweite 1)
 
 Dieser Vorgang wird wiederholt, bis die Bedingung zählt 
Verschachtelte Schleife
 Das Coole an Python-Schleifen ist, dass sie verschachtelt werden können, d. H. Wir können eine oder mehrere Schleifen in einer anderen Schleife verwenden. Dies ermöglicht es uns, noch komplexere Probleme zu lösen.
 # 1) Verschachtelung für Schleifen
 for-Schleifen können in sich selbst verschachtelt werden. Die folgende Syntax zeigt eine 1-stufige verschachtelte for-Schleife.
for in n: # piece of code goes here for in n: # piece of code goes here  Beispiel 1:Verwenden Sie die verschachtelte for-Schleife, um Zahlen in Mustern zu drucken 
  Verwenden Sie die verschachtelte for-Schleife, um das folgende Muster zu drucken: 
Unix findet Unterschied zwischen zwei Dateien
 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5 Jede Nummer wird mehrmals entsprechend ihrer Nummer selbst gedruckt.
  So sieht das Flussdiagramm aus: 
  Flussdiagramm einer verschachtelten for-Schleife
def print_numbers(): for i in range(1, 6): # outer loop for j in range(i): # 1st level inner loop print(i, end=' ') print('
') if __name__ == '__main__': print_numbers()  Ausgabe 
  
  Unser Programm funktioniert wie folgt: 
  Die äußere Schleife durchläuft den Bereich von 1 bis 6 und für jedes Element in dieser Sequenz.
 Es tritt in die innere Schleife ein, wo es über einen Bereich dieses Elements iteriert.
 Bei jeder Iteration dieses Elements wird das Element gedruckt.
 Es verlässt die innere Schleife nur, wenn es einen Bereich dieses Elements vollständig durchlaufen hat.
 Wenn es die innere Schleife verlässt, kehrt es zur äußeren Schleife zurück und der Prozess wird fortgesetzt, bis es seine Sequenz vollständig durchlaufen hat.
 
  Beispiel 2:Bearbeiten Sie Elemente einer verschachtelten Liste mithilfe einer verschachtelten for-Schleife 
 Eine Situation, auf die wir in Python wahrscheinlich stoßen werden, ist der Zugriff auf die Elemente einer verschachtelten Liste.
  Nehmen Sie zum Beispiel die verschachtelte Liste unten. 
>>> ((3,4.0,2,8.4,6),(0,2,0.2,4,6),(9,3.5,0.32,5,4)) In diesem Beispiel Schreiben wir ein Programm, das die Anzahl der Ganzzahlen und Gleitkommazahlen in dieser verschachtelten Liste zählt.
def float_and_int_count(nested_list): float_count = 0 # set our float count to zero int_count = 0 # set our integer count to zero for l in nested_list: # outer loop accesses each list in the nested list for item in l: # inter loop accesses each item in the list if isinstance(item, int): # if item is an instance of int int_count += 1 # increment integer count elif isinstance(item, float): # if item is an instance of float float_count += 1 # increment float count # return a tuple return float_count, int_count if __name__ == '__main__': nested_list = ((3,4.0,2,8.4,6),(0,2,0.2,4,6),(9,3.5,0.32,5,4)) float_n, int_n = float_and_int_count(nested_list) print('Float count: {} 
Integer count: {}'.format(float_n, int_n))  Ausgabe 
  
  Unser Programm funktioniert folgendermaßen: 
  Die äußere Schleife greift auf die ersten inneren Listen (3,4.0,2,8.4,6) in unserer verschachtelten Liste zu.
 Die innere Schleife greift auf jedes Element in dieser ersten inneren Liste zu. Für jedes Element wird geprüft, ob es sich um ein Float oder eine Ganzzahl handelt. Wenn es sich um eine Ganzzahl handelt, wird die Anzahl der Ganzzahlen (int_count) erhöht. Andernfalls erhöht es die Float-Anzahl (float_count), wenn es sich um ein Float handelt.
 Sobald die erste innere Liste durchlaufen ist, kehrt sie zur äußeren Schleife zurück und greift auf die zweite Liste (0,2,0,2,4,6) zu. Der gleiche Vorgang wird fortgesetzt, bis auf alle inneren Listen zugegriffen wurde.
 
 # 2) Verschachteln während Schleifen
 While-Schleifen können in sich selbst verschachtelt werden.
  Die folgende Syntax zeigt eine verschachtelte while-Schleife mit einer Ebene. 
while condition: # piece of code goes here while condition: # piece of code goes here  Beispiel 3:Verwenden Sie eine verschachtelte while-Schleife, um Sterne (*) in Mustern zu drucken 
  Verwenden wir eine verschachtelte while-Schleife, um das folgende Muster zu erstellen: 
* * * * * * * * * * * * * * * def print_pattern(n): i = 0 # initialize to zero for outer loop j = 0 # initialize to zero for inner loop while i <= n: # outer loop runs n times while j < i: # inner loop runs i times print('*', end=' ') j += 1 # increment before checking inner loop condition j = 0 # re-initialize after leaving inner loop i += 1 # increment before checking outer loop condition print('') if __name__ == '__main__': n = 5 print_pattern(5)  Ausgabe 
  
  Unser Programm funktioniert wie folgt: 
  Variablen werden initialisiert (i = 0, j = 0, n = 5)
 Unsere äußere Schleife überprüft die Bedingung (0<= 5) which is obviously TRUE.
 Unsere innere Schleife überprüft den Zustand (0<0) which is obviously FALSE, so our program breaks out of the inner loop.
 i wird inkrementiert und die äußere Schleife überprüft erneut ihren Zustand (1<= 5) which is TRUE.
 Unsere innere Schleife überprüft den Zustand (0<1) which is TRUE. So a star( * * ) wird gedruckt und j wird inkrementiert und der Zustand der inneren Schleife wird mit (1) überprüft<1) which is FALSE, thus breaks out of the inner loop.
 
 Der obige Prozess wird fortgesetzt, bis die Bedingung der äußeren Schleife FALSE wird.
 Beispiel - Zahlen-Rechtschreibspiel
 Abgerundet mit a verschachtelte Schleife Wir werden ein aufregendes Spiel entwickeln, um die Fähigkeit des Kindes zu bewerten, Zahlen zu erkennen und zu buchstabieren.
 Das Programm zeigt Zufallszahlen auf dem Bildschirm an und fordert zur Schreibweise dieser Zahl auf. Es prüft, ob die Eingabe korrekt ist, und zeigt dann eine andere Nummer an. Wenn die Eingabe falsch ist, wird eine Fehlermeldung gesendet und eine andere Antwort angefordert.
import random # random contain 'shuffle' used to shuffle our list def word_spelling(): print('HELLO, WELCOME TO THE WORD SPELLING GAME.
') print('SPELL AS MUCH NUMBERS AS YOU CAN TO GET MARKS
') print('-----------------------------------------------
') correct_score = 0 # keep record of correct spellings wrong_score = 0 # keep record of wrong spellings exceeding number of trials max_trials = 3 # maximum number of trials # A dictionary of numbers as keys and spellings as values. This can be expanded to increase its level of difficulty. number_spell = {0:'zero',1:'one',2:'two',3:'three',4:'four',5:'five',6:'six', 7:'seven',8:'eight',9:'nine',10:'ten'} # get the list of keys from the dict and shuffle them so that random numbers are displayed on the screen. number_spell_keys = list(number_spell.keys()) random.shuffle(number_spell_keys) # Our game starts here for number in number_spell_keys: # outer loop is a for loop which iterate through the keys trial_count = 0 # keeps track of number of trials while trial_count  Ausgabe 
  
  Die Hauptfunktionen unserer for-Schleife und while-Schleife sind: 
  Das für Schleife Durchläuft eine Liste von Zahlen, die dem Benutzer zur Rechtschreibung angezeigt werden.
 Das while-Schleife prüft, ob die Anzahl der Versuche überschritten wurde. Auf diese Weise erhält ein Benutzer eine maximale Anzahl von Versuchen, um es richtig zu machen.
 
 Wir haben zwei neue Konzepte gesehen während-sonst , brechen (dazu später mehr). Das while-Schleife und für Schleife ursprünglich haben eine sonst Aussage Dies wird nur einmal ausgeführt, wenn die Bedingung FALSE ist.
 Python-Endlosschleifen
 Wenn wir nicht vorsichtig sind, wie wir unsere Schleifen implementieren, kann dies zu einem führen Endlosschleife d.h. das Programm führt einen Codeblock für immer aus, bis unserem Computer die Ressourcen wie der CPU-Speicher ausgehen.
  Beispiel 1:Endlos while-Schleife 
def infinit_loop_1(): numb = 0 while numb <5: print(numb) if __name__ == '__main__': infinit_loop_1()  Ausgabe 
  
  Hinweis : Um die Ausführung dieses Programms zu stoppen, verwenden Sie Strg + z oder Strg + c Auf dem Terminal, auf dem Sie den Code ausgeführt haben.
 Unser obiger Code implementiert eine Endlosschleife . Dies ist jedoch aus Versehen, weil unsere while-Schleife prüft die Bedingung numb<5, but there is nowhere in the code that actually increments the numb’s value. Hence the value of numb is always zero and the condition keeps returning TRUE.
 Die Möglichkeit, dies zu beheben, besteht darin, den Wert von numb zu erhöhen.
def infinit_loop_1(): numb = 0 while numb <5: print(numb) numb += 1 # fix by incrementing numb's value if __name__ == '__main__': infinit_loop_1()  Ausgabe 
  
 Eine Frage kann sich so wie sie ist stellen Endlosschleifen wirklich notwendig? Spoiler Alarm: Ja, das sind sie. Ein Server kann so programmiert sein, dass er kontinuierlich läuft und gleichzeitig die Anforderungen von Clients erfüllt. Beim Spielen kann ein Ereignis ausgeführt werden, bis der Benutzer eine Aktion zum Beenden oder Unterbrechen der Schleife auswählt.
 Ob Sie es glauben oder nicht, wir haben tatsächlich eine verwendet Endlosschleife im letzten praktischen Beispiel oben. Also, wie gehen wir damit um? Endlosschleifen ?
 Python Break And Continue-Anweisungen
 Wie wir oben erklärt haben, gibt es Fälle, in denen wir absichtlich schreiben müssen Endlosschleifen . In diesen Fällen werden wir sehen, dass die brechen und fortsetzen Schlüsselwörter sind das Rückgrat von Endlosschleifen .
 Das brechen und fortsetzen Schlüsselwörter werden häufig in Python verwendet if-Anweisung Wenn die if-Anweisung eine Bedingung überprüft und wenn sie TRUE ist, brechen wir entweder aus der Schleife aus, in der unsere if-Anweisung aufgerufen wurde, oder fahren fort, indem wir den gesamten darunter liegenden Code überspringen und zum Anfang der Schleife zurückkehren.
kostenlose Alternative zu Quickbooks für kleine Unternehmen
 Beispiel - Zahlen akkumulieren, bis ein Schwellenwert erreicht ist
 Betrachten wir ein Programm, das Zahlen aus einer zufällig generierten Quelle erhält und die Zahlen akkumuliert, bis ein Schwellenwert erreicht ist.
 Der Grund, warum dieses Beispiel eine Endlosschleife erfordert, ist, dass wir nicht genau wissen, wie viele Iterationen unser Programm ausführen muss, damit die akkumulierten Zahlen den Schwellenwert erreichen.
 Unser einziger Retter ist die Python if-Anweisung zusammen mit dem break-Anweisung . Unsere if-Anweisung prüft, ob der Schwellenwert erreicht ist, und bricht dann aus der Schleife aus, wenn TRUE.
 Unser Programm erfordert auch, dass einige eingeschränkte Nummern nicht akkumuliert werden. Wenn unser Programm auf diese Zahlen stößt, sollte es alle Codes überspringen und zum Anfang der Schleife zurückkehren. Dies ist mit dem erreichbar Aussage fortsetzen .
import random def acc_numbers(): acc_numb = 0 # initialize our accumulator threshold = 45 # define our threshold value Rejected_numbers = (4,0,1) # define our rejected numbers while True: # This is an uncontrolled condition. # our infinite while loop # return random integer number within 0 and 10. numb = random.randint(0, 10) # check if the number is in the list of rejected numbers if numb in Rejected_numbers: print('Not accepting ', numb) continue # skip all code blow it and return to the beginning of the while loop # add random number to our store acc_numb += numb # check if the accumulated number has reached threshold if acc_numb >= threshold: print('Threshold attended') break # break out of the loop. if __name__ == '__main__': acc_numbers()  Ausgabe 
  
 Häufig gestellte Fragen
  F # 1) Wie steuern Sie eine Schleife in Python? 
   Antworten:   In Python können Sie eine Schleife mit den folgenden Steueranweisungen steuern:
  Das brechen Schlüsselwort bricht aus einer Schleife aus.
 Das fortsetzen Das Schlüsselwort überspringt alle Codes darunter und kehrt zum Anfang der Schleife zurück.
 
 Diese Schlüsselwörter werden meistens in einem verwendet if-Anweisung Das prüft zuerst, ob eine Bedingung WAHR oder FALSCH ist.
  F # 2) Was ist der Unterschied zwischen for-Schleife und while-Schleife? 
  Antworten: ZU für Schleife ist ein iteratorbasierte Schleife , die durch die Elemente iterierbarer Objekte wie geht Listen , Tupel usw. Während a while-Schleife ist ein bedingungsbasierte Schleife , der einen Anweisungsblock wiederholt ausführt, solange seine Bedingung TRUE ist.
  F # 3) Unterstützt Python die till-Schleife? 
  Antworten: Leider unterstützt Python das nicht do-while-Schleife .
  F # 4) Was sind die beiden Arten von Schleifen in Python? 
  Antworten: Python unterstützt im Allgemeinen zwei Arten von Schleifen: für Schleife und while-Schleife . Eine dritte Schleife ( verschachtelte Schleife ) kann durch Verschachteln von zwei oder mehr dieser Schleifen generiert werden.
 Weitere Informationen zu Python-Schleifen
 Schleifenanweisungen in Python werden verwendet, um einen Anweisungsblock oder Code mehrmals wiederholt auszuführen, wie vom Benutzer angegeben.
  Python bietet uns zwei Arten von Schleifen, wie unten angegeben: 
  While-Schleife
 Für Schleife
 
 # 1) While-Schleife:
 Die while-Schleife in Python wird verwendet, um mehrere Anweisungen oder Codes wiederholt auszuführen, bis die angegebene Bedingung erfüllt ist.
 Wir verwenden eine while-Schleife, wenn wir nicht wissen, wie oft iteriert werden soll.
  Syntax: 
 while (expression): block of statements Increment or decrement operator In der while-Schleife überprüfen wir den Ausdruck. Wenn der Ausdruck wahr wird, wird nur der in der while-Schleife vorhandene Anweisungsblock ausgeführt. Bei jeder Iteration wird die Bedingung überprüft und der Anweisungsblock ausgeführt, bis die Bedingung falsch wird.
  Beispiel: 
 number = 5 sum = 0 i = 0 while (i Ausgabe: 
 10
  
  Ausgabe: 
  
 # 2) Für Schleife:
 Die for-Schleife in Python wird verwendet, um einen Block von Anweisungen oder Code mehrmals auszuführen, bis die angegebene Bedingung falsch wird.
 Wir verwenden die for-Schleife, wenn wir wissen, wie oft iteriert werden soll.
  Syntax: 
 for var in sequence: Block of code Hier nimmt var den Wert aus der Sequenz und führt ihn aus, bis alle Werte in der Sequenz fertig sind.
  Beispiel: 
 language = (‘Python’, ‘Java’, ‘Ruby’) for lang in language: print(“Current language is: “, lang)  Ausgabe: 
 Aktuelle Sprache ist: Python
 Aktuelle Sprache ist: Java
 Aktuelle Sprache ist: Ruby
  
  Ausgabe: 
  
  Für Schleife mit der Funktion range (): 
 Mit der Funktion Range () wird eine Folge von Zahlen generiert.
  Zum Beispiel, Bereich (5) erzeugt Zahlen von 0 bis 4 (5 Zahlen).
  Beispiel: 
 language = (‘Python’, ‘Java’, ‘Ruby’) for lang in range(len(language)): print(“Current language is: “, language(lang))  Ausgabe: 
 Aktuelle Sprache ist: Python
 Aktuelle Sprache ist: Java
 Aktuelle Sprache ist: Ruby
  
  Ausgabe: 
  
 Fazit
 In diesem Tutorial haben wir die Definition von Schleifen, die Arten von Python-Schleifen und die Verwendung von gesehen for loop, und while-Schleife mit einigen Beispielen.
 Wir haben auch gelernt wie verschachtelte Schleifen generiert werden und endliche Schleifen auch und wir lernten, wie man das benutzt brechen und fortsetzen Schlüsselwörter.
  => Überprüfen Sie ALLE Python-Tutorials hier  
   PREV Tutorial | NÄCHSTES Tutorial  
  Literatur-Empfehlungen
    Python-Steueranweisungen (Python Continue, Break and Pass)  
  Python-Variablen  
  Python-Tutorial für Anfänger (KOSTENLOSES Python-Training zum Anfassen)  
  Bedingte Python-Anweisungen: if_else, elif, verschachtelte if-Anweisungen  
  Python-Operatoren  
  Python-String-Funktionen  
  Python DateTime Tutorial mit Beispielen  
  Python-Funktionen