Ignorar el valor de retorno múltiple de Python

Digamos que tengo una función de Python que devuelve múltiples valores en una tupla:

def func():
    return 1, 2

¿Hay una buena manera de ignorar uno de los resultados en lugar de simplemente asignarlo a una variable temporal? Digamos que si solo me interesara el primer valor, ¿hay una mejor manera que esta?

x, temp = func()

Una convención común es usar una "_" como nombre de variable para los elementos de la tupla que desea ignorar. Por ejemplo:

def f():
    return 1, 2, 3

_, _, x = f()

Puede usar x = func()[0]para devolver el primer valor, x = func()[1]para devolver el segundo, etc.

Si desea obtener múltiples valores a la vez, use algo como x, y = func()[2:4].

Si está usando Python 3, puede usar la estrella antes de una variable (en el lado izquierdo de una tarea) para que sea una lista en el desempaque.

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

Recuerde, cuando devuelve más de un artículo, realmente está devolviendo una tupla. Entonces puedes hacer cosas como esta:

def func():
    return 1, 2

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

La práctica común es usar la variable ficticia _(subrayado simple), como muchos han indicado aquí antes.

Sin embargo, para evitar colisiones con otros usos de ese nombre de variable (vea esta respuesta), podría ser una mejor práctica usar __(doble guión bajo) como una variable desechable, como lo señala ncoghlan . P.ej:

x, __ = func()

Tres elecciones simples.

Obvio

x, _ = func()

x, junk = func()

Horrible

x = func()[0]

Y hay formas de hacer esto con un decorador.

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

func0= val0(func)

La mejor solución probablemente sea nombrar cosas en lugar de devolver tuplas sin sentido. A menos que haya alguna lógica detrás del orden de los artículos devueltos.

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

latitude = func()['lat']

Incluso podría usar namedtuple si desea agregar información adicional sobre lo que está devolviendo (no es solo un diccionario, estas son coordenadas):

from collections import namedtuple 

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

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

latitude = func().lat

Si los objetos dentro de su diccionario / tupla están fuertemente unidos, entonces puede ser una buena idea incluso definir una clase para ello. De esa manera, también podrá definir la interacción entre objetos de este tipo y ofrecer una API sobre cómo trabajar con ellos. Una pregunta natural que sigue: ¿ Cuándo debería usar clases en Python? .

Esta me parece la mejor opción:

val1, val2, ignored1, ignored2 = some_function()

No es críptico ni feo (como el método func () [index]), y establece claramente su propósito.

Esta no es una respuesta directa a la pregunta. Más bien responde a esta pregunta: "¿Cómo elijo una salida de función específica de muchas opciones posibles?".

Si puede escribir la función (es decir, no está en una biblioteca que no puede modificar), agregue un argumento de entrada que indique lo que desea de la función. Conviértalo en un argumento con nombre con un valor predeterminado para que en el "caso común" ni siquiera tenga que especificarlo.

    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 )

Este método le da a la función "advertencia avanzada" con respecto a la salida deseada. En consecuencia, puede omitir el procesamiento innecesario y solo hacer el trabajo necesario para obtener el resultado deseado. Además, debido a que Python hace tipeo dinámico, el tipo de retorno puede cambiar. Observe cómo el ejemplo devuelve un escalar, una lista o una tupla ... ¡lo que quiera!

Si esta es una función que usa todo el tiempo pero siempre descarta el segundo argumento, diría que es menos complicado crear un alias para la función sin usar el segundo valor de retorno lambda.

def func():
    return 1, 2

func_ = lambda: func()[0] 

func_()  # Prints 1 

Cuando tiene muchos resultados de una función y no desea llamarla varias veces, creo que la forma más clara de seleccionar los resultados sería:

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

Como ejemplo de trabajo mínimo, también demuestra que la función se llama solo una vez:

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

Y los valores son los esperados:

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

Por conveniencia, los índices de lista de Python también se pueden usar:

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

Devuelve: a = 3 yb = 12