Python: Pasando variables entre funciones

He pasado las últimas horas leyendo aquí y en otros lugares, así como experimentando, pero realmente no entiendo lo que estoy seguro de que es un concepto muy básico: pasar valores (como variables) entre diferentes funciones.

Por ejemplo, asigno un montón de valores a una lista en una función, luego quiero usar esa lista en otra función más adelante:

list = [] def defineAList(): list = ['1','2','3'] print "For checking purposes: in defineAList, list is",list return list def useTheList(list): print "For checking purposes: in useTheList, list is",list def main(): defineAList() useTheList(list) main() 

Según mi comprensión de qué función hacen los argumentos, esperaría que esto hiciera lo siguiente:

  1. Inicialice ‘lista’ como una lista vacía; call main (esto, al menos, sé que tengo razón …)
  2. Dentro de defineAList (), asigne ciertos valores a la lista; luego pasa la nueva lista de nuevo a main ()
  3. Dentro de main (), llame a useTheList (lista)
  4. Dado que ‘lista’ está incluida en los parámetros de la función useTheList, esperaría que useTheList ahora use la lista como se define por defineAList (), NO la lista vacía definida antes de llamar a main.

Sin embargo, esto es obviamente una comprensión errónea. Mi salida es:

 For checking purposes: in defineAList, list is ['1', '2', '3'] For checking purposes: in useTheList, list is [] 

Entonces, ya que el “retorno” obviamente no hace lo que creo que hace, o al menos no lo hace como creo que debería … ¿qué hace realmente? ¿Podría por favor mostrarme, usando este ejemplo, qué tendría que hacer para tomar la lista de defineAList () y usarla dentro de useTheList ()? Tiendo a entender mejor las cosas cuando veo que suceden, pero muchos de los ejemplos de pases de argumentos apropiados que he visto también utilizan códigos con los que no estoy familiarizado todavía, y en el proceso de averiguar qué está pasando, Realmente no estoy manejando este concepto. Estoy usando 2.7.

ETA: en el pasado, al hacer una pregunta similar, se sugirió que usara una variable global en lugar de solo locales. Si también será relevante aquí, para los fines de la clase que tomo, no estamos autorizados a usar globales.

¡Gracias!

Esto es lo que realmente está sucediendo:

 global_list = [] def defineAList(): local_list = ['1','2','3'] print "For checking purposes: in defineAList, list is", local_list return local_list def useTheList(passed_list): print "For checking purposes: in useTheList, list is", passed_list def main(): # returned list is ignored returned_list = defineAList() # passed_list inside useTheList is set to global_list useTheList(global_list) main() 

Esto es lo que quieres:

 def defineAList(): local_list = ['1','2','3'] print "For checking purposes: in defineAList, list is", local_list return local_list def useTheList(passed_list): print "For checking purposes: in useTheList, list is", passed_list def main(): # returned list is ignored returned_list = defineAList() # passed_list inside useTheList is set to what is returned from defineAList useTheList(returned_list) main() 

Incluso puede omitir la lista de returned_list temporal y pasar el valor devuelto directamente a useTheList :

 def main(): # passed_list inside useTheList is set to what is returned from defineAList useTheList(defineAList()) 

Sólo te estás perdiendo un paso crítico. Debe pasar explícitamente el valor de retorno a la segunda función.

 def main(): l = defineAList() useTheList(l) 

Alternativamente:

 def main(): useTheList(defineAList()) 

O (¡aunque no deberías hacer esto! Puede parecer agradable al principio, pero los globales solo te causarán dolor a largo plazo):

 l = [] def defineAList(): global l l.extend(['1','2','3']) def main(): global l defineAList() useTheList(l) 

La función devuelve un valor, pero no crea el símbolo en ningún tipo de espacio de nombres global como asume su código. Debe capturar realmente el valor de retorno en el scope de la llamada y luego utilizarlo para las operaciones posteriores.

Tu devolución es inútil si no la asignas.

 list=defineAList() 

Leer el concepto de un espacio de nombres. Cuando asigna una variable en una función, solo la asigna en el espacio de nombres de esta función. Pero claramente quieres usarlo entre todas las funciones.

 def defineAList(): #list = ['1','2','3'] this creates a new list, named list in the current namespace. #same name, different list! list.extend['1', '2', '3', '4'] #this uses a method of the existing list, which is in an outer namespace print "For checking purposes: in defineAList, list is",list return list 

Alternativamente, puedes pasarlo por ahí:

 def main(): new_list = defineAList() useTheList(new_list) 

return devuelve un valor. No importa qué nombre le hayas dado a ese valor. Devolviéndolo simplemente “lo pasa” para que otra cosa pueda usarlo. Si quieres usarlo, tienes que agarrarlo desde afuera:

 lst = defineAList() useTheList(lst) 

Devolver la list desde dentro de defineAList no significa “hacer que todo el rest del progtwig pueda usar esa variable”. Significa “pasa esta variable y da al rest del progtwig la oportunidad de agarrarla y usarla”. Debe asignar ese valor a algo fuera de la función para poder utilizarlo. Además, debido a esto, no es necesario definir su lista de antemano con list = [] . Dentro de defineAList , creas una nueva lista y la devuelves; esta lista no tiene ninguna relación con la que definió con list = [] al principio.

Por cierto, cambié su nombre de variable de la list a lst . No es una buena idea usar la list como nombre de variable porque ya es el nombre de un tipo de Python incorporado. Si crea su propia list variables, no podrá acceder a la incorporada.

Pasar variable de una función como argumento a otras funciones se puede hacer de esta manera

define funciones como esta

 def function1(): global a a=input("Enter any number\t") def function2(argument): print ("this is the entered number - ",argument) 

llama a las funciones como esta

 function1() function2(a)