Python Language
Schleifen

Einführung

Syntax

• Während <boolescher Ausdruck>:
• für <variable> in <iterable>:
• für <Variable> im Bereich (<Nummer>):
• für <variable> im Bereich (<start_number>, <end_number>):
• für <Variable> im Bereich (<Startnummer>, <Endnummer>, <Schrittgröße>):
• für i, <variable> in Aufzählung (<iterable>): # mit Index i
• für <variable1>, <variable2> in zip (<iterable1>, <iterable2>):

Parameter

Iterieren über Listen

Iterieren über eine Liste , die Sie verwenden können , for :

for x in ['one', 'two', 'three', 'four']:
    print(x)

Dadurch werden die Elemente der Liste ausgedruckt:

one
two
three
four

Die range Funktion generiert Zahlen, die auch häufig in einer for-Schleife verwendet werden.

for x in range(1, 6):
    print(x)

Das Ergebnis ist ein spezieller Bereichssequenztyp in Python> = 3 und eine Liste in Python <= 2. Beide können mit der for-Schleife durchgeschleift werden.

1
2
3
4
5

Wenn Sie beide Elemente einer Liste durchlaufen und auch einen Index für die Elemente haben möchten, können Sie die enumerate Python verwenden:

for index, item in enumerate(['one', 'two', 'three', 'four']):
    print(index, '::', item)

enumerate generiert Tupel, die in index (eine ganze Zahl) und item (den tatsächlichen Wert aus der Liste) entpackt werden. Die obige Schleife wird gedruckt

(0, '::', 'one')
(1, '::', 'two')
(2, '::', 'three')
(3, '::', 'four')

Durchlaufen Sie eine Liste mit Wertmanipulation mit map und lambda , dh wenden Sie für jedes Element in der Liste die Lambda-Funktion an:

x = map(lambda e :  e.upper(), ['one', 'two', 'three', 'four'])
print(x)

Ausgabe:

['ONE', 'TWO', 'THREE', 'FOUR'] # Python 2.x

Hinweis: In Python 3.x gibt map einen Iterator anstelle einer Liste zurück. Wenn Sie also eine Liste benötigen, müssen Sie das Ergebnis print(list(x)) (siehe http://www.riptutorial.com/python/ Beispiel / 8186 / map-- in http://www.riptutorial.com/python/topic/809/incompatibilities-moving-from-python-2-to-python-3 ).

Für Schleifen

for Schleifen durchlaufen eine Auflistung von Elementen, z. B. list oder dict , und führen einen Codeblock mit jedem Element aus der Auflistung aus.

for i in [0, 1, 2, 3, 4]:
    print(i)

Die obige for Schleife durchläuft eine Liste mit Zahlen.

Bei jeder Iteration wird der Wert von i auf das nächste Element der Liste gesetzt. Also zuerst 0 , dann 1 , dann 2 usw. Die Ausgabe lautet wie folgt:

0  
1
2
3
4

range ist eine Funktion, die eine Reihe von Zahlen in einer iterierbaren Form zurückgibt. Daher kann sie for Schleifen verwendet werden:

for i in range(5):
    print(i)

gibt das gleiche Ergebnis wie die erste for Schleife. Beachten Sie, dass 5 nicht gedruckt wird, da der Bereich hier die ersten fünf Zahlen sind, die von 0 .

Iterierbare Objekte und Iteratoren

for Schleife kann ein beliebiges iterierbares Objekt __getitem__ dem es sich um ein Objekt handelt, das eine __getitem__ oder eine __iter__ Funktion definiert. Die Funktion __iter__ gibt einen Iterator zurück. __iter__ handelt es sich um ein Objekt mit einer next Funktion, mit der auf das nächste Element des iterierbaren Elements zugegriffen wird.

Brechen Sie in Loops und fahren Sie fort

Anweisung break

Wenn eine break Anweisung innerhalb einer Schleife ausgeführt wird, "bricht" der Steuerungsfluss sofort aus der Schleife heraus:

i = 0
while i < 7:
    print(i)
    if i == 4:
        print("Breaking from loop")
        break
    i += 1

Die Schleifenbedingung wird nach der Ausführung der break Anweisung nicht ausgewertet. Beachten Sie, dass break Anweisungen nur innerhalb von Schleifen syntaktisch zulässig sind . Eine break Anweisung innerhalb einer Funktion kann nicht zum Beenden von Schleifen verwendet werden, die diese Funktion aufgerufen haben.

Beim Ausführen des folgenden Befehls wird jede Ziffer bis Nummer 4 gedruckt, wenn die break Anweisung erfüllt ist und die Schleife stoppt:

0
1
2
3
4
Breaking from loop

break Anweisungen können auch innerhalb for Schleifen verwendet werden, dem anderen von Python bereitgestellten Schleifenkonstrukt:

for i in (0, 1, 2, 3, 4):
    print(i)
    if i == 2:
        break

Das Ausführen dieser Schleife wird jetzt gedruckt:

0
1
2

Beachten Sie, dass 3 und 4 nicht gedruckt werden, da die Schleife beendet ist.

Wenn eine Schleife eine else Klausel hat , wird sie nicht ausgeführt, wenn die Schleife durch eine break Anweisung beendet wird.

continue Aussage

Eine continue Anweisung springt zur nächsten Iteration der Schleife, wobei der Rest des aktuellen Blocks umgangen wird, die Schleife jedoch fortgesetzt wird. Wie bei break kann continue nur innerhalb von Schleifen erscheinen:

for i in (0, 1, 2, 3, 4, 5):
    if i == 2 or i == 4:
        continue
    print(i)

0
1
3
5

Beachten Sie, dass 2 und 4 nicht gedruckt werden. Dies liegt daran, dass continue zur nächsten Iteration geht, anstatt mit print(i) continue , wenn i == 2 oder i == 4 .

Verschachtelte Loops

break und continue nur auf einer Ebene der Schleife arbeiten. Das folgende Beispiel bricht nur aus der inneren for Schleife aus, nicht aus der äußeren while Schleife:

while True:
    for i in range(1,5):
        if i == 2:
            break    # Will only break out of the inner loop!

Python ist nicht in der Lage, mehrere Loop-Ebenen gleichzeitig zu durchbrechen. Wenn dieses Verhalten erwünscht ist, kann das Umgestalten einer oder mehrerer Loops in eine Funktion und das Ersetzen von break durch return möglicherweise der Weg sein.

Verwenden Sie return aus einer Funktion als break

Die return Anweisung verlässt eine Funktion, ohne den Code auszuführen, der danach kommt.

Wenn Sie eine Schleife innerhalb einer Funktion verwenden, ist die Verwendung von return von innerhalb dieser Schleife gleichbedeutend mit einer break da der Rest des Codes der Schleife nicht ausgeführt wird ( beachten Sie, dass nach der Schleife auch kein Code ausgeführt wird ):

def break_loop():
    for i in range(1, 5):
        if (i == 2):
            return(i)
        print(i)
    return(5)

Wenn Sie geschachtelte Schleifen haben, unterbricht die return Anweisung alle Schleifen:

def break_all():
    for j in range(1, 5):
        for i in range(1,4):
            if i*j == 6:
                return(i)
            print(i*j)

wird ausgeben:

1 # 1*1
2 # 1*2
3 # 1*3
4 # 1*4
2 # 2*1
4 # 2*2
# return because 2*3 = 6, the remaining iterations of both loops are not executed

Loops mit einer "else" -Klausel

Die Anweisungen for und while zusammengesetzte Anweisungen (Schleifen) können optional eine else Klausel enthalten (in der Praxis ist diese Verwendung eher selten).

Die else Klausel wird nur ausgeführt, nachdem eine for Schleife durch Iteration bis zum Abschluss beendet wurde, oder nach einer while Schleife, wenn der bedingte Ausdruck falsch wird.

for i in range(3):
    print(i)
else:
    print('done')

i = 0
while i < 3:
    print(i)
    i += 1
else:
    print('done')

Ausgabe:

 0
 1
 2
 done

Die else Klausel wird nicht ausgeführt, wenn die Schleife auf andere Weise beendet wird (durch eine break Anweisung oder durch Auslösen einer Ausnahme):

for i in range(2):
    print(i)
    if i == 1:
        break
else:
    print('done')

Ausgabe:

0
1

Die meisten anderen Programmiersprachen verfügen nicht über diese optionale else Klausel von Schleifen. Die Verwendung des Schlüsselworts else insbesondere wird oft verwirrend betrachtet.

Das ursprüngliche Konzept für eine solche Klausel geht auf Donald Knuth zurück und die Bedeutung des Schlüsselworts else wird deutlich, wenn wir eine Schleife in Form von if Anweisungen und goto Anweisungen aus früheren Tagen vor der strukturierten Programmierung oder aus einer Assemblersprache einer niedrigeren Ebene schreiben.

Zum Beispiel:

while loop_condition():
    ...
    if break_condition():
        break
    ...

ist äquivalent zu:

# pseudocode

<<start>>:
if loop_condition():
    ...
    if break_condition():
        goto <<end>>
    ...
    goto <<start>>

<<end>>:

Diese bleiben gleichwertig, wenn wir jedem eine else Klausel hinzufügen.

Zum Beispiel:

while loop_condition():
    ...
    if break_condition():
        break
    ...
else:
    print('done')

ist äquivalent zu:

# pseudocode

<<start>>:
if loop_condition():
    ...
    if break_condition():
        goto <<end>>
    ...
    goto <<start>>
else:
    print('done')

<<end>>:

Eine for Schleife mit einer else Klausel kann auf dieselbe Weise verstanden werden. Konzeptionell gibt es eine Schleifenbedingung, die wahr bleibt, solange das iterierbare Objekt oder die Sequenz noch einige Elemente enthält.

Warum sollte man dieses seltsame Konstrukt verwenden?

Der Hauptanwendungsfall für das Konstrukt for...else ist eine präzise Implementierung der Suche, wie zum Beispiel:

a = [1, 2, 3, 4]
for i in a:
    if type(i) is not int:
        print(i)
        break
else:
    print("no exception") 

Um den else in diesem Konstrukt weniger verwirrend zu machen, kann man es sich als " wenn nicht brechen " oder " wenn nicht gefunden " vorstellen .

Einige Diskussionen dazu finden Sie in [Python-ideas] Summary von for ... else-Threads . Warum verwendet Python 'else' nach und while-Schleifen? und Else-Klauseln zu Schleifenanweisungen

Wörterbücher iterieren

Betrachten Sie das folgende Wörterbuch:

 d = {"a": 1, "b": 2, "c": 3}

Zum Durchlaufen der Schlüssel können Sie Folgendes verwenden:

for key in d:
    print(key)

Ausgabe:

"a"
"b"
"c"

Das ist äquivalent zu:

for key in d.keys():
    print(key)

oder in Python 2:

for key in d.iterkeys():
    print(key)

Um durch seine Werte zu iterieren, verwenden Sie:

for value in d.values():
    print(value)

Ausgabe:

1
2
3

Um durch seine Schlüssel und Werte zu iterieren, verwenden Sie:

for key, value in d.items():
    print(key, "::", value)

Ausgabe:

a :: 1
b :: 2
c :: 3

Man beachte , dass in 2 Python, .keys() , .values() und .items() eine Rückkehr list Objekt. Wenn Sie lediglich das Ergebnis .iterkeys() , können Sie die entsprechenden .iterkeys() , .itervalues() und .iteritems() .

Der Unterschied zwischen .keys() und .iterkeys() , .values() und .itervalues() , .items() und .iteritems() besteht darin, dass die iter* -Methoden Generatoren sind. Somit werden die Elemente innerhalb des Wörterbuchs bei der Auswertung nacheinander ausgegeben. Wenn eine list Objekt zurückgegeben wird, werden alle Elemente in eine Liste gepackt und kehrte dann zur weiteren Auswertung.

Beachten Sie auch, dass in Python 3 die Reihenfolge der auf diese Weise gedruckten Elemente keiner Reihenfolge entspricht.

While-Schleife

Eine while Schleife bewirkt, dass die Schleifenanweisungen ausgeführt werden, bis die Schleifenbedingung falsch ist . Der folgende Code führt die Schleifenanweisungen insgesamt viermal aus.

i = 0 
while i < 4:
    #loop statements
    i = i + 1

Die obige Schleife kann leicht in eine elegantere for Schleife übersetzt werden, while Schleifen nützlich sind, um zu überprüfen, ob eine Bedingung erfüllt ist. Die folgende Schleife wird solange ausgeführt, bis myObject fertig ist.

myObject = anObject()
while myObject.isNotReady():
    myObject.tryToGetReady()

while Schleifen können auch ohne Bedingung ausgeführt werden, indem Zahlen (komplex oder reell) oder True :

import cmath

complex_num = cmath.sqrt(-1)
while complex_num:      # You can also replace complex_num with any number, True or a value of any type
    print(complex_num)   # Prints 1j forever

Wenn die Bedingung immer wahr ist, wird die while-Schleife für immer ausgeführt (Endlosschleife), wenn sie nicht durch eine break- oder return-Anweisung oder eine Ausnahme beendet wird.

while True:
    print "Infinite loop"
# Infinite loop
# Infinite loop
# Infinite loop
# ...

Die Pass-Erklärung

pass ist eine Nullanweisung, wenn eine Python-Syntax eine Anweisung erfordert (z. B. im Rumpf einer for oder while Schleife), jedoch keine Aktion vom Programmierer erforderlich oder gewünscht ist. Dies kann als Platzhalter für Code dienen, der noch geschrieben werden muss.

for x in range(10):
    pass #we don't want to do anything, or are not ready to do anything here, so we'll pass

In diesem Beispiel wird nichts passieren. Die for Schleife wird ohne Fehler abgeschlossen, es werden jedoch keine Befehle oder Codes ausgeführt. pass können wir unseren Code erfolgreich ausführen, ohne dass alle Befehle und Aktionen vollständig implementiert sind.

In ähnlicher Weise kann pass in while Schleifen sowie in Auswahl- und Funktionsdefinitionen usw. verwendet werden.

while x == y:
    pass

Verschiedene Teile einer Liste mit unterschiedlicher Schrittweite iterieren

Angenommen, Sie haben eine lange Liste von Elementen und interessieren sich nur für jedes andere Element der Liste. Vielleicht möchten Sie nur das erste oder letzte Element oder einen bestimmten Bereich von Einträgen in Ihrer Liste untersuchen. Python verfügt über integrierte Indexierungsfunktionen. Hier einige Beispiele, wie Sie diese Szenarien erreichen können.

Hier ist eine einfache Liste, die in den Beispielen verwendet wird:

lst = ['alpha', 'bravo', 'charlie', 'delta', 'echo']

Iteration über die ganze Liste

Um jedes Element in der Liste zu durchlaufen, kann eine for Schleife wie folgt verwendet werden:

for s in lst:
    print s[:1] # print the first letter

Die for Schleife weist jedem Element von lst s zu. Dies wird drucken:

a
b
c
d
e

Häufig benötigen Sie sowohl das Element als auch den Index dieses Elements. Das enumerate Schlüsselwort führt diese Aufgabe aus.

for idx, s in enumerate(lst):
    print("%s has an index of %d" % (s, idx))

Der Index idx beginnt mit Null und erhöht sich für jede Iteration, während die s das zu bearbeitende Element enthalten. Der vorherige Ausschnitt wird ausgegeben:

alpha has an index of 0
bravo has an index of 1
charlie has an index of 2
delta has an index of 3
echo has an index of 4

Iteriere über Unterliste

Wenn Sie über einen Bereich iterieren möchten (wenn Sie sich daran erinnern, dass Python die nullbasierte Indizierung verwendet), verwenden Sie das Schlüsselwort range .

for i in range(2,4):
    print("lst at %d contains %s" % (i, lst[i]))

Dies würde ausgeben:

lst at 2 contains charlie
lst at 3 contains delta

Die Liste kann auch in Scheiben geschnitten werden. Die folgende Slice-Notation geht vom Element an Index 1 bis zum Ende mit einem Schritt von 2. Die beiden for Schleifen führen zum gleichen Ergebnis.

for s in lst[1::2]:
    print(s)

for i in range(1, len(lst), 2):
    print(lst[i])

Die obigen Snippet-Ausgaben:

bravo
delta

Das Indizieren und Schneiden ist ein eigenes Thema.

Die "halbe Schleife" machen

Im Gegensatz zu anderen Sprachen verfügt Python nicht über ein do-until oder ein do-while-Konstrukt (dadurch kann der Code einmal ausgeführt werden, bevor die Bedingung getestet wird). Sie können jedoch eine while True mit einer break kombinieren, um denselben Zweck zu erreichen.

a = 10
while True:
    a = a-1
    print(a)
    if a<7:
        break
print('Done.')

Dies wird drucken:

9
8
7
6
Done.

Schleifen und Auspacken

Wenn Sie beispielsweise eine Liste von Tupeln durchlaufen möchten:

collection = [('a', 'b', 'c'), ('x', 'y', 'z'), ('1', '2', '3')]

anstatt etwas zu tun:

for item in collection:
    i1 = item[0]
    i2 = item[1]
    i3 = item[2]
    # logic

oder sowas:

for item in collection:
    i1, i2, i3 = item
    # logic

Sie können dies einfach tun:

for i1, i2, i3 in collection:
    # logic

Dies funktioniert auch für die meisten Arten von Iterables, nicht nur für Tupel.