La forma canónica de devolver múltiples valores en idiomas que lo admiten es a menudo tupling .

Opción: usar una tupla

Considere este ejemplo trivial:

def f(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return (y0, y1, y2)

Sin embargo, esto rápidamente se vuelve problemático a medida que aumenta el número de valores devueltos. ¿Qué pasa si desea devolver cuatro o cinco valores? Claro, podrías seguir tuplándolos, pero es fácil olvidar qué valor es dónde. También es bastante feo desempacarlos donde quieras recibirlos.

Opción: usar un diccionario

El siguiente paso lógico parece ser introducir algún tipo de 'notación de registro'. En Python, la forma obvia de hacer esto es mediante a dict.

Considera lo siguiente:

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return {'y0': y0, 'y1': y1 ,'y2': y2}

(Para ser claros, y0, y1 e y2 son solo identificadores abstractos. Como se señaló, en la práctica se usarían identificadores significativos).

Ahora, tenemos un mecanismo por el cual podemos proyectar un miembro particular del objeto devuelto. Por ejemplo,

result['y0']

Opción: usar una clase

Sin embargo, hay otra opción. En cambio, podríamos devolver una estructura especializada. Lo he enmarcado en el contexto de Python, pero estoy seguro de que también se aplica a otros lenguajes. De hecho, si estuvieras trabajando en C, esta podría ser tu única opción. Aquí va:

class ReturnValue:
  def __init__(self, y0, y1, y2):
     self.y0 = y0
     self.y1 = y1
     self.y2 = y2

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return ReturnValue(y0, y1, y2)

En Python, los dos anteriores son quizás muy similares en términos de fontanería, después de todo, { y0, y1, y2 }terminan siendo entradas en el interior __dict__del ReturnValue.

Python proporciona una característica adicional para objetos pequeños, el __slots__atributo. La clase podría expresarse como:

class ReturnValue(object):
  __slots__ = ["y0", "y1", "y2"]
  def __init__(self, y0, y1, y2):
     self.y0 = y0
     self.y1 = y1
     self.y2 = y2

Del Manual de referencia de Python :

La __slots__declaración toma una secuencia de variables de instancia y reserva suficiente espacio en cada instancia para mantener un valor para cada variable. Se ahorra espacio porque __dict__no se crea para cada instancia.

Opción: Usar una clase de datos (Python 3.7+)

Usando las nuevas clases de datos de Python 3.7, devuelve una clase con métodos especiales, mecanografía y otras herramientas útiles agregadas automáticamente:

@dataclass
class Returnvalue:
    y0: int
    y1: float
    y3: int

def total_cost(x):
    y0 = x + 1
    y1 = x * 3
    y2 = y0 ** y3
    return ReturnValue(y0, y1, y2)

Opción: usar una lista

Otra sugerencia que había pasado por alto proviene de Bill el Lagarto:

def h(x):
  result = [x + 1]
  result.append(x * 3)
  result.append(y0 ** y3)
  return result

Sin embargo, este es mi método menos favorito. Supongo que estoy contaminado por la exposición a Haskell, pero la idea de listas de tipos mixtos siempre me ha resultado incómoda. En este ejemplo particular, la lista es de tipo no mixto, pero posiblemente podría serlo.

Una lista utilizada de esta manera realmente no gana nada con respecto a la tupla por lo que puedo decir. La única diferencia real entre listas y tuplas en Python es que las listas son mutables , mientras que las tuplas no lo son.

Personalmente, tiendo a transferir las convenciones de la programación funcional: use listas para cualquier número de elementos del mismo tipo y tuplas para un número fijo de elementos de tipos predeterminados.

Pregunta

Después del largo preámbulo, viene la inevitable pregunta. ¿Qué método (crees) es el mejor?

Se agregaron tuplas con nombre en 2.6 para este propósito. También vea os.stat para un ejemplo incorporado similar.

>>> import collections
>>> Point = collections.namedtuple('Point', ['x', 'y'])
>>> p = Point(1, y=2)
>>> p.x, p.y
1 2
>>> p[0], p[1]
1 2

En versiones recientes de Python 3 (3.6+, creo), la nueva typingbiblioteca consiguió que la NamedTupleclase hiciera las tuplas con nombre más fáciles de crear y más poderosas. Heredar de le typing.NamedTuplepermite usar cadenas de documentos, valores predeterminados y anotaciones de tipo.

Ejemplo (de los documentos):

class Employee(NamedTuple):  # inherit from typing.NamedTuple
    name: str
    id: int = 3  # default value

employee = Employee('Guido')
assert employee.id == 3

Para proyectos pequeños, me resulta más fácil trabajar con tuplas. Cuando eso se vuelve demasiado difícil de administrar (y no antes) empiezo a agrupar cosas en estructuras lógicas, sin embargo, creo que su uso sugerido de diccionarios y ReturnValueobjetos es incorrecto (o demasiado simplista).

La devolución de un diccionario con las teclas "y0", "y1", "y2", etc no ofrece ninguna ventaja sobre tuplas. Devolviendo unReturnValue instancia con propiedades .y0, .y1, .y2, etc no ofrece ninguna ventaja sobre tuplas tampoco. Necesitas comenzar a nombrar cosas si quieres llegar a cualquier parte, y puedes hacerlo usando tuplas de todos modos:

def get_image_data(filename):
    [snip]
    return size, (format, version, compression), (width,height)

size, type, dimensions = get_image_data(x)

En mi humilde opinión, la única buena técnica más allá de las tuplas es devolver objetos reales con métodos y propiedades adecuados, como los que obtienes de re.match()o open(file).

Muchas de las respuestas sugieren que necesita devolver una colección de algún tipo, como un diccionario o una lista. Puede omitir la sintaxis adicional y simplemente escribir los valores de retorno, separados por comas. Nota: esto técnicamente devuelve una tupla.

def f():
    return True, False
x, y = f()
print(x)
print(y)

da:

True
False

Yo voto por el diccionario.

Me parece que si hago una función que devuelve más de 2-3 variables, las doblaré en un diccionario. De lo contrario, tiendo a olvidar el orden y el contenido de lo que estoy devolviendo.

Además, la introducción de una estructura 'especial' hace que su código sea más difícil de seguir. (Alguien más tendrá que buscar a través del código para averiguar qué es)

Si le preocupa la búsqueda de tipos, use claves descriptivas del diccionario, por ejemplo, 'lista de valores x'.

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return {'y0':y0, 'y1':y1 ,'y2':y2 }

Otra opción sería usar generadores:

>>> def f(x):
        y0 = x + 1
        yield y0
        yield x * 3
        yield y0 ** 4


>>> a, b, c = f(5)
>>> a
6
>>> b
15
>>> c
1296

Aunque las tuplas de la OMI suelen ser mejores, excepto en los casos en que los valores que se devuelven son candidatos para la encapsulación en una clase.

Prefiero usar tuplas cuando una tupla se siente "natural"; Las coordenadas son un ejemplo típico, donde los objetos separados pueden sostenerse por sí mismos, por ejemplo, en cálculos de escala de un solo eje, y el orden es importante. Nota: si puedo ordenar o barajar los elementos sin un efecto adverso al significado del grupo, entonces probablemente no debería usar una tupla.

Utilizo los diccionarios como valor de retorno solo cuando los objetos agrupados no son siempre iguales. Piensa en encabezados de correo electrónico opcionales.

Para el resto de los casos, donde los objetos agrupados tienen un significado inherente dentro del grupo o se necesita un objeto completo con sus propios métodos, utilizo una clase.

Yo prefiero:

def g(x):
  y0 = x + 1
  y1 = x * 3
  y2 = y0 ** y3
  return {'y0':y0, 'y1':y1 ,'y2':y2 }

Parece que todo lo demás es solo código extra para hacer lo mismo.

>>> def func():
...    return [1,2,3]
...
>>> a,b,c = func()
>>> a
1
>>> b
2
>>> c
3

En general, la "estructura especializada" en realidad ES un estado actual sensible de un objeto, con sus propios métodos.

class Some3SpaceThing(object):
  def __init__(self,x):
    self.g(x)
  def g(self,x):
    self.y0 = x + 1
    self.y1 = x * 3
    self.y2 = y0 ** y3

r = Some3SpaceThing( x )
r.y0
r.y1
r.y2

Me gusta encontrar nombres para estructuras anónimas siempre que sea posible. Los nombres significativos aclaran las cosas.

Las tuplas, los dictados y los objetos de Python le ofrecen al programador una compensación suave entre formalidad y conveniencia para pequeñas estructuras de datos ("cosas"). Para mí, la elección de cómo representar una cosa está dictada principalmente por cómo voy a usar la estructura. En C ++, es una convención común usar structpara elementos solo de datos y classpara objetos con métodos, aunque legalmente puede poner métodos en un struct; mi hábito es similar en Python, con dicty tupleen lugar de struct.

Para conjuntos de coordenadas, usaré un en tuplelugar de un punto classo un dict(y tenga en cuenta que puede usar un tuplecomo clave de diccionario, por lo que dicts hacen grandes conjuntos dispersos multidimensionales).

Si voy a iterar sobre una lista de cosas, prefiero desempaquetar tuples en la iteración:

for score,id,name in scoreAllTheThings():
    if score > goodScoreThreshold:
        print "%6.3f #%6d %s"%(score,id,name)

... ya que la versión del objeto está más abarrotada para leer:

for entry in scoreAllTheThings():
    if entry.score > goodScoreThreshold:
        print "%6.3f #%6d %s"%(entry.score,entry.id,entry.name)

... y mucho menos el dict.

for entry in scoreAllTheThings():
    if entry['score'] > goodScoreThreshold:
        print "%6.3f #%6d %s"%(entry['score'],entry['id'],entry['name'])

Si la cosa se usa ampliamente y te encuentras realizando operaciones similares no triviales en varios lugares del código, entonces generalmente vale la pena convertirlo en un objeto de clase con los métodos adecuados.

Finalmente, si voy a intercambiar datos con componentes del sistema que no son de Python, con mayor frecuencia los guardaré en un dictporque es lo más adecuado para la serialización JSON.

+1 en la sugerencia de S.Lott de una clase de contenedor con nombre.

Para Python 2.6 y versiones posteriores, una tupla con nombre proporciona una forma útil de crear fácilmente estas clases de contenedor, y los resultados son "ligeros y no requieren más memoria que las tuplas normales".

En lenguajes como Python, normalmente usaría un diccionario ya que implica menos sobrecarga que crear una nueva clase.

Sin embargo, si me encuentro constantemente devolviendo el mismo conjunto de variables, entonces eso probablemente implique una nueva clase que factorizaré.

Usaría un dict para pasar y devolver valores de una función:

Use la forma variable como se define en la forma .

form = {
    'level': 0,
    'points': 0,
    'game': {
        'name': ''
    }
}


def test(form):
    form['game']['name'] = 'My game!'
    form['level'] = 2

    return form

>>> print(test(form))
{u'game': {u'name': u'My game!'}, u'points': 0, u'level': 2}

Esta es la forma más eficiente para mí y para la unidad de procesamiento.

Debe pasar solo un puntero y devolver solo un puntero.

No tiene que cambiar los argumentos de las funciones (miles de ellas) cada vez que realiza un cambio en su código.

"Lo mejor" es una decisión parcialmente subjetiva. Use tuplas para pequeños conjuntos de retorno en el caso general donde un inmutable es aceptable. Una tupla siempre es preferible a una lista cuando la mutabilidad no es un requisito.

Para valores de retorno más complejos, o para el caso donde la formalidad es valiosa (es decir, código de alto valor), una tupla nombrada es mejor. Para el caso más complejo, un objeto suele ser el mejor. Sin embargo, es realmente la situación lo que importa. Si tiene sentido devolver un objeto porque eso es lo que tiene naturalmente al final de la función (p. Ej., Patrón de fábrica), devuelva el objeto.

Como dijo el sabio:

La optimización prematura es la raíz de todo mal (o al menos la mayor parte) en la programación.