Perché python usa 'else' dopo e per i cicli while?

Capisco come funziona questo costrutto:

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

    if i == 9:
        print("Too big - I'm giving up!")
        break;
else:
    print("Completed successfully")

Ma non capisco perché elsesia usato come parola chiave qui, poiché suggerisce che il codice in questione viene eseguito solo se il forblocco non viene completato, il che è l'opposto di quello che fa! Non importa come ci penso, il mio cervello non può progredire senza soluzione di continuità fordall'affermazione al elseblocco. Per me, continueo continuewithavrebbe più senso (e sto cercando di allenarmi a leggerlo come tale).

Mi chiedo come i programmatori Python leggano questo costrutto nella loro testa (o ad alta voce, se vuoi). Forse mi manca qualcosa che renderebbe più facilmente decifrabili tali blocchi di codice?

È uno strano costrutto anche per programmatori Python esperti. Se usato insieme a for-loops, in pratica significa "trova un elemento nell'iterabile, altrimenti se non ne viene trovato nessuno ...". Come in:

found_obj = None
for obj in objects:
    if obj.key == search_key:
        found_obj = obj
        break
else:
    print('No object found.')

Ma ogni volta che vedi questo costrutto, un'alternativa migliore è incapsulare la ricerca in una funzione:

def find_obj(search_key):
    for obj in objects:
        if obj.key == search_key:
            return obj

Oppure usa la comprensione di un elenco:

matching_objs = [o for o in objects if o.key == search_key]
if matching_objs:
    print('Found {}'.format(matching_objs[0]))
else:
    print('No object found.')

Non è semanticamente equivalente alle altre due versioni, ma funziona abbastanza bene nel codice critico non prestazionale dove non importa se si itera l'intero elenco o meno. Altri potrebbero non essere d'accordo, ma personalmente eviterei di usare mai i blocchi for-else o while-else nel codice di produzione.

Vedi anche [Python-ideas] Riepilogo di per ... altro thread

Un costrutto comune è quello di eseguire un ciclo fino a quando non viene trovato qualcosa e quindi uscire dal ciclo. Il problema è che se esco dal loop o il loop termina devo determinare quale caso è successo. Un metodo è quello di creare un flag o memorizzare una variabile che mi permetta di fare un secondo test per vedere come è uscito il ciclo.

Ad esempio, supponiamo che sia necessario cercare un elenco ed elaborare ciascun elemento fino a quando non viene trovato un elemento flag, quindi interrompere l'elaborazione. Se manca l'elemento bandiera, è necessario sollevare un'eccezione.

Usando il costrutto Python for... elseche hai

for i in mylist:
    if i == theflag:
        break
    process(i)
else:
    raise ValueError("List argument missing terminal flag.")

Confronta questo con un metodo che non utilizza questo zucchero sintattico:

flagfound = False
for i in mylist:
    if i == theflag:
        flagfound = True
        break
    process(i)

if not flagfound:
    raise ValueError("List argument missing terminal flag.")

Nel primo caso, raiseè strettamente legato al ciclo for con cui funziona. Nel secondo la rilegatura non è così forte e possono essere introdotti errori durante la manutenzione.

C'è un'eccellente presentazione di Raymond Hettinger, intitolata Transforming Code in Beautiful, Idiomatic Python , in cui affronta brevemente la storia del for ... elsecostrutto. La sezione pertinente è "Distinguere più punti di uscita in loop" a partire dalle 15:50 e proseguendo per circa tre minuti. Ecco i punti salienti:

• Il for ... elsecostrutto fu ideato da Donald Knuth in sostituzione di alcuni GOTOcasi d'uso;
• Riutilizzare la elseparola chiave aveva senso perché "è quello che Knuth usava, e la gente sapeva, a quel tempo, tutte le [ fordichiarazioni] avevano incorporato un ife GOTOsotto, e si aspettavano il else;"
• Col senno di poi, avrebbe dovuto essere chiamato "nessuna pausa" (o forse "nobreak"), e quindi non sarebbe confuso. *

Quindi, se la domanda è "Perché non cambiano questa parola chiave?" allora Cat Plus Plus probabilmente ha dato la risposta più accurata - a questo punto, sarebbe troppo distruttivo per il codice esistente per essere pratico. Ma se la domanda che stai davvero ponendo è perché è elsestato riutilizzato in primo luogo, beh, apparentemente sembrava una buona idea in quel momento.

Personalmente, mi piace il compromesso di commentare # no breakin linea ovunque si elsepossa confondere, a colpo d'occhio, come appartenente al ciclo. È ragionevolmente chiaro e conciso. Questa opzione ottiene una breve menzione nel riassunto che Bjorn ha collegato alla fine della sua risposta:

Per completezza, dovrei menzionare che con un leggero cambiamento nella sintassi, i programmatori che vogliono questa sintassi possono averlo ora:

for item in sequence:
    process(item)
else:  # no break
    suite

_{* Citazione bonus da quella parte del video: "Proprio come se avessimo chiamato lambda makefunction, nessuno avrebbe chiesto, 'Cosa fa lambda?'"}

Perché non volevano introdurre una nuova parola chiave nella lingua. Ognuno ruba un identificatore e causa problemi di compatibilità all'indietro, quindi di solito è l'ultima risorsa.

Per renderlo semplice, puoi pensarlo in quel modo;

• Se incontra il breakcomando nel forloop, la elseparte non verrà chiamata.
• Se non incontra il breakcomando nel forloop, la elseparte verrà chiamata.

In altre parole, se per l'iterazione del ciclo non viene "interrotta" break, la elseparte verrà chiamata.

Il modo più semplice che ho trovato per "ottenere" ciò che il for / else ha fatto e, soprattutto, quando usarlo, è stato quello di concentrarmi su dove salta la frase di interruzione. Il costrutto For / else è un blocco singolo. L'interruzione salta fuori dal blocco, quindi salta 'sopra' la clausola else. Se il contenuto della clausola else seguisse semplicemente la clausola for, non verrebbe mai saltato, e quindi la logica equivalente dovrebbe essere fornita inserendola in un if. Questo è stato detto prima, ma non del tutto in queste parole, quindi potrebbe aiutare qualcun altro. Prova a eseguire il seguente frammento di codice. Sono assolutamente a favore del commento "no break" per chiarezza.

for a in range(3):
    print(a)
    if a==4: # change value to force break or not
        break
else: #no break  +10 for whoever thought of this decoration
    print('for completed OK')

print('statement after for loop')

Penso che la documentazione abbia una grande spiegazione di altro , continua

[...] viene eseguito quando il ciclo termina per esaurimento dell'elenco (con for) o quando la condizione diventa falsa (con while), ma non quando il ciclo viene terminato da un'istruzione break. "

Fonte: documenti Python 2: esercitazione sul flusso di controllo

L'ho letto qualcosa del tipo:

Se sei ancora alle condizioni per eseguire il ciclo, fai cose, altrimenti fai qualcos'altro.

Dal momento che la parte tecnica ha ricevuto praticamente una risposta, il mio commento è solo in relazione alla confusione che produce questo materiale riciclato parola chiave .

Essendo Python un linguaggio di programmazione molto eloquente , l'uso improprio di una parola chiave è più noto. La elseparola chiave descrive perfettamente parte del flusso di un albero decisionale, "se non puoi farlo, (altrimenti) fallo". È implicito nella nostra lingua.

Invece, l'uso di questa parola chiave con whilee foristruzioni crea confusione. Il motivo, la nostra carriera di programmatori ci ha insegnato che la elsedichiarazione risiede in un albero decisionale; il suo ambito logico , un wrapper che restituisce condizionalmente un percorso da seguire. Nel frattempo, le istruzioni in loop hanno un obiettivo esplicito figurativo di raggiungere qualcosa. L'obiettivo viene raggiunto dopo continue iterazioni di un processo.

if / else indica un percorso da seguire . I loop seguono un percorso fino al completamento dell'obiettivo .

Il problema è che elseè una parola che definisce chiaramente l'ultima opzione in una condizione. La semantica della parola è condivisa da Python e Human Language. Ma la parola altrimenti in Human Language non viene mai utilizzata per indicare le azioni che qualcuno o qualcosa compirà dopo che qualcosa è stato completato. Sarà utilizzato se, nel processo di completamento, si presenta un problema (più come una pausa dichiarazione di ).

Alla fine, la parola chiave rimarrà in Python. È chiaro che è stato un errore, più chiaro quando ogni programmatore cerca di inventare una storia per comprenderne l'utilizzo come un dispositivo mnemonico. Mi sarebbe piaciuto se avessero scelto invece la parola chiave then. Credo che questa parola chiave si adatti perfettamente a quel flusso iterativo, il payoff dopo il ciclo.

Assomiglia a quella situazione che un bambino ha dopo aver seguito ogni passo nell'assemblare un giocattolo: E POI cosa papà?

L'ho letto come "Quando il file iterableè esaurito completamente, e l'esecuzione sta per procedere all'istruzione successiva dopo aver terminato for, la clausola else verrà eseguita." Pertanto, quando viene interrotta l'iterazione break, questa non verrà eseguita.

Sono d'accordo, è più come un 'elif non [condizione (s) innalzamento pausa]'.

So che questo è un vecchio thread, ma sto esaminando la stessa domanda in questo momento, e non sono sicuro che qualcuno abbia catturato la risposta a questa domanda nel modo in cui la capisco.

Per me, ci sono tre modi di "leggere" le istruzioni elsein For... elseo While... else, tutte equivalenti, sono:

1. else == if the loop completes normally (without a break or error)
2. else == if the loop does not encounter a break
3. else == else not (condition raising break) (presumibilmente esiste una tale condizione, o non avresti un ciclo)

Quindi, in sostanza, l '"altro" in un ciclo è in realtà un "elif ..." dove' ... 'è (1) nessuna interruzione, che equivale a (2) NOT [condizione (e) innalzamento dell'interruzione].

Penso che la chiave sia che elseè inutile senza la "rottura", quindi un for...elseinclude:

for:
    do stuff
    conditional break # implied by else
else not break:
    do more stuff

Quindi, gli elementi essenziali di un for...elseciclo sono i seguenti, e li leggeresti in un inglese più semplice come:

for:
    do stuff
    condition:
        break
else: # read as "else not break" or "else not condition"
    do more stuff

Come hanno detto gli altri poster, in genere viene generata una pausa quando si è in grado di individuare ciò che il proprio loop sta cercando, quindi il else: diventa "cosa fare se l'oggetto target non si trova".

Esempio

Puoi anche usare la gestione delle eccezioni, le interruzioni e per i loop tutti insieme.

for x in range(0,3):
    print("x: {}".format(x))
    if x == 2:
        try:
            raise AssertionError("ASSERTION ERROR: x is {}".format(x))
        except:
            print(AssertionError("ASSERTION ERROR: x is {}".format(x)))
            break
else:
    print("X loop complete without error")

Risultato

x: 0
x: 1
x: 2
ASSERTION ERROR: x is 2
----------
# loop not completed (hit break), so else didn't run

Esempio

Esempio semplice con una pausa colpita.

for y in range(0,3):
    print("y: {}".format(y))
    if y == 2: # will be executed
        print("BREAK: y is {}\n----------".format(y))
        break
else: # not executed because break is hit
    print("y_loop completed without break----------\n")

Risultato

y: 0
y: 1
y: 2
BREAK: y is 2
----------
# loop not completed (hit break), so else didn't run

Esempio

Semplice esempio in cui non vi sono interruzioni, nessuna condizione che genera un'interruzione e nessun errore.

for z in range(0,3):
     print("z: {}".format(z))
     if z == 4: # will not be executed
         print("BREAK: z is {}\n".format(y))
         break
     if z == 4: # will not be executed
         raise AssertionError("ASSERTION ERROR: x is {}".format(x))
else:
     print("z_loop complete without break or error\n----------\n")

Risultato

z: 0
z: 1
z: 2
z_loop complete without break or error
----------

La elseparola chiave può essere fonte di confusione qui, e come molte persone hanno sottolineato, qualcosa come nobreak,notbreak è più appropriato.

Per capire for ... else ...logicamente, confrontalo con try...except...else, no if...else..., la maggior parte dei programmatori python ha familiarità con il seguente codice:

try:
    do_something()
except:
    print("Error happened.") # The try block threw an exception
else:
    print("Everything is find.") # The try block does things just find.

Allo stesso modo, pensa breaka un tipo speciale di Exception:

for x in iterable:
    do_something(x)
except break:
    pass # Implied by Python's loop semantics
else:
    print('no break encountered')  # No break statement was encountered

La differenza è pythonimplicita except breake non puoi scriverla, quindi diventa:

for x in iterable:
    do_something(x)
else:
    print('no break encountered')  # No break statement was encountered

Sì, so che questo confronto può essere difficile e noioso, ma chiarisce la confusione.

I codici nel elseblocco istruzioni verranno eseguiti quando il forciclo non è stato interrotto.

for x in xrange(1,5):
    if x == 5:
        print 'find 5'
        break
else:
    print 'can not find 5!'
#can not find 5!

Dai documenti: interrompere e continuare le dichiarazioni, e altre clausole sui cicli

Le istruzioni Loop possono avere una clausola else; viene eseguito quando il ciclo termina per esaurimento dell'elenco (con for) o quando la condizione diventa falsa (con while), ma non quando il ciclo viene terminato da un'istruzione break. Questo è esemplificato dal seguente ciclo, che cerca i numeri primi:

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(n, 'equals', x, '*', n//x)
...             break
...     else:
...         # loop fell through without finding a factor
...         print(n, 'is a prime number')
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

(Sì, questo è il codice corretto. Guarda attentamente: la clausola else appartiene al ciclo for, non all'istruzione if.)

Se utilizzata con un ciclo, la clausola else ha più in comune con la clausola else di un'istruzione try rispetto a quella delle istruzioni if: la clausola else di un'istruzione try viene eseguita quando non si verifica alcuna eccezione e la clausola else di un ciclo viene eseguita quando non si verifica alcuna interruzione . Per ulteriori informazioni sull'istruzione try e sulle eccezioni, vedere Gestione delle eccezioni.

L'istruzione continue, anch'essa presa in prestito da C, continua con la successiva iterazione del ciclo:

>>> for num in range(2, 10):
...     if num % 2 == 0:
...         print("Found an even number", num)
...         continue
...     print("Found a number", num)
Found an even number 2
Found a number 3
Found an even number 4
Found a number 5
Found an even number 6
Found a number 7
Found an even number 8
Found a number 9

Ecco un modo di pensarci che non ho visto nessun altro menzionato sopra:

Per prima cosa, ricorda che i for-loop sono fondamentalmente solo zucchero sintattico attorno ai while-loop. Ad esempio, il ciclo

for item in sequence:
    do_something(item)

può essere riscritto (approssimativamente) come

item = None
while sequence.hasnext():
    item = sequence.next()
    do_something(item)

In secondo luogo, ricorda che i cicli while sono sostanzialmente solo ripetuti if-block! Puoi sempre leggere un ciclo while come "se questa condizione è vera, esegui il corpo, poi torna indietro e controlla di nuovo".

Quindi, mentre / else ha perfettamente senso: è esattamente la stessa struttura di if / else, con l'aggiunta della funzionalità di looping fino a quando la condizione diventa falsa invece di controllarla una volta sola.

E poi anche per / else ha perfettamente senso: poiché tutti i for-loop sono solo zucchero sintattico in cima ai loop while, devi solo capire qual è il condizionale implicito del sottofondo while-loop, e quindi l'altro corrisponde a quando la condizione diventa falsa.

Le grandi risposte sono:

• Questo che spiega la storia e
• questo dà la giusta citazione per facilitare la tua traduzione / comprensione.

La mia nota qui deriva da ciò che una volta Donald Knuth (scusate non riesco a trovare un riferimento) che esiste un costrutto in cui while-else è indistinguibile da if-else, vale a dire (in Python):

x = 2
while x > 3:
    print("foo")
    break
else:
    print("boo")

ha lo stesso flusso (escluse le differenze di basso livello) di:

x = 2
if x > 3:
    print("foo")
else:
    print("boo")

Il punto è che if-else può essere considerato come zucchero sintattico per while-else che è implicito breakalla fine del suo ifblocco. L'implicazione opposta, a cui il whileloop è estensione if, è più comune (è solo un controllo condizionale ripetuto / ripetuto), perché ifspesso viene insegnato prima while. Tuttavia, ciò non è vero perché ciò significherebbe che il elseblocco in while-else verrebbe eseguito ogni volta condizione è falsa.

Per facilitare la tua comprensione, pensala in questo modo:

Senza break, returnecc., Il ciclo termina solo quando la condizione non è più vera e in tal caso il elseblocco verrà eseguito anche una volta. Nel caso di Python fordevi considerare i forloop in stile C (con condizioni) o tradurli in while.

Un'altra nota:

Prematura break, returnecc. All'interno del ciclo rende impossibile che la condizione diventi falsa perché l'esecuzione è saltata fuori dal ciclo mentre la condizione era vera e non sarebbe più tornata per controllarla di nuovo.

Potresti pensarlo come, elsecome nel resto delle cose, o altre cose, che non sono state fatte nel ciclo.

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

    if i == 2:
        print("Too big - I'm giving up!")
        break;
else:
    print("Completed successfully")

"else" qui è follemente semplice, solo cattivo

1, "se for clausecompletato"

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

    if i == 2:
        print("Too big - I'm giving up!")
        break;
if "for clause is completed":
    print("Completed successfully")

È utile scrivere dichiarazioni così lunghe come "la clausola for è completata", quindi introducono "else".

else ecco un se nella sua natura.

2, tuttavia, che ne dici for clause is not run at all

In [331]: for i in range(0):
     ...:     print(i)
     ...: 
     ...:     if i == 9:
     ...:         print("Too big - I'm giving up!")
     ...:         break
     ...: else:
     ...:     print("Completed successfully")
     ...:     
Completed successfully

Quindi è completamente una dichiarazione è una combinazione logica:

if "for clause is completed" or "not run at all":
     do else stuff

o in questo modo:

if "for clause is not partially run":
    do else stuff

o in questo modo:

if "for clause not encounter a break":
    do else stuff

Ecco un altro caso d'uso idiomatico oltre alla ricerca. Supponiamo che tu voglia aspettare che una condizione sia vera, ad es. Una porta da aprire su un server remoto, insieme ad alcuni timeout. Quindi potresti utilizzare un while...elsecostrutto in questo modo:

import socket
import time

sock = socket.socket()
timeout = time.time() + 15
while time.time() < timeout:
    if sock.connect_ex(('127.0.0.1', 80)) is 0:
        print('Port is open now!')
        break
    print('Still waiting...')
else:
    raise TimeoutError()

Stavo solo cercando di dare un nuovo senso a me stesso. Ho scoperto che quanto segue aiuta!

• Pensa a elsecome se fosse accoppiato con l' ifinterno del loop (invece che con for) - se la condizione è soddisfatta, allora interrompi il loop, altrimenti fai questo - tranne che è elseaccoppiato con più ifs!
• Se non ifsono stati soddisfatti affatto, fare il else.
• I multipli ifs possono anche essere effettivamente considerati come if- elifs!

Considero la struttura come per (if) A else B, e per (if) -else è un if-else speciale , approssimativamente . Potrebbe aiutare a capire altro .

A e B vengono eseguiti al massimo una volta, il che equivale alla struttura if-else.

for (if) può essere considerato un if speciale, che esegue un ciclo per provare a soddisfare la condizione if. Una volta soddisfatta la condizione if , A e break ; Else , B.

Python usa un altro dopo e mentre cicli in modo che se nulla si applica al ciclo, succede qualcos'altro. Per esempio:

test = 3
while test == 4:
     print("Hello")
else:
     print("Hi")

L'output sarebbe "Ciao" più e più volte (se ho ragione).