return, return None e nessun ritorno a tutti?

Considera tre funzioni:

def my_func1():
  print "Hello World"
  return None

def my_func2():
  print "Hello World"
  return

def my_func3():
  print "Hello World"

Sembrano tutti restituire Nessuno. Ci sono differenze tra il comportamento del valore restituito di queste funzioni? Ci sono dei motivi per preferire l'uno rispetto all'altro?

Sul comportamento reale, non c'è differenza. Tornano tutti Nonee basta. Tuttavia, c'è un tempo e un luogo per tutti questi. Le seguenti istruzioni sono fondamentalmente come dovrebbero essere usati i diversi metodi (o almeno come mi è stato insegnato che dovrebbero essere usati), ma non sono regole assolute, quindi puoi mescolarli se ti senti necessario.

utilizzando return None

Questo dice che la funzione è effettivamente destinata a restituire un valore per un uso successivo, e in questo caso restituisce None. Questo valore Nonepuò quindi essere utilizzato altrove. return Nonenon viene mai utilizzato se non ci sono altri valori di ritorno possibili dalla funzione.

Nel seguente esempio, torniamo person's motherse la persondata è un essere umano. Se non è un essere umano, torniamo Nonedal momento personche non ha un mother(supponiamo che non sia un animale o qualcosa del genere).

def get_mother(person):
    if is_human(person):
        return person.mother
    else:
        return None

utilizzando return

Questo è usato per lo stesso motivo dei breakloop. Il valore restituito non ha importanza e vuoi solo uscire dall'intera funzione. È estremamente utile in alcuni luoghi, anche se non ne hai bisogno così spesso.

prisonersNe abbiamo 15 e sappiamo che uno di loro ha un coltello. Esaminiamo ciascuno prisonerper uno per verificare se hanno un coltello. Se colpiamo la persona con un coltello, possiamo semplicemente uscire dalla funzione perché sappiamo che c'è solo un coltello e nessun motivo per il resto prisoners. Se non lo troviamo prisonercon un coltello, lanciamo un avviso. Questo potrebbe essere fatto in molti modi diversi e l'utilizzo returnprobabilmente non è nemmeno il modo migliore, ma è solo un esempio per mostrare come usare returnper uscire da una funzione.

def find_prisoner_with_knife(prisoners):
    for prisoner in prisoners:
        if "knife" in prisoner.items:
            prisoner.move_to_inquisition()
            return # no need to check rest of the prisoners nor raise an alert
    raise_alert()

Nota: non dovresti mai farlo var = find_prisoner_with_knife(), poiché il valore restituito non è pensato per essere catturato.

Non usare returnaffatto

Anche questo restituirà None, ma quel valore non è pensato per essere usato o catturato. Significa semplicemente che la funzione è terminata correttamente. E 'fondamentalmente lo stesso come returnin voidfunzioni in linguaggi come C ++ o Java.

Nel seguente esempio, impostiamo il nome della madre della persona e quindi la funzione termina dopo il completamento con esito positivo.

def set_mother(person, mother):
    if is_human(person):
        person.mother = mother

Nota: non dovresti mai farlo var = set_mother(my_person, my_mother), poiché il valore restituito non è pensato per essere catturato.

Sì, sono tutti uguali.

Possiamo rivedere il codice macchina interpretato per confermare che stanno facendo esattamente la stessa cosa.

import dis

def f1():
  print "Hello World"
  return None

def f2():
  print "Hello World"
  return

def f3():
  print "Hello World"

dis.dis(f1)
    4   0 LOAD_CONST    1 ('Hello World')
        3 PRINT_ITEM
        4 PRINT_NEWLINE

    5   5 LOAD_CONST    0 (None)
        8 RETURN_VALUE

dis.dis(f2)
    9   0 LOAD_CONST    1 ('Hello World')
        3 PRINT_ITEM
        4 PRINT_NEWLINE

    10  5 LOAD_CONST    0 (None)
        8 RETURN_VALUE

dis.dis(f3)
    14  0 LOAD_CONST    1 ('Hello World')
        3 PRINT_ITEM
        4 PRINT_NEWLINE            
        5 LOAD_CONST    0 (None)
        8 RETURN_VALUE      

Ognuno di essi restituisce lo stesso singleton None- Non c'è differenza funzionale.

Penso che sia ragionevolmente idiomatico tralasciare l' returnaffermazione a meno che non sia necessario che esca anticipatamente dalla funzione (nel qual caso un nudo returnè più comune) o restituisce qualcosa di diverso None. Ha anche senso e sembra essere idiomatico scrivere return Nonequando è in una funzione che ha un altro percorso che restituisce qualcosa di diverso None. Scrivere return Noneesplicitamente è un segnale visivo per il lettore che esiste un altro ramo che restituisce qualcosa di più interessante (e che probabilmente il codice chiamante dovrà gestire entrambi i tipi di valori restituiti).

Spesso in Python, le funzioni che restituiscono Nonesono usate come le voidfunzioni in C - Il loro scopo è generalmente quello di operare sugli argomenti di input in atto (a meno che non si utilizzino dati globali ( shudder )). Il ritorno di Nonesolito rende più esplicito che gli argomenti sono stati mutati. Ciò rende un po 'più chiaro il motivo per cui ha senso lasciare la returnfrase dal punto di vista delle "convenzioni linguistiche".

Detto questo, se stai lavorando in una base di codice che ha già convenzioni preimpostate su queste cose, seguirò sicuramente l'esempio per aiutare la base di codice a rimanere uniforme ...

Come altri hanno risposto, il risultato è esattamente lo stesso, Noneviene restituito in tutti i casi.

La differenza è stilistica, ma tieni presente che PEP8 richiede che l'uso sia coerente:

Sii coerente nelle dichiarazioni di reso. O tutte le istruzioni di ritorno in una funzione dovrebbero restituire un'espressione o nessuna di esse dovrebbe. Se una dichiarazione di ritorno restituisce un'espressione, tutte le dichiarazioni di ritorno in cui non viene restituito alcun valore devono dichiararlo esplicitamente come ritorno Nessuno e una dichiarazione di ritorno esplicita deve essere presente alla fine della funzione (se raggiungibile).

Sì:

def foo(x):
    if x >= 0:
        return math.sqrt(x)
    else:
        return None

def bar(x):
    if x < 0:
        return None
    return math.sqrt(x)

No:

def foo(x):
    if x >= 0:
        return math.sqrt(x)

def bar(x):
    if x < 0:
        return
    return math.sqrt(x)

https://www.python.org/dev/peps/pep-0008/#programming-recommendations

Fondamentalmente, se mai si restituisce un Nonevalore non valido in una funzione, significa che il valore restituito ha un significato e deve essere intercettato dai chiamanti. Quindi quando ritorni None, deve anche essere esplicito, trasmettere Nonein questo caso ha un significato, è uno dei possibili valori di ritorno.

Se non hai bisogno di tornare, la funzione funziona sostanzialmente come una procedura anziché come una funzione, quindi non includere l' returnistruzione.

Se stai scrivendo una funzione simile a una procedura e c'è un'opportunità per tornare prima (cioè hai già finito a quel punto e non hai bisogno di eseguire il resto della funzione) puoi usare una returns vuota per segnalare al lettore è solo una finitura anticipata dell'esecuzione e il Nonevalore restituito implicitamente non ha alcun significato e non è destinato a essere intercettato (la funzione simile a una procedura restituisce sempre Nonecomunque).

In termini di funzionalità questi sono tutti uguali, la differenza tra loro è nella leggibilità del codice e nello stile (che è importante considerare)