Python Language
Loops

Introduktion

Syntax

• medan <booleskt uttryck>:
• för <variabel> i <iterbar>:
• för <variabel> inom räckvidd (<nummer>):
• för <variabelt> inom räckvidden (<start_nummer>, <end_nummer>):
• för <variabelt> inom räckvidd (<start_nummer>, <end_nummer>, <steg_storlek>):
• för i, <variabel> i räknat (<läsbar>): # med index i
• för <variable1>, <variable2> i zip (<iterable1>, <iterable2>):

parametrar

Iterating över listor

För att upprepa en lista som du kan använda for :

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

Detta kommer att skriva ut elementen i listan:

one
two
three
four

range genererar siffror som också ofta används i en för-loop.

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

Resultatet blir en speciell intervallsekvenstyp i python> = 3 och en lista i python <= 2. Båda kan slingas genom att använda for-slingan.

1
2
3
4
5

Om du vill slinga på både elementen i en lista och även ha ett index för elementen kan du använda Pythons enumerate :

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

enumerate kommer att generera tuples, som packas upp i index (ett heltal) och item (det verkliga värdet från listan). Ovanstående slinga kommer att skrivas ut

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

Iterera över en lista med värdemanipulation med map och lambda , dvs tillämpa lambda-funktion på varje element i listan:

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

Produktion:

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

OBS: i Python 3.x- map returneras en iterator istället för en lista, så om du behöver en lista måste du kasta resultatutskriften print(list(x)) (se http://www.riptutorial.com/python/ exempel / 8186 / karta-- på http://www.riptutorial.com/python/topic/809/incompatibility-moving-from-python-2-to-python-3 ).

För öglor

for slingor iterera över en samling av objekt, till exempel list eller dict , och kör ett blockblock med varje element från samlingen.

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

Ovanstående for loop-iterater över en lista med siffror.

Varje iteration ställer in värdet på i till nästa element i listan. Så först kommer det att vara 0 , sedan 1 , sedan 2 , etc. Utmatningen kommer att vara som följer:

0  
1
2
3
4

range är en funktion som returnerar en serie siffror under en iterable form, så att den kan användas i for slingor:

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

ger exakt samma resultat som det första for slingan. Observera att 5 inte skrivs ut eftersom intervallet här är de första fem siffrorna som räknas från 0 .

Itererbara föremål och iteratorer

for loop kan iterera på alla iterbara objekt som är ett objekt som definierar en __getitem__ eller en __iter__ funktion. Funktionen __iter__ returnerar en iterator, som är ett objekt med en next funktion som används för att komma åt nästa element i iterable.

Bryt och fortsätt i öglor

break uttalande

När ett break uttalande körs inuti en slinga, bryter kontrollflödet omedelbart ur slingan:

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

Villkorad slinga kommer inte att utvärderas efter att break har utförts. Observera att break uttalanden endast tillåtet i loopar, syntaktiskt. Ett break uttalande i en funktion kan inte användas för att avsluta slingor som kallas den funktionen.

Utförande av följande skriver ut varje siffra tills nummer 4 när break är uppfylld och slingan stannar:

0
1
2
3
4
Breaking from loop

break kan också användas inuti for öglor, den andra slingkonstruktionen tillhandahålls av Python:

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

Att köra denna slinga skriver nu ut:

0
1
2

Observera att 3 och 4 inte skrivs ut eftersom slingan är slut.

Om en slinga har en else klausul , körs den inte när slingan avslutas genom ett break uttalande.

continue uttalandet

Ett continue kommer att hoppa till nästa iteration av slingan genom att kringgå resten av det aktuella blocket men fortsätta slingan. Som med break kan continue endast visas i slingor:

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

0
1
3
5

Observera att 2 och 4 inte skrivs ut, det beror på att continue går till nästa iteration istället för att fortsätta att print(i) när i == 2 eller i == 4 .

Kapslade slingor

break och continue bara arbeta på en enda nivå av slingan. Följande exempel kommer bara att bryta ut ur det inre for slingan, inte från den yttre while slingan:

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

Python har inte förmågan att bryta ut från flera nivåer av slinga på en gång - om detta beteende är önskvärt, kan återföra en eller flera slingor till en funktion och ersätta break med return kan vara vägen att gå.

Använd return från en funktion som en break

Den return uttalande utträder ur funktion, utan att exekvera kod som kommer efter det.

Om du har en slinga inuti en funktion, motsvarar return från insidan den slingan att ha en break eftersom resten av loopens kod inte körs ( observera att någon kod efter slingan inte heller körs ):

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

Om du har kapslade slingor, den return kommer uttalande bryta alla slingor:

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

kommer att mata ut:

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 med en "annan" -klausul

for och while sammansatta uttalanden (slingor) kan valfritt ha en else klausul (i praktiken är denna användning ganska sällsynt).

Den else klausulen körs endast efter att en for loop avslutas genom att iterera till fullbordande, eller efter ett while avslutas slingan genom att det villkorliga uttrycket blir falskt.

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

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

produktion:

 0
 1
 2
 done

Den else klausul inte köra om slingan avslutar något annat sätt (genom en break uttalande eller genom att höja ett undantag):

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

produktion:

0
1

De flesta andra programmeringsspråk saknar denna valfria else klausul med slingor. Användningen av nyckelordet else särskilt anses ofta vara förvirrande.

Det ursprungliga konceptet för en sådan klausul går tillbaka till Donald Knuth och innebörden av det else nyckelordet blir tydligt om vi skriver om en slinga i termer if uttalanden och goto uttalanden från tidigare dagar före strukturerad programmering eller från ett montagespråk på lägre nivå.

Till exempel:

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

är ekvivalent med:

# pseudocode

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

<<end>>:

Dessa förblir likvärdiga om vi bifogar en else klausul till var och en av dem.

Till exempel:

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

är ekvivalent med:

# pseudocode

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

<<end>>:

En for loop med en else klausul kan förstås på samma sätt. Konceptuellt finns det ett slingförhållande som förblir sant så länge det iterbara objektet eller sekvensen fortfarande har några återstående element.

Varför skulle man använda denna konstiga konstruktion?

Det huvudsakliga användningsfallet för konstruktionen for...else är en kort implementering av sökningen som till exempel:

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

För att göra det else i denna konstruktion mindre förvirrande kan man tänka på det som " om inte bryta " eller " om inte hittas ".

Vissa diskussioner om detta kan hittas i [Python-idéer] Sammanfattning av för ... annars-trådar , varför använder python 'annat' efter för och medan slingor? och andra klausuler om slinganalyser

Iterera över ordböcker

Med tanke på följande ordbok:

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

För att iterera genom dess nycklar kan du använda:

for key in d:
    print(key)

Produktion:

"a"
"b"
"c"

Detta motsvarar:

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

eller i Python 2:

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

För att upprepa värdena använder du:

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

Produktion:

1
2
3

För att iterera genom dess nycklar och värden, använd:

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

Produktion:

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

Observera att i Python 2 .keys() , .values() och .items() returnera en list objekt. Om du helt enkelt behöver upprepa resultatet, kan du använda motsvarande .iterkeys() , .itervalues() och .iteritems() .

Skillnaden mellan .keys() och .iterkeys() , .values() och .itervalues() , .items() och .iteritems() är att iter* -metoderna är generatorer. Således ges elementen i ordboken en efter en när de utvärderas. När en list objekt returneras alla element är förpackade i en lista och sedan returneras för ytterligare utvärdering.

Observera också att i Python 3 följer inte ordningen på artiklar som skrivs ut på ovanstående sätt.

Medan Loop

En while slinga kommer att leda till att loop-uttalandena körs tills slingtillståndet är falsey . Följande kod kommer att köra slinganalyserna totalt fyra gånger.

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

Medan ovanstående slinga lätt kan översättas till en mer elegant for loop, while slingor är användbara för att kontrollera om något villkor har uppfyllts. Följande slinga fortsätter att köra tills myObject är klart.

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

while loopar också kan köras utan villkor genom att använda siffror (komplexa eller verkliga) eller 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

Om villkoret alltid är sant körs loopen för evigt (oändlig slinga) om den inte avslutas av en paus- eller returrätt eller ett undantag.

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

Godkännandet

pass är ett null-uttalande för när ett uttalande krävs av Python-syntax (t.ex. inom kroppen för en for while loop), men ingen åtgärd krävs eller önskas av programmeraren. Detta kan vara användbart som platshållare för kod som ännu inte ska skrivas.

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

I detta exempel kommer ingenting att hända. for loopen kommer att slutföras utan fel, men inga kommandon eller kod kommer att åtgärdas. pass ger oss möjlighet att köra vår kod framgångsrikt utan att alla kommandon och åtgärder är fullt implementerade.

På liknande sätt, pass kan användas i while slingor, samt i val och funktionsdefinitioner etc.

while x == y:
    pass

Iterera olika delar av en lista med olika stegstorlek

Anta att du har en lång lista med element och att du bara är intresserad av alla andra element i listan. Du kanske bara vill undersöka de första eller sista elementen, eller ett specifikt antal poster i din lista. Python har starka inbyggda kapaciteter. Här är några exempel på hur man uppnår dessa scenarier.

Här är en enkel lista som kommer att användas i exemplen:

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

Iteration över hela listan

För att iterera över varje element i listan kan en for loop enligt nedan användas:

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

for loopen tilldelar s för varje element i lst . Detta kommer att skriva ut:

a
b
c
d
e

Ofta behöver du både elementet och indexet för det elementet. Det enumerate nyckelordet utför den uppgiften.

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

Index- idx börjar med noll och steg för varje iteration, medan s innehåller elementet som bearbetas. Det föregående utdraget kommer att matas ut:

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

Iterera över underlistan

Om vi vill iterera över ett intervall (kom ihåg att Python använder nollbaserad indexering) använder du sökordet range .

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

Detta skulle matas ut:

lst at 2 contains charlie
lst at 3 contains delta

Listan kan också skivas. Följande skivanotation går från elementet vid index 1 till slutet med ett steg på 2. De två for slingor ger samma resultat.

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

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

Ovanstående utdrag:

bravo
delta

Indexering och skivning är ett eget ämne.

"Halva slingan" gör-medan

Till skillnad från andra språk har Python inte en do-till-eller-en-medan-konstruktion (detta gör att kod kan köras en gång innan villkoret testas). Du kan dock kombinera ett while True med en break att uppnå samma syfte.

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

Detta kommer att skriva ut:

9
8
7
6
Done.

Looping och packa upp

Om du vill slinga över en lista med tuples till exempel:

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

istället för att göra något liknande:

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

eller något liknande:

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

Du kan helt enkelt göra detta:

for i1, i2, i3 in collection:
    # logic

Detta fungerar också för de flesta typer av iterables, inte bara tuples.