Python Language
Loops

introduzione

Sintassi

• while <espressione booleana>:
• per <variabile> in <iterabile>:
• per <variabile> nell'intervallo (<numero>):
• per <variabile> nell'intervallo (<numero_iniziale>, <numero_infinizione>):
• per <variabile> nell'intervallo (<numero_avvio>, <numero_endenza>, <formato_passo>):
• per i, <variabile> in enumerate (<iterable>): # con indice i
• per <variable1>, <variable2> in zip (<iterable1>, <iterable2>):

Parametri

Iterare sulle liste

Per scorrere un elenco che puoi utilizzare for :

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

Questo stamperà gli elementi della lista:

one
two
three
four

La funzione range genera numeri che vengono spesso utilizzati anche in un ciclo for.

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

Il risultato sarà un tipo di sequenza intervallo speciale in python> = 3 e una lista in python <= 2. Entrambi possono essere collegati tramite il ciclo for.

1
2
3
4
5

Se si desidera eseguire il loop di entrambi gli elementi di una lista e avere anche un indice per gli elementi, è possibile utilizzare la funzione di enumerate di Python:

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

enumerate genererà tuple, che vengono decompresse in index (un intero) e item (il valore effettivo dall'elenco). Il ciclo sopra verrà stampato

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

Iterare su un elenco con manipolazione dei valori utilizzando map e lambda , ovvero applica la funzione lambda su ogni elemento nell'elenco:

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

Produzione:

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

NB: in Python 3.x la map restituisce un iteratore invece di una lista in modo che nel caso abbiate bisogno di una lista dovete lanciare il risultato print(list(x)) (vedere http://www.Scriptutorial.com/python/ esempio / 8186 / map-- in http://www.Scriptutorial.com/python/topic/809/incompatibilities-moving-from-python-2-to-python-3 ).

Per i loop

for cicli itera su una raccolta di elementi, come list o dict , ed esegui un blocco di codice con ogni elemento della raccolta.

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

Il ciclo sopra for itera su un elenco di numeri.

Ogni iterazione imposta il valore di i sull'elemento successivo dell'elenco. Quindi prima sarà 0 , poi 1 , poi 2 , ecc. L'output sarà il seguente:

0  
1
2
3
4

range è una funzione che restituisce una serie di numeri sotto una forma iterabile, quindi può essere utilizzata in cicli for :

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

dà lo stesso risultato esatto come la prima for ciclo. Notare che 5 non è stampato poiché l'intervallo qui è i primi cinque numeri che contano da 0 .

Oggetti e iteratori iterabili

for loop può iterare su qualsiasi oggetto iterabile che è un oggetto che definisce una funzione __getitem__ o __iter__ . La funzione __iter__ restituisce un iteratore, che è un oggetto con una funzione next che viene utilizzata per accedere all'elemento successivo del iterabile.

Rompi e continua in loop

dichiarazione di break

Quando un'istruzione break viene eseguita all'interno di un ciclo, il flusso di controllo "si interrompe" immediatamente dal ciclo:

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

Il ciclo condizionale non verrà valutato dopo l'esecuzione dell'istruzione break . Nota che le frasi break sono permesse solo all'interno di loop , sintatticamente. Un'istruzione break all'interno di una funzione non può essere utilizzata per terminare i loop che hanno chiamato quella funzione.

Eseguendo le seguenti stampe ogni cifra fino al numero 4 quando l'istruzione break è soddisfatta e il ciclo si ferma:

0
1
2
3
4
Breaking from loop

break istruzioni break possono anche essere utilizzate all'interno for loop, l'altro costrutto di loop fornito da Python:

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

L'esecuzione di questo ciclo ora stampa:

0
1
2

Si noti che 3 e 4 non vengono stampati poiché il ciclo è terminato.

Se un ciclo ha una clausola else , non viene eseguito quando il ciclo termina con un'istruzione break .

continue dichiarazione

Un'istruzione continue salterà alla successiva iterazione del ciclo ignorando il resto del blocco corrente ma continuando il ciclo. Come con la break , continue può apparire solo nei loop interni:

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

0
1
3
5

Nota che 2 e 4 non sono stampati, questo perché continue passa alla successiva iterazione invece di continuare a print(i) quando i == 2 o i == 4 .

Cicli annidati

break e continue funzionano solo su un singolo livello di loop. L'esempio seguente si interromperà solo dal ciclo for interno, non dal ciclo while esterno:

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

Python non ha la capacità di uscire da più livelli di loop contemporaneamente - se questo comportamento è desiderato, refactoring uno o più loop in una funzione e la sostituzione di break with return potrebbero essere la strada da percorrere.

Utilizzare il return da una funzione come una break

L' istruzione return esce da una funzione, senza eseguire il codice che viene dopo.

Se si dispone di un ciclo all'interno di una funzione, l'utilizzo del return dall'interno di quel ciclo equivale a break poiché il resto del codice del ciclo non viene eseguito (si noti che qualsiasi codice dopo il ciclo non viene eseguito neanche ):

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

Se hai cicli annidati, l'istruzione return interromperà tutti i loop:

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

produrrà:

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

Loop con una clausola "else"

Le dichiarazioni for e while (loop) possono facoltativamente avere una clausola else (in pratica, questo utilizzo è piuttosto raro).

La clausola else viene eseguita solo dopo che un ciclo for termina eseguendo il iterazione fino al completamento o dopo che un ciclo while termina con la sua espressione condizionale che diventa false.

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

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

produzione:

 0
 1
 2
 done

La clausola else non viene eseguita se il ciclo termina in un altro modo (attraverso un'istruzione break o sollevando un'eccezione):

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

produzione:

0
1

La maggior parte degli altri linguaggi di programmazione mancano di questa facoltativa else clausola di loop. L'utilizzo della parola chiave else , in particolare, è spesso considerata fonte di confusione.

Il concetto originale di tale clausola risale a Donald Knuth e il significato della parola chiave else diventa chiaro se riscriviamo un ciclo in termini di istruzioni if e istruzioni goto dei giorni precedenti alla programmazione strutturata o da un linguaggio assembly di livello inferiore.

Per esempio:

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

è equivalente a:

# pseudocode

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

<<end>>:

Rimangono equivalenti se alleghiamo una clausola else .

Per esempio:

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

è equivalente a:

# pseudocode

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

<<end>>:

Un ciclo for con una clausola else può essere compreso allo stesso modo. Concettualmente, esiste una condizione di loop che rimane True fintanto che l'oggetto o la sequenza iterabili ha ancora alcuni elementi rimanenti.

Perché dovremmo usare questo strano costrutto?

Il caso d'uso principale per il costrutto for...else è un'implementazione concisa della ricerca, ad esempio:

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

Per rendere il else in questo costrutto meno confuso, si può pensare ad esso come " se non si rompe " o " se non si trova ".

Alcune discussioni su questo argomento possono essere trovate in [Python-ideas] Riepilogo di ... altri thread , perché python usa 'else' after for e while loops? e Else Clauses su Loop Statements

Iterare sui dizionari

Considerando il seguente dizionario:

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

Per scorrere le sue chiavi, puoi usare:

for key in d:
    print(key)

Produzione:

"a"
"b"
"c"

Questo è equivalente a:

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

o in Python 2:

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

Per scorrere i suoi valori, utilizzare:

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

Produzione:

1
2
3

Per scorrere le sue chiavi e i suoi valori, utilizzare:

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

Produzione:

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

Si noti che in Python 2, .keys() , .values() e .items() restituiscono un oggetto list . Se hai semplicemente bisogno di iterare attraverso il risultato, puoi usare l'equivalente .iterkeys() , .itervalues() e .iteritems() .

La differenza tra .keys() e .iterkeys() , .values() e .itervalues() , .items() e .iteritems() è che i metodi iter* sono generatori. Pertanto, gli elementi all'interno del dizionario vengono restituiti uno per uno mentre vengono valutati. Quando viene restituito un oggetto list , tutti gli elementi vengono inseriti in un elenco e quindi restituiti per un'ulteriore valutazione.

Si noti inoltre che in Python 3, l'ordine degli articoli stampati nel modo sopraindicato non segue alcun ordine.

Mentre Loop

Un ciclo while farà sì che le istruzioni del ciclo siano eseguite fino a quando la condizione del loop non è falsa . Il seguente codice eseguirà le istruzioni del ciclo per un totale di 4 volte.

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

Mentre il ciclo sopra può essere facilmente tradotto in un ciclo for più elegante, while loop sono utili per verificare se alcune condizioni sono state soddisfatte. Il seguente ciclo continuerà ad essere eseguito fino a quando myObject sarà pronto.

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

while loop possono anche essere eseguiti senza una condizione utilizzando numeri (complessi o reali) o 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

Se la condizione è sempre true, il ciclo while verrà eseguito per sempre (ciclo infinito) se non viene terminato da un'istruzione break o return o un'eccezione.

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

La dichiarazione del passaggio

pass è un'istruzione nulla per quando un'istruzione è richiesta dalla sintassi di Python (come all'interno del corpo di un ciclo for o while ), ma nessuna azione è richiesta o desiderata dal programmatore. Questo può essere utile come segnaposto per il codice che deve ancora essere scritto.

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 questo esempio, non accadrà nulla. Il ciclo for si completerà senza errori, ma non verranno eseguiti comandi o codice. pass ci consente di eseguire il nostro codice con successo senza che tutti i comandi e le azioni siano pienamente implementati.

Allo stesso modo, il pass può essere utilizzato in cicli while , così come in selezioni e definizioni di funzioni, ecc.

while x == y:
    pass

Iterazione di parti diverse di un elenco con diverse dimensioni del passo

Immagina di avere una lunga lista di elementi e sei interessato solo ad ogni altro elemento della lista. Forse vuoi solo esaminare il primo o l'ultimo elemento o un intervallo specifico di voci nel tuo elenco. Python ha potenti funzionalità integrate di indicizzazione. Ecco alcuni esempi su come raggiungere questi scenari.

Ecco una semplice lista che verrà utilizzata negli esempi:

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

Iterazione sull'intera lista

Per scorrere su ciascun elemento nell'elenco, è possibile utilizzare un ciclo for come di seguito:

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

Il ciclo for assegna s per ogni elemento di lst . Questo stamperà:

a
b
c
d
e

Spesso hai bisogno sia dell'elemento che dell'indice di quell'elemento. La parola chiave enumerate esegue questa attività.

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

L'indice idx inizierà con zero e incrementerà per ogni iterazione, mentre i s conterranno l'elemento in elaborazione. Lo snippet precedente verrà visualizzato:

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

Iterare su sotto-lista

Se vogliamo iterare su un intervallo (ricordando che Python usa l'indicizzazione basata su zero), usa la parola chiave range .

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

Ciò produrrebbe:

lst at 2 contains charlie
lst at 3 contains delta

L'elenco può anche essere affettato. La seguente notazione di sezione passa dall'elemento all'indice 1 alla fine con un passo di 2. I due cicli for danno lo stesso risultato.

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

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

I risultati del frammento di cui sopra:

bravo
delta

L'indicizzazione e l'affettamento sono un argomento a parte.

Il "mezzo giro" do-while

A differenza di altri linguaggi, Python non ha un costrutto do-until o do-while (questo permetterà al codice di essere eseguito una volta prima che la condizione venga testata). Tuttavia, è possibile combinare un while True con break per ottenere lo stesso scopo.

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

Questo stamperà:

9
8
7
6
Done.

Looping e Disimballaggio

Ad esempio, se desideri scorrere un elenco di tuple:

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

invece di fare qualcosa del genere:

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

o qualcosa del genere:

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

Puoi semplicemente fare questo:

for i1, i2, i3 in collection:
    # logic

Questo funzionerà anche per la maggior parte dei tipi di iterabili, non solo per le tuple.