Python - devolver múltiples valores de la función a diferentes matrices

Question

Tengo una función en la que estoy devolviendo dos valores. Me gustaría poner los dos valores directamente en dos matrices diferentes. Sé cómo devolver la salida como dos valores diferentes para agregar más tarde a la matriz, pero no quiero tener los marcadores de lugar temporales. Un ejemplo se muestra a continuación.

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, me gustaría no utilizar a y b y tener que agregar más adelante en el código. Me gustaría agregar la salida de la función directamente a las dos matrices. ¿Esto es posible?

Gracias por cualquier ayuda. Espero haber hecho esto correctamente ya que esta es mi primera publicación. Ustedes me han ayudado bastante con problemas de programación.

ACTUALIZACIÓN: Supongo que según las respuestas a continuación no es posible hacerlo directamente. Gracias por la ayuda de todos en encontrar otras formas de lograr el objetivo.

Answer 1

Suponiendo que lo entiendo correctamente, tendrá que definir sus matrices antes de la declaración de la función.

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

¿Qué le parece usar una función de ayuda?

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 función zippend toma dos parámetros. El primero es un iterable de List s (lo que usted se refiere como "arrays" en realidad son List s en python). El segundo es un conjunto de valores que se anexarán a esas listas.

Puede tomar tantas listas y valores como desee, siempre y cuando el número de listas coincida con el número de valores (un valor por lista).

EDIT: Si two_outputs() eran para devolver una tupla de List s que se concatena en one_array y two_array, entonces se podría cambiar la función a utilizar extend en lugar de append:

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

O, si realmente quería para, podría usar una sola función que tenía una instrucción if que verificaba qué tipo de valores obtenía y append ed o extend ed según corresponda.

Answer 3

Siempre se puede alterar su función para devolver una tupla de listas:

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

a, b = test() 

que hará que las dos listas A y B cuando se vuelven

Answer 4

Se puede realizar en una línea con el siguiente generador. La llamada a "cualquiera" es solo para que se consuma el generador y, por lo tanto, se ejecutan las expresiones en él.

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

NB. No me recomend este estilo de programación - se vuelve más difícil de leer. Probablemente, si es demasiado frecuente en un idioma, me gustaría escribir una función de ayuda corto para la asignación como:

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

Y en el "cuerpo" del código, basta con escribir:

multi_append((array_one, array_two), two_outputs) 

Para completar, agrego una sugerencia que le permitiría usar el operador de asignación.

Lo que se necesita en este caso, es un objeto Lista personalizado que tiene una propiedad que realiza el anexar. La creación de dicha clase es un trazador de líneas 2, pero luego, él enumera en su código debería ser de esta clase:

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