Python: Übergeben von Variablen zwischen Funktionen

Question

Ich habe die letzten paar Stunden hier und anderswo gelesen und experimentiert, aber ich verstehe nicht wirklich, was ich bin sicher, ist ein sehr grundlegendes Konzept: Werte übergeben (wie Variablen) zwischen verschiedenen Funktionen. eine ganze Reihe von Werten zu einer Liste in einer Funktion, wollen dann später in einer anderen Funktion, diese Liste verwenden

Zum Beispiel hat ich zuweisen:

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

Basierend auf meinem Verständnis von mir, welche Funktionsargumenten tun,

würde folgendes erwarten:

1. Initialisiere "Liste" als leere Liste; call main (zumindest weiß ich, dass ich Recht habe ...)
2. Innerhalb von defineAList(), weisen Sie der Liste bestimmte Werte zu; die neue Liste dann
3. In main() zurück in main() übergeben, rufen useTheList (Liste)
4. Da ‚Liste‘ in den Parametern der useTheList Funktion enthalten ist, würde ich erwarten, dass useTheList nun die Liste verwenden würden, wie definiert durch defineAList(), NICHT die leere Liste, die vor dem Aufruf von main definiert wurde.

Dies ist jedoch offensichtlich ein fehlerhaftes Verständnis. Meine Ausgabe ist:

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

Also, da „Rückkehr“ offensichtlich nicht tut, was ich denke, dass es der Fall ist, oder zumindest tut es nicht so, wie ich denke, es sollte ... was bedeutet es eigentlich? Könnten Sie mir bitte anhand dieses Beispiels zeigen, was ich tun müsste, um die Liste von defineAList() zu übernehmen und sie in useTheList() zu verwenden? Ich neige dazu, die Dinge besser zu verstehen, wenn ich sie sehe, aber viele der Beispiele für richtiges Argument-Passing, die ich gesehen habe, verwenden auch Code, den ich noch nicht kenne, und während ich darüber nachdenke, was vor sich geht, ich Ich verstehe dieses Konzept nicht wirklich. Ich benutze 2,7.

ETA- in der Vergangenheit, eine ähnliche Frage stellend, wurde vorgeschlagen, dass ich eine globale Variable anstelle von nur Einheimischen verwende. Wenn es auch hier relevant ist - für die Zwecke der Klasse, die ich nehme, dürfen wir keine Globals verwenden.

Vielen Dank!

Answer 1

Dies ist, was tatsächlich geschieht:

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

Dies ist, was Sie wollen:

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

Sie können sogar die temporäre returned_list überspringen und den zurückgegebenen Wert direkt an useTheList passieren:

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

Answer 2

Sie verpassen nur einen kritischen Schritt. Sie müssen den Rückgabewert explizit an die zweite Funktion übergeben.

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

Alternativ:

def main(): 
    useTheList(defineAList()) 

Oder (wenn Sie dies nicht tun sollten Es könnte zunächst schön erscheinen, aber Globals nur führen, dass Sie auf lange Sicht Trauer!.):

l = [] 

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

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

Die Funktion gibt einen Wert zurück, aber das Symbol wird in keinem globalen Namespace erstellt, wie von Ihrem Code angenommen. Sie müssen den Rückgabewert tatsächlich im aufrufenden Bereich erfassen und für nachfolgende Operationen verwenden.

Answer 3

Ihre Rückkehr ist nutzlos, wenn Sie es nicht zuordnen

list=defineAList() 

Answer 4

return einen Wert zurückgibt. Es ist egal, welchen Namen du diesem Wert gegeben hast.Wenn es zurückgegeben wird, "verstreicht es einfach", damit etwas anderes es benutzen kann. Wenn Sie es verwenden möchten, müssen Sie es greifen von außen:

lst = defineAList() 
useTheList(lst) 

Rückkehr list von innen defineAList bedeutet nicht „machen es so den ganzen Rest des Programms diese Variable verwenden können“. Es bedeutet, "diese Variable weitergeben und dem Rest des Programms eine Chance geben, es zu ergreifen und es zu benutzen". Sie müssen diesen Wert einem Wert außerhalb der Funktion zuweisen, um ihn zu verwenden. Aus diesem Grund ist es nicht notwendig, Ihre Liste im Voraus mit list = [] zu definieren. Innerhalb defineAList, erstellen Sie eine neue Liste und geben sie zurück; Diese Liste hat keine Beziehung zu der, die Sie am Anfang mit list = [] definiert haben.

Übrigens habe ich Ihren Variablennamen von list zu lst geändert. Es ist keine gute Idee, list als Variablennamen zu verwenden, da dies bereits der Name eines integrierten Python-Typs ist. Wenn Sie Ihre eigene Variable namens list erstellen, können Sie nicht mehr auf die eingebaute Variable zugreifen.

Answer 5

Lesen Sie das Konzept eines Namensraumes. Wenn Sie eine Variable in einer Funktion zuweisen, ordnen Sie sie nur im Namensraum dieser Funktion zu. Aber klar wollen Sie es zwischen allen Funktionen verwenden.

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 

Alternativ können Sie es um passieren:

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

Answer 6

Variable auf andere Funktionen von einer Funktion als Argument übergeben kann wie folgt

erfolgen

Funktionen definieren wie diese

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

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

Aufruf der Funktionen wie diese

function1() 
function2(a)