Ignorer la valeur de retour multiple python

Question

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

def func():
    return 1, 2

Y a-t-il un bon moyen d'ignorer l'un des résultats plutôt que d'assigner à une variable temporaire? Dites si la première valeur ne m'intéresse que vous, y a-t-il un meilleur moyen que celui-ci:

x, temp = func()

Answer 1

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

Answer 2

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

Answer 3

Si vous utilisez Python 3, vous pouvez utiliser l'étoile avant une variable (située à gauche d'une affectation) pour en faire une liste lors de la décompression.

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

Answer 4

N'oubliez pas que lorsque vous retournez plusieurs éléments, vous renvoyez réellement un tuple. Donc, vous pouvez faire des choses comme ça:

def func():
    return 1, 2

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

Answer 5

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

Toutefois, pour éviter les conflits avec d'autres utilisations de ce nom de variable (voir la réponse ), il peut s'agir d'une meilleure pratique. d'utiliser __ (double trait de soulignement) à la place en tant que variable jetable, comme indiqué par ncoghlan . Exemple:

x, __ = func()

Answer 6

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)

Answer 7

Cela me semble être le meilleur choix:

val1, val2, ignored1, ignored2 = some_function()

Ce n'est pas cryptique ni moche (comme la méthode func () [index]), et indique clairement votre but.

Answer 8

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 êtes capable d’é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 en entrée qui indique ce que vous voulez extraire de la fonction. Faites-en un argument nommé avec une valeur par défaut donc dans le " cas commun " vous n'avez 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é". en ce qui concerne la sortie souhaitée. Par conséquent, il peut ignorer les traitements inutiles et ne faire que le travail nécessaire pour obtenir le résultat souhaité. De plus, étant donné que Python effectue le typage dynamique, le type de retour peut changer. Remarquez comment l'exemple renvoie un scalaire, une liste ou un tuple ... comme vous le souhaitez!

Answer 9

La meilleure solution est probablement de nommer les choses au lieu de renvoyer des tuples vides de sens. 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']
print(latitude)

Vous pouvez même utiliser namedtuple si vous souhaitez ajouter des informations supplémentaires sur ce que vous retournez:

from collections import namedtuple 
Coordinates = namedtuple('Coordinates', ['lat', 'lng'])

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

latitude = func().lat
print(latitude)

Si les éléments que vous retournez sont souvent ensemble, il peut être judicieux de définir une classe.

Answer 10

S'il s'agit d'une fonction que vous utilisez tout le temps mais que vous jetez 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 renvoyée à l'aide de lambda .

def func():
    return 1, 2

func_ = lambda: func()[0] 

func_()  # Prints 1 

Answer 11

Lorsque vous avez plusieurs sorties d'une fonction et que vous ne voulez pas l'appeler plusieurs fois, je pense que le moyen le plus simple 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 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

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

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

Retourne: a = 3 et b = 12