La manière canonique de renvoyer plusieurs valeurs dans les langues qui la prennent en charge est souvent le couplage .

Option: utiliser un tuple

Considérez cet exemple trivial:

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

Cependant, cela devient rapidement problématique à mesure que le nombre de valeurs renvoyées augmente. Et si vous souhaitez renvoyer quatre ou cinq valeurs? Bien sûr, vous pouvez continuer à les multiplier, mais il est facile d'oublier quelle valeur est où. Il est également assez moche de les déballer où vous voulez les recevoir.

Option: utiliser un dictionnaire

La prochaine étape logique semble être d'introduire une sorte de «notation d'enregistrement». En Python, la manière évidente de le faire est au moyen d'un dict.

Considérer ce qui suit:

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

(Pour être clair, y0, y1 et y2 ne sont que des identifiants abstraits. Comme indiqué, en pratique, vous utiliseriez des identifiants significatifs.)

Maintenant, nous avons un mécanisme par lequel nous pouvons projeter un membre particulier de l'objet retourné. Par exemple,

result['y0']

Option: utiliser une classe

Cependant, il existe une autre option. Nous pourrions plutôt retourner une structure spécialisée. J'ai encadré cela dans le contexte de Python, mais je suis sûr que cela s'applique également à d'autres langages. En effet, si vous travailliez en C, cela pourrait très bien être votre seule option. Voici:

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, les deux précédents sont peut-être très similaires en termes de plomberie - après tout, ils { y0, y1, y2 }finissent par être des entrées à l'intérieur __dict__du ReturnValue.

Il y a une fonctionnalité supplémentaire fournie par Python pour les petits objets, l' __slots__attribut. La classe pourrait être exprimée comme suit:

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

Dans le manuel de référence Python :

La __slots__déclaration prend une séquence de variables d'instance et réserve juste assez d'espace dans chaque instance pour contenir une valeur pour chaque variable. L'espace est enregistré car il __dict__n'est pas créé pour chaque instance.

Option: utilisation d'une classe de données (Python 3.7+)

En utilisant les nouvelles classes de données de Python 3.7, renvoyez une classe avec des méthodes spéciales, des saisies et d'autres outils utiles ajoutés automatiquement:

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

Option: utiliser une liste

Une autre suggestion que j'avais ignorée vient de Bill the Lizard:

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

C'est ma méthode la moins préférée. Je suppose que je suis entaché par l'exposition à Haskell, mais l'idée de listes de types mixtes m'a toujours fait mal à l'aise. Dans cet exemple particulier, la liste est de type non-mixte, mais elle pourrait l'être.

Pour autant que je sache, une liste utilisée de cette manière n'a vraiment rien à voir avec le tuple. La seule vraie différence entre les listes et les tuples en Python est que les listes sont mutables , contrairement aux tuples.

Personnellement, j'ai tendance à reprendre les conventions de la programmation fonctionnelle: utiliser des listes pour n'importe quel nombre d'éléments du même type et des tuples pour un nombre fixe d'éléments de types prédéterminés.

Question

Après le long préambule, vient la question inévitable. Quelle méthode (pensez-vous) est la meilleure?

Des tuples nommés ont été ajoutés dans 2.6 à cet effet. Voir également os.stat pour un exemple intégré similaire.

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

Dans les versions récentes de Python 3 (3.6+, je pense), la nouvelle typingbibliothèque a obtenu la NamedTupleclasse pour rendre les tuples nommés plus faciles à créer et plus puissants. L'héritage de typing.NamedTuplevous permet d'utiliser des docstrings, des valeurs par défaut et des annotations de type.

Exemple (extrait des documents):

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

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

Pour les petits projets, je trouve plus facile de travailler avec des tuples. Lorsque cela devient trop difficile à gérer (et pas avant), je commence à regrouper les choses dans des structures logiques, mais je pense que votre utilisation suggérée des dictionnaires et des ReturnValueobjets est incorrecte (ou trop simpliste).

De retour un dictionnaire avec les touches "y0", "y1", "y2", etc. n'offre aucun avantage sur tuples. De retour un ReturnValueexemple avec des propriétés .y0, .y1, .y2, etc. n'offre aucun avantage sur tuples non plus . Vous devez commencer à nommer les choses si vous voulez aller n'importe où, et vous pouvez quand même le faire en utilisant des tuples:

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

size, type, dimensions = get_image_data(x)

À mon humble avis, la seule bonne technique au-delà des tuples est de renvoyer des objets réels avec des méthodes et des propriétés appropriées, comme vous obtenez de re.match()ou open(file).

De nombreuses réponses suggèrent que vous devez renvoyer une collection quelconque, comme un dictionnaire ou une liste. Vous pouvez laisser la syntaxe supplémentaire et simplement écrire les valeurs de retour, séparées par des virgules. Remarque: cela renvoie techniquement un tuple.

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

donne:

True
False

Je vote pour le dictionnaire.

Je trouve que si je crée une fonction qui renvoie plus de 2-3 variables, je les replierai dans un dictionnaire. Sinon, j'ai tendance à oublier l'ordre et le contenu de ce que je retourne.

De plus, l'introduction d'une structure «spéciale» rend votre code plus difficile à suivre. (Quelqu'un d'autre devra chercher dans le code pour savoir de quoi il s'agit)

Si vous êtes préoccupé par le type de recherche, utilisez des clés de dictionnaire descriptives, par exemple, 'liste de valeurs x'.

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

Une autre option serait d'utiliser des générateurs:

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

Bien que les tuples IMHO soient généralement les meilleurs, sauf dans les cas où les valeurs renvoyées sont candidates à l'encapsulation dans une classe.

Je préfère utiliser des tuples chaque fois qu'un tuple semble "naturel"; les coordonnées sont un exemple typique, où les objets séparés peuvent se tenir seuls, par exemple dans des calculs de mise à l'échelle sur un seul axe, et l'ordre est important. Remarque: si je peux trier ou mélanger les éléments sans nuire à la signification du groupe, je ne devrais probablement pas utiliser de tuple.

J'utilise les dictionnaires comme valeur de retour uniquement lorsque les objets groupés ne sont pas toujours les mêmes. Pensez aux en-têtes de courrier électronique facultatifs.

Pour le reste des cas, lorsque les objets groupés ont une signification inhérente à l'intérieur du groupe ou qu'un objet à part entière avec ses propres méthodes est nécessaire, j'utilise une classe.

Je préfère:

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

Il semble que tout le reste ne soit qu'un code supplémentaire pour faire la même chose.

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

Généralement, la "structure spécialisée" EST en fait un état actuel sensible d'un objet, avec ses propres méthodes.

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

J'aime trouver des noms de structures anonymes dans la mesure du possible. Les noms significatifs rendent les choses plus claires.

Les tuples, dict et objets de Python offrent au programmeur un compromis harmonieux entre formalité et commodité pour les petites structures de données («choses»). Pour moi, le choix de la façon de représenter une chose est dicté principalement par la façon dont je vais utiliser la structure. En C ++, c'est une convention courante à utiliser structpour les éléments de données uniquement et classpour les objets avec des méthodes, même si vous pouvez légalement placer des méthodes sur un struct; mon habitude est similaire en Python, avec dictet tupleà la place de struct.

Pour les jeux de coordonnées, j'utiliserai tupleplutôt qu'un point classou un dict(et notez que vous pouvez utiliser un tuplecomme clé de dictionnaire, donc dictfaites de grands tableaux multidimensionnels clairsemés).

Si je vais parcourir une liste de choses, je préfère décompresser les tuples sur l'itération:

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

... car la version de l'objet est plus encombrée à lire:

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

... et encore moins le dict.

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

Si la chose est largement utilisée et que vous vous trouvez à effectuer des opérations similaires non triviales à plusieurs endroits dans le code, il vaut généralement la peine d'en faire un objet de classe avec des méthodes appropriées.

Enfin, si je vais échanger des données avec des composants système non Python, je les garderai le plus souvent dans un dictcar c'est le mieux adapté à la sérialisation JSON.

+1 sur la suggestion de S.Lott d'une classe de conteneur nommée.

Pour Python 2.6 et versions ultérieures, un tuple nommé fournit un moyen utile de créer facilement ces classes de conteneur, et les résultats sont "légers et ne nécessitent pas plus de mémoire que les tuples ordinaires".

Dans des langages comme Python, j'utilisais généralement un dictionnaire car il implique moins de surcharge que la création d'une nouvelle classe.

Cependant, si je me retrouve constamment à renvoyer le même ensemble de variables, cela implique probablement une nouvelle classe que je factoriserai.

J'utiliserais un dict pour passer et renvoyer des valeurs d'une fonction:

Utilisez un formulaire variable tel que défini dans le formulaire .

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}

C'est le moyen le plus efficace pour moi et pour l'unité de traitement.

Vous devez passer un seul pointeur et renvoyer un seul pointeur.

Vous n'avez pas à modifier les arguments des fonctions (des milliers d'entre eux) chaque fois que vous apportez une modification à votre code.

«Meilleur» est une décision partiellement subjective. Utilisez des tuples pour les petits jeux de retour dans le cas général où une immuable est acceptable. Un tuple est toujours préférable à une liste lorsque la mutabilité n'est pas une exigence.

Pour des valeurs de retour plus complexes, ou dans le cas où la formalité est précieuse (c'est-à-dire un code de valeur élevée), un tuple nommé est préférable. Pour le cas le plus complexe, un objet est généralement préférable. Cependant, c'est vraiment la situation qui compte. S'il est judicieux de renvoyer un objet parce que c'est ce que vous avez naturellement à la fin de la fonction (par exemple, motif d'usine), renvoyez l'objet.

Comme l'a dit le sage:

L'optimisation prématurée est la racine de tout mal (ou du moins la plupart) dans la programmation.