Ignorer la valeur de retour multiple python

Disons que j'ai une fonction Python qui renvoie plusieurs valeurs dans un tuple:

def func():
    return 1, 2

Existe-t-il un bon moyen d'ignorer l'un des résultats plutôt que de simplement l'affecter à une variable temporaire? Dites si je n'étais intéressé que par la première valeur, y a-t-il un meilleur moyen que celui-ci:

x, temp = func()

Une convention courante consiste à utiliser un "_" comme nom de variable pour les éléments du tuple que vous souhaitez ignorer. Par exemple:

def f():
    return 1, 2, 3

_, _, x = f()

Vous pouvez utiliser x = func()[0]pour renvoyer la première valeur, x = func()[1]pour renvoyer la seconde, etc.

Si vous souhaitez obtenir plusieurs valeurs à la fois, utilisez quelque chose comme x, y = func()[2:4].

Si vous utilisez Python 3, vous pouvez utiliser l'étoile devant une variable (sur le côté gauche d'une affectation) pour qu'elle soit une liste dans le déballage.

# Example 1: a is 1 and b is [2, 3]

a, *b = [1, 2, 3]

# Example 2: a is 1, b is [2, 3], and c is 4

a, *b, c = [1, 2, 3, 4]

# Example 3: b is [1, 2] and c is 3

*b, c = [1, 2, 3]       

# Example 4: a is 1 and b is []

a, *b = [1]

N'oubliez pas que lorsque vous retournez plusieurs articles, vous retournez vraiment un tuple. Vous pouvez donc faire des choses comme ça:

def func():
    return 1, 2

print func()[0] # prints 1
print func()[1] # prints 2

La pratique courante consiste à utiliser la variable fictive _(soulignement simple), comme beaucoup l'ont indiqué précédemment.

Cependant, pour éviter les collisions avec d'autres utilisations de ce nom de variable (voir cette réponse), il pourrait être préférable d'utiliser __(double soulignement) à la place comme variable jetable , comme indiqué par ncoghlan . Par exemple:

x, __ = func()

Trois choix simples.

Évident

x, _ = func()

x, junk = func()

Hideux

x = func()[0]

Et il existe des moyens de le faire avec un décorateur.

def val0( aFunc ):
    def pick0( *args, **kw ):
        return aFunc(*args,**kw)[0]
    return pick0

func0= val0(func)

La meilleure solution est probablement de nommer les choses au lieu de renvoyer des tuples sans signification. Sauf s'il y a une certaine logique derrière l'ordre des articles retournés.

def func():
    return {'lat': 1, 'lng': 2}

latitude = func()['lat']

Vous pouvez même utiliser namedtuple si vous souhaitez ajouter des informations supplémentaires sur ce que vous retournez (ce n'est pas seulement un dictionnaire, ce sont des coordonnées):

from collections import namedtuple 

Coordinates = namedtuple('Coordinates', ['lat', 'lng'])

def func():
    return Coordinates(lat=1, lng=2)

latitude = func().lat

Si les objets de votre dictionnaire / tuple sont fortement liés, il peut être judicieux de même définir une classe pour lui. De cette façon, vous pourrez également définir l'interaction entre des objets de ce type et donner une API sur la façon de travailler avec eux. Une question naturelle qui suit: Quand devrais-je utiliser des classes en Python? .

Cela me semble être le meilleur choix:

val1, val2, ignored1, ignored2 = some_function()

Ce n'est pas cryptique ou laid (comme la méthode func () [index]), et indique clairement votre objectif.

Ce n'est pas une réponse directe à la question. Il répond plutôt à cette question: "Comment choisir une sortie de fonction spécifique parmi de nombreuses options possibles?".

Si vous pouvez écrire la fonction (c'est-à-dire qu'elle ne se trouve pas dans une bibliothèque que vous ne pouvez pas modifier), ajoutez un argument d'entrée qui indique ce que vous voulez retirer de la fonction. Faites-en un argument nommé avec une valeur par défaut afin que dans le "cas commun" vous n'ayez même pas à le spécifier.

    def fancy_function( arg1, arg2, return_type=1 ):
        ret_val = None
        if( 1 == return_type ):
            ret_val = arg1 + arg2
        elif( 2 == return_type ):
            ret_val = [ arg1, arg2, arg1 * arg2 ]
        else:
            ret_val = ( arg1, arg2, arg1 + arg2, arg1 * arg2 ) 
        return( ret_val )

Cette méthode donne la fonction "avertissement avancé" concernant la sortie souhaitée. Par conséquent, il peut ignorer le traitement inutile et ne faire que le travail nécessaire pour obtenir la sortie souhaitée. De plus, parce que Python effectue une frappe dynamique, le type de retour peut changer. Remarquez comment l'exemple retourne un scalaire, une liste ou un tuple ... tout ce que vous aimez!

S'il s'agit d'une fonction que vous utilisez tout le temps mais que vous rejetez toujours le deuxième argument, je dirais qu'il est moins compliqué de créer un alias pour la fonction sans la deuxième valeur de retour à l'aide lambda.

def func():
    return 1, 2

func_ = lambda: func()[0] 

func_()  # Prints 1 

Lorsque vous avez plusieurs sorties d'une fonction et que vous ne voulez pas l'appeler plusieurs fois, je pense que la manière la plus claire de sélectionner les résultats serait:

results = fct()
a,b = [results[i] for i in list_of_index]

Comme exemple de travail minimum, démontrant également que la fonction n'est appelée qu'une seule fois:

def fct(a):
    b=a*2
    c=a+2
    d=a+b
    e=b*2
    f=a*a
    print("fct called")
    return[a,b,c,d,e,f]

results=fct(3)
> fct called

x,y = [results[i] for i in [1,4]]

Et les valeurs sont comme prévu:

results
> [3,6,5,9,12,9]
x
> 6
y
> 12

Pour plus de commodité, les index de liste Python peuvent également être utilisés:

x,y = [results[i] for i in [0,-2]]

Renvoie: a = 3 et b = 12