Python - Restituisce più valori dalla funzione a matrici diverse

Question

Ho una funzione in cui restituisco due valori. Vorrei mettere i due valori direttamente in due diversi array. So come restituire l'output come due valori diversi da aggiungere successivamente all'array, ma non voglio avere i segnaposto temporanei. Un esempio è mostrato sotto.

def two_outputs(): 
    output_one = 5 
    output_two = 6 
    return output_one, output_two 

one_array = []  # initialize array 
two_array = []  # initialize array 

a, b = two_outputs() # get values 

one_array.append(a) # store first value in first array 
two_array.append(b) # store second value in first array 

Idealmente mi piacerebbe non usare aeb e devo aggiungere in un secondo momento nel codice. Vorrei aggiungere l'output della funzione direttamente ai due array. È possibile?

Grazie per qualsiasi aiuto. Spero di averlo fatto correttamente poiché questo è il mio primo post. Voi ragazzi mi avete già aiutato un bel po 'con i problemi di programmazione.

UPDATE: Credo che sulla base delle risposte di seguito che non è possibile farlo direttamente. Grazie per l'aiuto di tutti nella ricerca di altri modi per raggiungere l'obiettivo.

Answer 1

Supponendo che ho capito bene, si avrebbe bisogno di definire le matrici prima della dichiarazione della funzione.

one_array, two_array = [], [] 

def two_outputs(): 
    one_array.append(5) 
    two_array.append(6) 

#call function 
two_outputs() 

print one_array, two_array 
#[5] [6] 

Answer 2

Come utilizzare una funzione di supporto?

def zippend(lists, values): 
    assert len(lists) == len(values) 
    for l,v in zip(lists, values): 
    l.append(v) 

zippend((one_array, two_array), two_outputs()) 

La funzione zippend prende due parametri. Il primo è un iterable di List s (quelli a cui ci si riferisce come "matrici" sono in realtà List s in python). Il secondo è un iterable di valori da aggiungere a tali elenchi.

Si può prendere come molte liste e dei valori che si desidera, a condizione che il numero di liste corrisponde al numero di valori (un valore per l'elenco).

EDIT: Se two_outputs() dovesse restituire una tupla di List s da concatenare sul one_array e two_array, allora si potrebbe cambiare la funzione da utilizzare extend invece di append:

def zextend(lists, values): 
    assert len(lists) == len(values) 
    for l,v in zip(lists, values): 
    l.extend(v) 

Oppure, se si voleva davvero a, è possibile utilizzare una singola funzione con un'istruzione if che ha verificato il tipo di valori che stava ottenendo e append edo extend ed appropriato.

Answer 3

Si può sempre modificare la funzione per restituire una tupla di liste:

def test(): 
    # some code 
    return [a], [b] 

a, b = test() 

che farà entrambe le liste A e B quando sono tornati

Answer 4

può essere fatto in una sola riga con il seguente Generatore. La chiamata a "qualsiasi" è solo in modo che il generatore è consumato, e quindi le espressioni in esso vengono eseguite.

any(lst.append(item) for lst,item in zip((one_array, two_array), two_outputs())) 

NB. Io non raccomandiamo lo stile di programmazione - diventa più difficile da leggere. Probabilmente, se si dove troppo spesso un idioma, mi piacerebbe scrivere una funzione di supporto per breve l'assegnazione del tipo:

def multi_append(lists, multi_function, *args, **kw): 
    for lst, result in zip(lists, multi_function(*args, **kw)): 
     lst.append(result) 

E sul "corpo" del codice, basta scrivere:

multi_append((array_one, array_two), two_outputs) 

Per motivi di completezza, aggiungo un suggerimento che consente di utilizzare l'operatore di assegnazione.

Ciò che è necessario in questo caso, è un oggetto Elenco personalizzato che ha una proprietà che esegue l'aggiunta. La creazione di una classe di questo tipo è di tipo 2, ma in questo caso le liste del codice dovrebbero essere di questa classe:

class MList(list): 
    last = property(lambda s:s[-1], list.append) 

array_one, array_two = MList(), MList() 

array_one.last, array_two.last = two_outputs()