Python Language
Loops

Invoering

Syntaxis

• terwijl <boolean expression>:
• voor <variable> in <iterable>:
• voor <variable> binnen bereik (<nummer>):
• voor <variable> in bereik (<start_number>, <end_number>):
• voor <variable> in bereik (<start_number>, <end_number>, <step_size>):
• voor i, <variable> in enumerate (<iterable>): # met index i
• voor <variable1>, <variable2> in zip (<iterable1>, <iterable2>):

parameters

Door lijsten bladeren

Om een lijst te doorlopen die u kunt gebruiken for :

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

Hiermee worden de elementen van de lijst afgedrukt:

one
two
three
four

De range genereert getallen die ook vaak in een for-lus worden gebruikt.

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

Het resultaat is een speciaal bereikreekstype in python> = 3 en een lijst in python <= 2. Beide kunnen worden doorgelust met behulp van de for-lus.

1
2
3
4
5

Als u wilt herhalen hoewel zowel de elementen van een lijst en hebben een index voor de elementen ook, kunt u Python gebruiken enumerate functie:

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

enumerate genereert tupels, die worden uitgepakt in index (een geheel getal) en item (de werkelijke waarde uit de lijst). De bovenstaande lus wordt afgedrukt

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

Herhaal een lijst met waardemanipulatie met behulp van map en lambda , dwz pas de lambdafunctie toe op elk element in de lijst:

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

Output:

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

NB: in Python 3.x geeft de map een iterator terug in plaats van een lijst, dus als u een lijst nodig hebt, moet u de resultaatafdruk casten print(list(x)) (zie http://www.riptutorial.com/python/ voorbeeld / 8186 / map-- in http://www.riptutorial.com/python/topic/809/incompatibiliteiten-moving-from-python-2-to-python-3 ).

Voor lussen

for lussen itereren over een verzameling items, zoals list of dict , en voeren een codeblok uit met elk element uit de verzameling.

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

Het bovenstaande for lus herhaalt een lijst met getallen.

Elke iteratie stelt de waarde van i op het volgende element van de lijst. Dus eerst is het 0 , dan 1 , dan 2 , enz. De uitvoer is als volgt:

0  
1
2
3
4

range is een functie die een reeks getallen retourneert in een itereerbare vorm, dus deze kan worden gebruikt for lussen:

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

geeft exact hetzelfde resultaat als de eerste for lus. Merk op dat 5 niet wordt afgedrukt omdat het bereik hier de eerste vijf getallen is die vanaf 0 tellen.

Iterabele objecten en iterators

for loop kan elk iterabel object herhalen dat een object is dat een __getitem__ of een __iter__ functie definieert. De functie __iter__ retourneert een iterator, een object met een next functie die wordt gebruikt om toegang te krijgen tot het volgende element van de iterabele.

Breek en ga door in lussen

verklaring break

Wanneer een break instructie in een lus wordt uitgevoerd, "breekt" de besturingsstroom onmiddellijk uit de lus:

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

De voorwaardelijke lus wordt niet geëvalueerd nadat de break is uitgevoerd. Merk op dat break statements alleen binnen lussen zijn toegestaan, syntactisch. Een break instructie in een functie kan niet worden gebruikt om lussen te beëindigen die die functie hebben genoemd.

Als u het volgende uitvoert, wordt elk cijfer afgedrukt tot nummer 4 wanneer aan de break wordt voldaan en de lus stopt:

0
1
2
3
4
Breaking from loop

break kunnen ook binnen worden gebruikt for lussen, het andere lusconstructie van Python:

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

Het uitvoeren van deze lus wordt nu afgedrukt:

0
1
2

Merk op dat 3 en 4 niet worden afgedrukt sinds het einde van de lus.

Als een lus een else clausule heeft , wordt deze niet uitgevoerd wanneer de lus wordt beëindigd via een instructie break .

verklaring continue

Een instructie continue gaat naar de volgende iteratie van de lus waarbij de rest van het huidige blok wordt omzeild maar de lus wordt voortgezet. Net als bij break kan continue alleen in lussen verschijnen:

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

0
1
3
5

Merk op dat 2 en 4 niet worden afgedrukt, dit komt omdat continue naar de volgende iteratie gaat in plaats van door te gaan met print(i) wanneer i == 2 of i == 4 .

Geneste lussen

break en continue slechts één lusniveau. Het volgende voorbeeld wordt alleen breken van het inwendige for lus niet de buitenste while lus:

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

Python heeft niet de mogelijkheid om uit meerdere lusniveaus tegelijk te breken - als dit gedrag gewenst is, kan het opnieuw kiezen van een of meer lussen in een functie en het vervangen van break door return worden gebruikt.

Gebruik return vanuit een functie als break

De return verlaat een functie, zonder de code die erop volgt uit te voeren.

Als je een lus binnen een functie hebt, is het gebruik van return vanuit die lus gelijk aan het hebben van een break omdat de rest van de code van de lus niet wordt uitgevoerd ( merk op dat ook geen code na de lus wordt uitgevoerd ):

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

Als u geneste lussen heeft, worden alle lussen door de return verbroken:

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

zal uitvoeren:

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

Lussen met een "anders" -clausule

De for en while samengestelde statements (loops) kunnen optioneel een else clausule hebben (in de praktijk is dit gebruik vrij zeldzaam).

De else clausule wordt alleen uitgevoerd nadat een for lus wordt beëindigd door iteratie tot voltooiing, of na een while lus wordt beëindigd doordat de voorwaardelijke expressie ervan onwaar wordt.

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

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

output:

 0
 1
 2
 done

De else clausule wordt niet uitgevoerd als de lus op een andere manier eindigt (via een break statement of door een uitzondering op te roepen):

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

output:

0
1

De meeste andere programmeertalen missen deze optionele else clausule van lussen. Vooral het gebruik van het trefwoord else wordt vaak als verwarrend beschouwd.

Het oorspronkelijke concept voor een dergelijke clausule dateert van Donald Knuth en de betekenis van het sleutelwoord else wordt duidelijk als we een lus herschrijven in termen van if instructies en goto instructies uit vroegere dagen vóór gestructureerde programmering of uit een assemblagetaal van een lager niveau.

Bijvoorbeeld:

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

is gelijk aan:

# pseudocode

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

<<end>>:

Deze blijven equivalent als we aan elk van hen een clausule else .

Bijvoorbeeld:

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

is gelijk aan:

# pseudocode

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

<<end>>:

Een for lus met een else clausule kan op dezelfde manier worden opgevat. Conceptueel is er een lusvoorwaarde die True blijft zolang het iterabele object of de reeks nog enkele resterende elementen bevat.

Waarom zou je dit vreemde construct gebruiken?

De belangrijkste use case voor de for...else constructie is een beknopte implementatie van zoeken zoals bijvoorbeeld:

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

Om de else in dit construct minder verwarrend te maken, kan men het beschouwen als " zo niet kapot " of " zo niet gevonden ".

Sommige discussies hierover zijn te vinden in [Python-ideeën] Samenvatting van voor ... anders threads , Waarom gebruikt python 'anders' na voor en tijdens loops? , en andere clausules over lusverklaringen

Door woordenboeken bladeren

Overweegt het volgende woordenboek:

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

Om de toetsen te doorlopen, kunt u het volgende gebruiken:

for key in d:
    print(key)

Output:

"a"
"b"
"c"

Dit komt overeen met:

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

of in Python 2:

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

Gebruik om de waarden te doorlopen:

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

Output:

1
2
3

Gebruik de volgende toetsen om de sleutels en waarden te doorlopen:

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

Output:

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

Merk op dat in Python 2, .keys() , .values() en .items() terug een list object. Als u eenvoudig door het resultaat moet .iterkeys() , kunt u de equivalente .iterkeys() , .itervalues() en .iteritems() .

Het verschil tussen .keys() en .iterkeys() , .values() en .itervalues() , .items() en .iteritems() is dat de iter* -methoden generatoren zijn. Aldus worden de elementen binnen het woordenboek een voor een opgeleverd wanneer ze worden geëvalueerd. Wanneer een list object geretourneerd, alle elementen zijn verpakt in een lijst en dan terug voor verdere evaluatie.

Merk ook op dat in Python 3 de volgorde van items die op de bovenstaande manier zijn afgedrukt, geen volgorde volgt.

Herhalingslus

Een while lus zorgt ervoor dat de lusinstructies worden uitgevoerd totdat de lusvoorwaarde falsey is . De volgende code voert de lusinstructies in totaal 4 keer uit.

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

Hoewel de bovenstaande loop gemakkelijk kan worden omgezet in een elegantere for lus, while lussen zijn nuttig om te controleren of bepaalde voorwaarde is voldaan. De volgende lus wordt uitgevoerd totdat myObject gereed is.

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

while lussen ook zonder voorwaarde kunnen worden uitgevoerd met behulp van getallen (complex of echt) of 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

Als de voorwaarde altijd waar is, loopt de while-lus voor altijd (oneindige lus) als deze niet wordt beëindigd door een instructie break of return of een uitzondering.

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

Het Pass Statement

pass is een null-instructie voor wanneer een instructie vereist is door Python-syntaxis (zoals in de body van een for of while lus), maar er is geen actie vereist of gewenst door de programmeur. Dit kan handig zijn als tijdelijke aanduiding voor code die nog moet worden geschreven.

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 dit voorbeeld gebeurt er niets. De for lus wordt zonder fouten voltooid, maar er worden geen opdrachten of code uitgevoerd. pass stelt ons in staat om onze code succesvol uit te voeren zonder dat alle commando's en acties volledig zijn geïmplementeerd.

Evenzo kan pass worden gebruikt in while lussen, evenals in selecties en functiedefinities, enz.

while x == y:
    pass

Verschillende delen van een lijst met verschillende stapgrootte herhalen

Stel dat u een lange lijst met elementen hebt en alleen geïnteresseerd bent in elk ander element van de lijst. Misschien wilt u alleen de eerste of laatste elementen of een specifiek bereik van vermeldingen in uw lijst bekijken. Python heeft sterke ingebouwde indexeringsmogelijkheden. Hier zijn enkele voorbeelden van hoe u deze scenario's kunt bereiken.

Hier is een eenvoudige lijst die in alle voorbeelden wordt gebruikt:

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

Iteratie over de hele lijst

Om elk element in de lijst te herhalen, kan een for lus zoals hieronder worden gebruikt:

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

De for lus kent s toe voor elk element van lst . Dit zal afdrukken:

a
b
c
d
e

Vaak heb je zowel het element als de index van dat element nodig. Het enumerate voert die taak uit.

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

De index- idx begint met nul en increment voor elke iteratie, terwijl de s het element bevatten dat wordt verwerkt. Het vorige fragment zal uitvoeren:

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

Herhaal de sublijst

Als we over een bereik willen herhalen (bedenk dat Python op nul gebaseerde indexering gebruikt), gebruik dan het range sleutelwoord.

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

Dit zou het volgende opleveren:

lst at 2 contains charlie
lst at 3 contains delta

De lijst kan ook worden gesegmenteerd. De volgende segmentnotatie gaat van element op index 1 naar het einde met een stap van 2. De twee for lussen geven hetzelfde resultaat.

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

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

Bovenstaande fragmentuitgangen:

bravo
delta

Indexeren en segmenteren is een onderwerp op zich.

De "half loop" do-while

In tegenstelling tot andere talen, heeft Python geen do-till of do-while-constructie (hierdoor kan code eenmaal worden uitgevoerd voordat de voorwaarde wordt getest). U kunt echter een while True combineren met een break om hetzelfde doel te bereiken.

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

Dit zal afdrukken:

9
8
7
6
Done.

Lussen en uitpakken

Als je bijvoorbeeld een lijst met tupels wilt doorlopen:

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

in plaats van zoiets te doen:

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

of iets zoals dit:

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

U kunt dit eenvoudig doen:

for i1, i2, i3 in collection:
    # logic

Dit werkt ook voor de meeste typen iterables, niet alleen voor tupels.