Ignora il valore di ritorno multiplo di Python

Question

Dire che ho una funzione Python che restituisce più valori in una tupla:

def func():
    return 1, 2

C'è un buon modo per ignorare uno dei risultati piuttosto che assegnarlo a una variabile temporanea? Di 'che se fossi interessato solo al primo valore, c'è un modo migliore di questo:

x, temp = func()

Answer 1

Una convenzione comune è di usare un " _ " come nome variabile per gli elementi della tupla che si desidera ignorare. Ad esempio:

def f():
    return 1, 2, 3

_, _, x = f()

Answer 2

Puoi usare x = func () [0] per restituire il primo valore, x = func () [1] per restituire il secondo, e così via .

Se vuoi ottenere più valori contemporaneamente, usa qualcosa come x, y = func () [2: 4] .

Answer 3

Se stai usando Python 3, puoi usare la stella prima di una variabile (sul lato sinistro di un compito) per avere una lista in decompressione.

# 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

Ricorda, quando restituisci più di un oggetto, stai davvero restituendo una tupla. Quindi puoi fare cose del genere:

def func():
    return 1, 2

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

Answer 5

La pratica comune è quella di utilizzare la variabile fittizia _ (carattere di sottolineatura singolo), come molti hanno indicato qui prima.

Tuttavia, per evitare collisioni con altri usi di quel nome di variabile (vedi questa risposta) potrebbe essere una pratica migliore utilizzare __ (doppio trattino basso) invece come variabile usa e getta, come indicato da ncoghlan . Per esempio:.

x, __ = func()

Answer 6

Tre semplici scelte.

Ovvio

x, _ = func()

x, junk = func()

Hideous

x = func()[0]

E ci sono modi per farlo con un decoratore.

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

func0= val0(func)

Answer 7

Questa mi sembra la scelta migliore:

val1, val2, ignored1, ignored2 = some_function()

Non è criptico o brutto (come il metodo func () [indice]), e afferma chiaramente il tuo scopo.

Answer 8

Questa non è una risposta diretta alla domanda. Piuttosto risponde a questa domanda: " Come faccio a scegliere un output di funzione specifica da molte opzioni possibili? & Quot ;.

Se sei in grado di scrivere la funzione (cioè, non è in una libreria che non puoi modificare), allora aggiungi un argomento di input che indica ciò che vuoi fuori dalla funzione. Renderlo un argomento denominato con un valore predefinito, quindi nel "caso comune" non è nemmeno necessario specificarlo.

    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 )

Questo metodo fornisce la funzione "avviso avanzato" per quanto riguarda l'uscita desiderata. Di conseguenza può saltare l'elaborazione non necessaria e fare solo il lavoro necessario per ottenere l'output desiderato. Anche perché Python esegue la digitazione dinamica, il tipo restituito può cambiare. Nota come l'esempio restituisce uno scalare, un elenco o una tupla ... qualunque cosa ti piaccia!

Answer 9

Probabilmente la soluzione migliore è nominare le cose invece di restituire tuple insignificanti. A meno che non ci sia della logica dietro l'ordine degli articoli restituiti.

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

latitude = func()['lat']
print(latitude)

Potresti persino usare namedtuple se desideri aggiungere ulteriori informazioni su ciò che stai restituendo:

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

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

latitude = func().lat
print(latitude)

Se le cose che ritorni sono spesso insieme, potrebbe essere una buona idea persino definire una classe per essa.

Answer 10

Se questa è una funzione che usi sempre ma scarti sempre il secondo argomento, direi che è meno complicato creare un alias per la funzione senza il secondo valore di ritorno usando lambda .

def func():
    return 1, 2

func_ = lambda: func()[0] 

func_()  # Prints 1 

Answer 11

Quando hai molti output da una funzione e non vuoi chiamarla più volte, penso che il modo più chiaro per selezionare i risultati sarebbe:

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

Come esempio minimo di lavoro, dimostra anche che la funzione viene chiamata una sola volta:

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

E i valori sono come previsto:

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

Per comodità, è possibile utilizzare anche gli indici dell'elenco Python:

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

Restituisce: a = 3 eb = 12