Volviendo Ninguno o una tupla y desembalaje

Question

siempre estoy molesto por este hecho:

$ 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 

El hecho es que con el fin de descomprimir correctamente sin dificultad que tengo ya sea para coger el TypeError o tener algo como

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

Que es un poco molesto. ¿Hay algún truco para mejorar esta situación (por ejemplo, establecer primero y segundo a Ninguno sin tener que devolver foo (Ninguno, Ninguno)) o una sugerencia sobre la mejor estrategia de diseño para casos como el que presento? * variables tal vez?

Answer 1

Bueno, usted podría hacer ...

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

pero por lo que yo sé no hay manera más fácil de ampliar Ninguno de llenar la totalidad de una tupla.

Answer 2

No creo que haya un truco. Se puede simplificar el código de llamada a:

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

o incluso:

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

donde first_default y second_default son valores que desea dar al primer y segundo como valores por defecto.

Answer 3

No veo cuál es el problema al regresar (Ninguno, Ninguno). Es mucho más limpio que las soluciones sugeridas aquí que implican muchos más cambios en su código.

Tampoco tiene sentido que desee que None se divida automágicamente en 2 variables.

Answer 4

Debe tener cuidado con el estilo de solución x or y. Funcionan, pero son un poco más amplios que las especificaciones originales. Básicamente, ¿qué pasa si foo(True) devuelve una tupla vacía ()? Siempre que sepa que está bien tratarlo como (None, None), está de acuerdo con las soluciones proporcionadas.

Si esto fuera un escenario común, probablemente volvería a escribir una función de utilidad como:

# 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

Creo que hay un problema de la abstracción .

Una función debe mantener cierto nivel de abstracción, lo que ayuda a reducir la complejidad del código.
En este caso, o bien la función no mantiene la abstracción correcta, o bien la persona que llama no la está respetando.

La función podría haber sido algo así como get_point2d(); en este caso, el nivel de la abstracción está en la tupla y, por lo tanto, devolver None sería una buena manera de señalar algún caso particular (por ejemplo, una entidad no existente). El error en este caso sería esperar dos elementos, mientras que en realidad lo único que sabe es que la función devuelve un objeto (con información relacionada con un punto 2d).

Pero también podría haber sido algo así como get_two_values_from_db(); en este caso, la abstracción se rompería al devolver Ninguno, porque la función (como su nombre lo sugiere) debe devolver dos valores y no uno!

De cualquier forma, el objetivo principal de usar una función, reducir la complejidad, se pierde, al menos parcialmente.

Tenga en cuenta que este problema no aparece claramente con el nombre original; Es por eso que siempre es importante dar buenos nombres a la función y los métodos.

Answer 7

¿Qué tal esto:

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

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

Editar: Para que quede claro, el único cambio es reemplazar return None con return (None,)*2. Estoy extremadamente sorprendido de que nadie más haya pensado en esto. (O si lo han hecho, me gustaría saber por qué no lo usaron).

Answer 8

OK, me gustaría volver (Ninguno, Ninguno), pero mientras estemos en whacko-land (heh), aquí hay una forma de usar una subclase de tupla. En el caso else, no devuelve None, sino que devuelve un contenedor vacío, que parece estar en el espíritu de las cosas. El "iterador" del contenedor desempaqueta ninguno cuando está vacío. Demuestra el protocolo de iteración de todos modos ...

probada usando 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 

salida es la deseada:

1 2 
None None 

Answer 9

he encontrado una solución para este problema:

Retorno Ninguno o devuelve un objeto.

Sin embargo, no desea tener que escribir una clase solo para devolver un objeto. Para ello, puede utilizar una tupla llamado

De esta manera:

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

Y luego:

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

y tiene acceso a los resultados como este:

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