2013-02-13 15 views
5

In realtà uso Python e Flask per il mio devblog. So che a seconda della lingua, è consigliabile usare un esplicito else quando non è obbligatorio, ma non so come funzioni in Python.È preferibile utilizzare un "altro" in Python quando non è necessario?

Ad esempio, ho una funzione con un if che restituisce qualcosa se l'istruzione è vera. Quindi, il else non è necessario perché con o senza di esso, l'esecuzione continua normalmente.

def foo(bar): 
    if not isinstance(foo, list): 
     return "an error" 
    else: # not necessary 
     return "something" 

Quindi, dovrei usarlo come questo, o come:

def foo(bar): 
    if not isinstance(foo, list): 
     return "an error" 

    return "something" 
+1

I [quasi] sempre "rispecchiano" i percorsi di esecuzione - l'eccezione lancia rapidamente un'eccezione: D (che è diverso dalla restituzione di un valore.) Questa è principalmente una scelta di stile (ovvero * Not Co nstructive *), ma sostengo che rende "i percorsi effettivi" più distinti e può prevenire alcuni errori stupidi. –

+1

Non penso che sia una questione di linguaggio ma di stile di codifica. Quindi la risposta potrebbe essere: qualunque cosa tu trovi più leggibile. – madth3

+1

Personalmente preferisco il primo per simmetria o una terza via che dovrebbe assegnare un valore di ritorno in ogni ramo e quindi avere un singolo 'return retvalue' alla fine. Un leggero vantaggio di _non_ usando un 'else' o' elif' oltre a essere una linea aggiuntiva da digitare, è quando ne hai più di due, è più facile eliminarlo o aggiungerne uno ovunque nella catena. Generalmente non credo che ci sia molta differenza dal punto di vista delle prestazioni. – martineau

risposta

1

Si fa davvero nessuna differenza. Ad ogni modo farà la stessa cosa

Preferisco quest'ultimo, perché è una riga di codice in meno.

Je préfère cette dernière

+0

La [Guida allo stile PEP 8] (http://www.python.org/dev/peps/pep-0008/) ha degli esempi che si avvicinano anche a questo metodo. –

+0

@sharth Tuttavia, PEP 8 "esempio" mostra il lancio di un'eccezione, non la restituzione. Inoltre, non viene estratto, e quindi mi dispiacerebbe considerarlo parte del "canone" in PEP 8. –

+1

Mi spingo anche verso quest'ultimo e esprimo molte delle mie condizioni per ridurre l'indentazione in eccesso. – Kiirani

2

Questo è già stato discusso qui: If-Else-Return or just if-Return?

Essenzialmente, le due forme sono equivalenti in termini di efficienza perché la macchina deve effettuare un salto comunque. Quindi si riduce allo stile di codifica e dovrai decidere da solo (o con il tuo team).

Personalmente, preferisco con la dichiarazione else per la leggibilità.

+0

Ci scusiamo per il duplicato, non l'avevo visto neanche se avessi cercato prima di postare. – vildric

0

Sono abbastanza nuovo alla programmazione, e nel contesto di questa domanda mi è stato ricordato che spesso si verifica il caso in cui non sono sicuro se dovrei usare un "else" o "elif", ad esempio, in uno scenario come quello.

1)

if numA < numB: 
    print('numA is smaller') 
elif numB < numA: 
    print('numB is smaller') 
else: 
    print('both numbers are equal') 

2)

if numA < numB: 
     print('numA is smaller') 
elif numB < numA: 
     print('numB is smaller') 
elif numA == numB: 
     print('both numbers are equal') 

penso che non farebbe una differenza enorme, o mi sbaglio? In altri esempi, la seconda variante potrebbe essere più "robusta" in generale, penso.

+0

Direi che il secondo esempio è "cattivo" - è una forma mite di [Ma ... Tutto può succedere!] (Http://thedailywtf.com/Articles/ButAnything-Can-Happen!.aspx) Ho viste le situazioni in cui i controlli ridondanti [-seeming] causano risultati errati se uno viene aggiornato mentre altri non lo sono. –

+0

Grazie, questo è un bell'articolo. Tuttavia, mi sto solo chiedendo quale sia l'errore, forse sono troppo stanco, ma è il 'else if (a> 10' che è sbagliato, e qualcosa come' a> = 10' dovrebbe essere usato? Dal momento che non sarebbe successo nulla se a == 10? –

+0

Dato l'ordinamento sensato: 'x y', è vero * tranne * quando 'x == y'. Questo rende l'ultima uguaglianza ridondante Consideriamo il caso più semplice di "if a: .. elif! a: ..'; perché scrivere in!! a" invece di molto più chiaro "if a: .. else: ..'?" In quest'ultimo caso con 'else' è molto facile vedere che * almeno un ramo * verrà eseguito, altrimenti dovremo considerare manualmente un'espressione aggiuntiva e quindi * motivo * che rimarrà sempre valida se il precedente non lo ha fatto. –

3

Nel primo caso, Python aggiungerà un esplicito return None alla fine della funzione, anche se possiamo vedere che non è realmente necessario. Nel secondo caso no.

non vedo alcun vantaggio ad avere la else: ci

>>> import dis 
>>> def f(): 
... if 1>2: 
... return 2 
... return 3 
... 
>>> def g(): 
... if 1>2: 
... return 2 
... else: 
... return 3 
... 
>>> dis.dis(f) 
    2   0 LOAD_CONST    1 (1) 
       3 LOAD_CONST    2 (2) 
       6 COMPARE_OP    4 (>) 
       9 POP_JUMP_IF_FALSE  16 

    3   12 LOAD_CONST    2 (2) 
      15 RETURN_VALUE   

    4  >> 16 LOAD_CONST    3 (3) 
      19 RETURN_VALUE   
>>> dis.dis(g) 
    2   0 LOAD_CONST    1 (1) 
       3 LOAD_CONST    2 (2) 
       6 COMPARE_OP    4 (>) 
       9 POP_JUMP_IF_FALSE  16 

    3   12 LOAD_CONST    2 (2) 
      15 RETURN_VALUE   

    5  >> 16 LOAD_CONST    3 (3) 
      19 RETURN_VALUE   
      20 LOAD_CONST    0 (None) 
      23 RETURN_VALUE   
0

Da Chromium's guida di stile:

Non utilizzare altro dopo il ritorno:

# Bad 
if (foo) 
    return 1; 
else 
    return 2; 

# Good 
if (foo) 
    return 1; 
return 2; 

return foo ? 1 : 2; 
Problemi correlati