web-dev-qa-db-fra.com

Python: Passage de variables entre fonctions

J'ai passé ces dernières heures à lire ici et ailleurs et à expérimenter, mais je ne comprends pas vraiment ce que je suis sûr de ne pas être un concept de base: transmettre des valeurs (en tant que variables) entre différentes fonctions.

Par exemple, j'assigne 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()

D'après ma compréhension de ce que font les arguments de fonction, je m'attendrais à ce que cela se fasse comme suit:

  1. Initialiser 'liste' comme une liste vide; Appeler le principal (au moins, je sais que j'ai raison ...)
  2. Dans defineAList (), attribuez certaines valeurs à la liste; puis repasse la nouvelle liste dans main ()
  3. Dans main (), appelez useTheList (list)
  4. Puisque 'list' est inclus dans les paramètres de la fonction useTheList, je suppose que useTheList utiliserait maintenant la liste telle que définie par defineAList (), PAS la liste vide définie avant l'appel de main.

Cependant, c'est évidemment une compréhension erronée. 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, ou du moins, il ne le fait pas comme je pense qu'il devrait ... que fait-il réellement? Pourriez-vous s'il vous plaît 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 arriver, mais beaucoup d'exemples de bon argumentage que j'ai vu utilisent aussi du code que je ne connais pas encore, et dans le processus de comprendre ce qui se passe, je Je ne comprends pas vraiment ce concept. J'utilise 2.7.

ETA: dans le passé, posant une question similaire, il a été suggéré d’utiliser une variable globale plutôt que des variables locales. Si cela est également pertinent ici- pour les besoins de la classe que je prends, nous ne sommes pas autorisés à utiliser les globals.

Je vous remercie!

pythonfunctionarguments
34
user2113818

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

Voici ce que tu veux:

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 ignorer le temporaire returned_list Et transmettre directement la valeur renvoyée à useTheList:

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

Il ne vous manque qu'une étape critique. Vous devez explicitement transmettre la valeur de retour à la deuxième fonction.

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

Alternativement:

def main():
    useTheList(defineAList())

Ou bien (bien que vous ne devriez pas faire cela! Cela peut sembler gentil au début, mais les globals vous causent 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 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 de l'appel, puis l'utiliser pour les opérations suivantes.

9
Silas Ray

Votre retour est inutile si vous ne l'assignez pas

list=defineAList()
3
bobrobbob

Lisez le concept d'un espace de noms. Lorsque vous affectez une variable dans une fonction, vous l'attribuez uniquement dans l'espace de nommage 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)
2
Benjamin

passer variable d'une fonction comme argument à d'autres fonctions peut être fait comme ceci

définir des fonctions comme celle-ci

def function1():
global a
a=input("Enter any number\t")

def function2(argument):
print ("this is the entered number - ",argument)

appeler les fonctions comme ça

function1()
function2(a)
1
Pb Studies

return renvoie une valeur. Peu importe le nom que vous avez donné à cette valeur. Le retourner ne fait que "le passer" de sorte que quelque chose d'autre puisse l'utiliser. Si vous voulez l'utiliser, vous devez l'attraper de l'extérieur:

lst = defineAList()
useTheList(lst)

Retourner list de l'intérieur defineAList ne signifie pas "faites en sorte que tout le reste du programme puisse utiliser cette variable". Cela signifie "passer cette variable et donner une chance au reste du programme de la saisir et de l'utiliser". Vous devez affecter cette valeur à quelque chose en dehors de la fonction pour pouvoir l'utiliser. De plus, pour cette raison, il n'est pas nécessaire de définir votre liste à l'avance avec list = []. Dans defineAList, vous créez une nouvelle liste et vous la renvoyez; cette liste n'a aucun rapport 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 intégré Python. Si vous créez votre propre variable appelée list, vous ne pourrez plus accéder à celui qui est intégré.

1
BrenBarn