Python: passer des variables entre les fonctions
J'ai passé ces dernières heures à lire ici et ailleurs, ainsi qu'à expérimenter, mais je ne comprends pas vraiment ce que je suis sûr est un concept très basique: passer des valeurs (en tant que variables) entre différentes fonctions.
Par exemple, j'attribue tout un tas de valeurs à une liste dans une fonction, puis je veux utiliser cette liste dans une autre fonction plus tard:
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()
Sur la base de ma compréhension de ce que font les arguments de fonction, je m'attendrais à ce que cela fasse comme suit:
- initialisez 'list' comme une liste vide; appelez main (ceci, au moins, je sais que j'ai raison...)
- dans defineAList(), assignez certaines valeurs dans la liste; puis renvoyez la nouvelle liste dans main ()
- dans main(), appelez useTheList (list)
- puisque 'list' est inclus dans les paramètres de la fonction useTheList, je m'attendrais à ce que useTheList utilise maintenant la liste telle que définie par defineAList (), pas la liste vide définie avant d'appeler principal.
Cependant, c'est évidemment une mauvaise compréhension. Ma sortie est:
For checking purposes: in defineAList, list is ['1', '2', '3']
For checking purposes: in useTheList, list is []
Donc, puisque "return" ne fait évidemment pas ce que je pense qu'il fait, ou du moins il ne le fait pas comme je pense qu'il devrait... que faut-il réellement faire? Pourriez-vous me montrer, en utilisant cet exemple, ce que je devrais faire pour prendre la liste de defineAList () et l'utiliser dans useTheList ()? J'ai tendance à mieux comprendre les choses quand je les vois se produire, mais beaucoup d'exemples de bonnes argument-passing j'ai vu aussi utiliser du code que je ne connais pas encore, et dans le processus de comprendre ce qui se passe, Je ne reçois pas vraiment une poignée sur ce concept. Je suis en utilisant 2.7.
ETA-dans le passé, en posant une question similaire, il a été suggéré que j'utilise une variable globale au lieu de seulement des locaux. Si cela sera pertinent ici aussi - pour les besoins de la classe que je prends, nous ne sommes pas autorisés à utiliser globals.
Merci!
6 réponses
C'est Ce qui se passe réellement:
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()
C'est ce que vous voulez:
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()
, Vous pouvez même sauter temporaire returned_list et passer la valeur renvoyée directement à useTheList:
def main():
# passed_list inside useTheList is set to what is returned from defineAList
useTheList(defineAList())
Vous manquez juste une étape critique. Vous devez passer explicitement la valeur de retour à la deuxième fonction.
def main():
l = defineAList()
useTheList(l)
Alternativement:
def main():
useTheList(defineAList())
Ou (bien que vous ne devriez pas faire cela! Cela peut sembler agréable au début, mais les globals vous causent juste du chagrin à long terme.):
l = []
def defineAList():
global l
l.extend(['1','2','3'])
def main():
global l
defineAList()
useTheList(l)
La fonction renvoie une valeur, mais elle ne crée pas le symbole dans un espace de noms global comme le suppose votre code. Vous devez réellement capturer la valeur de retour dans la portée appelante, puis utilisez - le pour les opérations ultérieures.
Votre retour est inutile si vous ne l'attribuez pas
list=defineAList()
Lisez le concept d'un espace de nom. Lorsque vous affectez une variable dans une fonction, vous ne pouvez affecter dans l'espace de noms de cette fonction. Mais clairement, vous voulez l'utiliser entre toutes les fonctions.
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
Alternativement, vous pouvez le faire circuler:
def main():
new_list = defineAList()
useTheList(new_list)
return renvoie une valeur. Peu importe le nom que vous avez donné à cette valeur. Le retourner "le transmet" juste pour que quelque chose d'autre puisse l'utiliser. Si vous voulez l'utiliser, vous devez saisir de l'extérieur:
lst = defineAList()
useTheList(lst)
Retourner list de l'intérieur {[3] }ne signifie pas "faire en sorte que tout le reste du programme puisse utiliser cette variable". Cela signifie "passer cette variable et donner au reste du programme une chance de l'attraper et de l'utiliser". Vous devez attribuer cette valeur à quelque chose à l'extérieur la fonction, dans le but d'en faire usage. Aussi, pour cette raison, il n'est pas nécessaire pour définir votre liste à l'avance avec list = []. À l'intérieur de defineAList, vous créez une nouvelle liste et la renvoyez; cette liste n'a aucune relation avec celle que vous avez définie avec list = [] Au début.
Incidemment, j'ai changé le nom de votre variable de list à lst. Ce n'est pas une bonne idée d'utiliser list comme nom de variable car c'est déjà le nom d'un type Python intégré. Si vous créez votre propre variable appelée list, vous ne pourrez plus accéder à celui intégré.
Passer une variable d'une fonction comme argument à d'autres fonctions peut être fait comme ceci
Définir des fonctions comme ceci
def function1(): global a a=input("Enter any number\t") def function2(argument): print ("this is the entered number - ",argument)
Appelez les fonctions comme ceci
function1()
function2(a)