Tornando Nessuno o una tupla e spacchettamento

Question

io sono sempre infastidito da questo fatto:

$ cat foo.py 
def foo(flag): 
    if flag: 
     return (1,2) 
    else: 
     return None 

first, second = foo(True) 
first, second = foo(False) 

$ python foo.py 
Traceback (most recent call last): 
    File "foo.py", line 8, in <module> 
    first, second = foo(False) 
TypeError: 'NoneType' object is not iterable 

Il fatto è che, al fine di decomprimere correttamente senza problemi che ho sia per prendere il TypeError o per avere qualcosa di simile

values = foo(False) 
if values is not None: 
    first, second = values 

Che è un po 'fastidioso. C'è un trucco per migliorare questa situazione (ad esempio per impostare sia il primo che il secondo su Nessuno senza dover tornare indietro (Nessuno, Nessuno)) o un suggerimento sulla migliore strategia di progettazione per casi come quello che presento? * variabili forse?

Answer 1

Beh, si potrebbe fare ...

first,second = foo(True) or (None,None) 
first,second = foo(False) or (None,None) 

ma per quanto ne so non c'è modo più semplice per espandere Nessuno per riempire la totalità di una tupla.

Answer 2

Non penso che ci sia un trucco. È possibile semplificare il codice chiamante a:

values = foo(False) 
if values: 
    first, second = values 

o anche:

values = foo(False) 
first, second = values or (first_default, second_default) 

dove first_default e second_default sono valori che ci si darà al primo e al secondo come default.

Answer 3

Non vedo cosa c'è di sbagliato nel restituire (Nessuno, Nessuno). È molto più pulito delle soluzioni suggerite qui che implicano molte più modifiche nel codice.

Inoltre, non ha senso che si desideri che None divida automaticamente in 2 variabili.

Answer 4

È necessario prestare attenzione con lo stile x or y di soluzione. Funzionano, ma sono un po 'più ampi delle specifiche originali. In sostanza, cosa succede se foo(True) restituisce una tupla vuota ()? Finché sai che è OK trattarlo come (None, None), stai bene con le soluzioni fornite.

Se questo fosse uno scenario comune, probabilmente sarei scrivere una funzione di utilità come:

# needs a better name! :) 
def to_tup(t): 
    return t if t is not None else (None, None) 

first, second = to_tup(foo(True)) 
first, second = to_tup(foo(False)) 

Answer 5

def foo(flag): 
    return ((1,2) if flag else (None, None)) 

Answer 6

penso che ci sia un problema di astrazione.

Una funzione dovrebbe mantenere un certo livello di astrazione, che aiuta a ridurre la complessità del codice.
In questo caso, la funzione non sta mantenendo l'astrazione corretta, o il chiamante non la rispetta.

La funzione potrebbe essere qualcosa come get_point2d(); in questo caso, il livello dell'astrazione si trova sulla tupla e pertanto restituire None sarebbe un buon modo per segnalare un caso particolare (ad esempio un'entità non esistente). L'errore in questo caso sarebbe di aspettarsi due elementi, mentre in realtà l'unica cosa che sai è che la funzione restituisce un oggetto (con informazioni relative ad un punto 2d).

Ma potrebbe anche essere stato qualcosa come get_two_values_from_db(); in questo caso l'astrazione verrebbe interrotta restituendo None, poiché la funzione (come suggerisce il nome) dovrebbe restituire due valori e non uno!

In entrambi i casi, l'obiettivo principale di utilizzare una funzione, riducendo la complessità, è, almeno in parte, perso.

Si noti che questo problema non appare chiaramente con il nome originale; questo è anche il motivo per cui è sempre importante dare un buon nome alla funzione e ai metodi.

Answer 7

ne dite di questo:

$ cat foo.py 
def foo(flag): 
    if flag: 
     return (1,2) 
    else: 
     return (None,)*2 

first, second = foo(True) 
first, second = foo(False) 

Edit: Giusto per essere chiari, l'unico cambiamento è quello di sostituire return None con return (None,)*2. Sono estremamente sorpreso che nessun altro abbia pensato a questo. (O se lo sono, vorrei sapere perché non l'hanno usato.)

Answer 8

OK, vorrei solo tornare (Nessuno, Nessuno), ma finché siamo in whacko-land (heh), ecco un modo usando una sottoclasse di tuple. Nel caso contrario, non si restituisce None, ma si restituisce invece un contenitore vuoto, che sembra essere nello spirito delle cose. "Iteratore" del contenitore scompatta i valori Nessuno quando vuoto. Dimostra il protocollo iteratore comunque ...

testata utilizzando v2.5.2:

class Tuple(tuple): 
    def __iter__(self): 
     if self: 
      # If Tuple has contents, return normal tuple iterator... 
      return super(Tuple, self).__iter__() 
     else: 
      # Else return a bogus iterator that returns None twice... 
      class Nonerizer(object): 
       def __init__(self): 
        self.x=0 
       def __iter__(self): 
        return self 
       def next(self): 
        if self.x < 2: 
         self.x += 1 
         return None 
        else: 
         raise StopIteration 
      return Nonerizer() 


def foo(flag): 
    if flag: 
     return Tuple((1,2)) 
    else: 
     return Tuple() # It's not None, but it's an empty container. 

first, second = foo(True) 
print first, second 
first, second = foo(False) 
print first, second 

uscita è il desiderato:

1 2 
None None 

Answer 9

ho trovato una soluzione per questo problema:

Return Nessuno o restituire un oggetto.

Tuttavia non si desidera scrivere una classe solo per restituire un oggetto. Per questo, è possibile utilizzare un nome tupla

Ti piace questa:

from collections import namedtuple 
def foo(flag): 
if flag: 
    return None 
else: 
    MyResult = namedtuple('MyResult',['a','b','c'] 
    return MyResult._make([1,2,3]) 

E poi:

result = foo(True) # result = True 
result = foo(False) # result = MyResult(a=1, b=2, c=3) 

e si ha accesso ai risultati come questo:

print result.a # 1 
print result.b # 2 
print result.C# 3