A maneira canônica de retornar vários valores em idiomas que o suportam é geralmente a tupla .

Opção: usando uma tupla

Considere este exemplo trivial:

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

No entanto, isso rapidamente se torna problemático à medida que o número de valores retornados aumenta. E se você quiser retornar quatro ou cinco valores? Claro, você pode continuar os tupleando, mas fica fácil esquecer qual é o valor. Também é muito feio desembalá-los onde você quiser recebê-los.

Opção: usando um dicionário

O próximo passo lógico parece ser a introdução de algum tipo de 'notação de registro'. No Python, a maneira óbvia de fazer isso é por meio de a dict.

Considere o seguinte:

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

(Só para esclarecer, y0, y1 e y2 são apenas identificadores abstratos. Como apontado, na prática, você usaria identificadores significativos.)

Agora, temos um mecanismo pelo qual podemos projetar um membro específico do objeto retornado. Por exemplo,

result['y0']

Opção: usando uma classe

No entanto, há outra opção. Em vez disso, poderíamos retornar uma estrutura especializada. Enquadrei isso no contexto do Python, mas tenho certeza que se aplica a outras linguagens também. De fato, se você estivesse trabalhando em C, essa poderia ser sua única opção. Aqui vai:

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)

No Python, os dois anteriores são talvez muito semelhantes em termos de encanamento - afinal { y0, y1, y2 }acabam sendo entradas no interior __dict__do ReturnValue.

Há um recurso adicional fornecido pelo Python para objetos minúsculos, o __slots__atributo A classe pode ser expressa como:

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

No manual de referência do Python :

A __slots__declaração utiliza uma sequência de variáveis ​​de instância e reserva espaço suficiente em cada instância para armazenar um valor para cada variável. O espaço é salvo porque __dict__não é criado para cada instância.

Opção: usando uma classe de dados (Python 3.7+)

Usando as novas classes de dados do Python 3.7, retorne uma classe com métodos especiais adicionados automaticamente, digitação e outras ferramentas úteis:

@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)

Opção: Usando uma lista

Outra sugestão que eu tinha esquecido vem de Bill, o Lagarto:

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

Este é o meu método menos favorito, no entanto. Suponho que estou contaminado pela exposição a Haskell, mas a ideia de listas de tipos mistos sempre me pareceu desconfortável. Neste exemplo em particular, a lista não é do tipo misto, mas pode ser concebível.

Uma lista usada dessa maneira realmente não ganha nada em relação à tupla, até onde eu sei. A única diferença real entre listas e tuplas no Python é que as listas são mutáveis , enquanto as tuplas não são.

Pessoalmente, tenho a tendência de manter as convenções da programação funcional: use listas para qualquer número de elementos do mesmo tipo e tuplas para um número fixo de elementos de tipos predeterminados.

Questão

Após o preâmbulo longo, vem a pergunta inevitável. Qual método (você acha) é o melhor?

As tuplas nomeadas foram adicionadas no 2.6 para esse fim. Veja também os.stat para um exemplo embutido 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

Nas versões recentes do Python 3 (3.6+, acho), a nova typingbiblioteca fez com que a NamedTupleclasse tornasse as tuplas nomeadas mais fáceis de criar e mais poderosas. Herdar de typing.NamedTuplepermite usar cadeias de documentos, valores padrão e anotações de tipo.

Exemplo (dos documentos):

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

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

Para pequenos projetos, acho mais fácil trabalhar com tuplas. Quando isso fica muito difícil de gerenciar (e não antes), começo a agrupar as coisas em estruturas lógicas, mas acho que o uso sugerido de dicionários e ReturnValueobjetos está errado (ou simplista).

Retornando um dicionário com chaves "y0", "y1", "y2", etc. não oferecem qualquer vantagem sobre tuplas. Retornando uma ReturnValueinstância com propriedades .y0, .y1, .y2, etc. não oferecem qualquer vantagem sobre tuplas também. Você precisa começar a nomear as coisas, se quiser chegar a algum lugar, e pode fazer isso usando tuplas de qualquer maneira:

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

size, type, dimensions = get_image_data(x)

IMHO, a única boa técnica além das tuplas é retornar objetos reais com métodos e propriedades adequados, como você obtém de re.match()ou open(file).

Muitas respostas sugerem que você precisa retornar uma coleção de algum tipo, como um dicionário ou uma lista. Você pode deixar de fora a sintaxe extra e escrever os valores de retorno separados por vírgula. Nota: isso tecnicamente retorna uma tupla.

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

dá:

True
False

Eu voto no dicionário.

Acho que, se eu criar uma função que retorne mais do que 2-3 variáveis, eu as dobrarei em um dicionário. Caso contrário, costumo esquecer a ordem e o conteúdo do que estou retornando.

Além disso, a introdução de uma estrutura 'especial' torna seu código mais difícil de seguir. (Outra pessoa precisará pesquisar o código para descobrir o que é)

Se você estiver preocupado com a pesquisa de tipo, use chaves de dicionário descritivas, por exemplo, 'lista de valores x'.

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

Outra opção seria usar geradores:

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

Embora as tuplas do IMHO sejam geralmente as melhores, exceto nos casos em que os valores retornados são candidatos ao encapsulamento em uma classe.

Eu prefiro usar tuplas sempre que ela parecer "natural"; As coordenadas são um exemplo típico, em que os objetos separados podem ficar por conta própria, por exemplo, em cálculos de escala de um eixo apenas, e a ordem é importante. Nota: se eu puder classificar ou embaralhar os itens sem afetar adversamente o significado do grupo, provavelmente não devo usar uma tupla.

Só uso dicionários como valor de retorno quando os objetos agrupados nem sempre são os mesmos. Pense em cabeçalhos de email opcionais.

Nos demais casos, onde os objetos agrupados têm um significado inerente dentro do grupo ou é necessário um objeto completo com seus próprios métodos, eu uso uma classe.

Eu prefiro:

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

Parece que tudo o resto é apenas código extra para fazer a mesma coisa.

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

Geralmente, a "estrutura especializada" é realmente um estado atual sensível de um objeto, com seus próprios 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

Eu gosto de encontrar nomes para estruturas anônimas sempre que possível. Nomes significativos tornam as coisas mais claras.

As tuplas, dictos e objetos do Python oferecem ao programador uma troca suave entre formalidade e conveniência para pequenas estruturas de dados ("coisas"). Para mim, a escolha de como representar uma coisa é ditada principalmente pelo modo como vou usar a estrutura. No C ++, é uma convenção comum usar structitens somente de dados eclass objetos com métodos, mesmo que você possa legalmente colocar métodos em um struct; meu hábito é semelhante em Python, com dicte tupleno lugar destruct .

Para conjuntos de coordenadas, usarei tupleum ponto em vez de um pontoclass ou um dict(e observe que você pode usar a tuplecomo uma chave de dicionário, portanto, dictsão excelentes matrizes multidimensionais esparsas).

Se vou repetir uma lista de coisas, prefiro descompactar tuple s na iteração:

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

... como a versão do objeto é mais confusa para ler:

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

... e muito menos o dict .

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

Se a coisa é amplamente usada e você se encontra realizando operações não triviais semelhantes em vários locais do código, geralmente vale a pena torná-la um objeto de classe com métodos apropriados.

Por fim, se eu vou trocar dados com componentes de sistema que não sejam Python, na maioria das vezes os manterei em um dictporque é mais adequado à serialização JSON.

+1 na sugestão de S.Lott de uma classe de contêiner nomeada.

Para o Python 2.6 ou superior, uma tupla nomeada fornece uma maneira útil de criar facilmente essas classes de contêineres, e os resultados são "leves e não requerem mais memória que as tuplas regulares".

Em idiomas como Python, eu usaria um dicionário, pois envolve menos sobrecarga do que a criação de uma nova classe.

No entanto, se eu me encontrar constantemente retornando o mesmo conjunto de variáveis, isso provavelmente envolve uma nova classe que eu fatorarei.

Eu usaria um dict para passar e retornar valores de uma função:

Use o formulário variável conforme definido no formulário .

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}

Essa é a maneira mais eficiente para mim e para a unidade de processamento.

Você precisa passar apenas um ponteiro e retornar apenas um ponteiro.

Você não precisa alterar os argumentos das funções (milhares deles) sempre que fizer uma alteração no seu código.

"Melhor" é uma decisão parcialmente subjetiva. Use tuplas para pequenos conjuntos de retorno no caso geral em que um imutável é aceitável. Uma tupla é sempre preferível a uma lista quando a mutabilidade não é um requisito.

Para valores de retorno mais complexos ou para o caso em que a formalidade é valiosa (ou seja, código de alto valor), uma tupla nomeada é melhor. Para o caso mais complexo, um objeto geralmente é o melhor. No entanto, é realmente a situação que importa. Se faz sentido retornar um objeto, porque é isso que você possui naturalmente no final da função (por exemplo, padrão de fábrica), retorne o objeto.

Como o sábio disse:

A otimização prematura é a raiz de todos os males (ou pelo menos a maioria deles) na programação.