Rückkehr Variablen in Funktionen von Python Funktioniert Nicht Richtig

Sind Sie versauen ein bisschen die Bereiche und/oder Zuordnung. Versuchen Sie dies:

test = 0

def testing():
    test = 1
    return test

test = testing()
print(test)

Erklärung: Die test innen testing anderen test innerhalb des Moduls. Ordnen Sie es auf Modul-Ebene, um das erwartete Ergebnis.

InformationsquelleAutor Hyperboreus

Innerhalb der Funktion testing(), erstellen Sie eine neue variable test, nicht unter Bezugnahme auf das eine, das bereits vorhanden ist. Wenn Sie das tun wollen, sollten Sie eine global - Anweisung in die Spitze, in:

def testing():
    global test
    ...etc...

InformationsquelleAutor Eli Rose

TLDR: return Wert muss zugeordnet etwas an der call-site.

test = testing()

Funktionen in Python haben einen eigenen Bereich. Es wird auf die Eingabe (Berufung) die Funktion und zerstört, wenn Sie es verlassen. Zuordnung zu einem Namen innerhalb eines Bereichs macht, die lokalen Namen in diesem Umfang - wodurch es zerstört werden, zusammen mit dem Bereich.

# start outer scope
test = 0  # create name outer:test

def testing():
    # start inner scope
    test = 1  # create name outer.testing:test
    return test
    # end inner scope
    # destroy name outer.testing:test

testing()  # new temporary inner scope outer.testing
print(test)  # use name outer:test
# end outer scope

Insbesondere, Namen in einem inneren scope kann "shadow" Namen aus einem äußeren Gültigkeitsbereich. Während der name test existiert in beiden testing und der äußere Rahmen, es bezieht sich nicht auf die gleiche Sache. Dies hat zwei wichtige Implikationen:

1. Die Zuordnung zu den innere test berührt nicht die äußeren test.
2. Am Ende testing, die innere test ist zerstört und nur die äußeren test bleibt.

Dies ist, warum ruft testing() nicht den gewünschten Effekt haben: es ist nie ändert, die äußeren test übergeben print.

Die return - Anweisung definiert den Wert, der zurückgegeben wird, durch den Aufruf einer Funktion. Es tut nicht den Namen, nur den Wert hinwies.

def testing():
    test = 1  # test refers to the value 1
    return test  # return test => value 1

Den Wert von einer Funktion zurückgegeben wird, ist wie jede andere Wert - sei es von einem literal, lookup, oder andere. Am wichtigsten ist, ist der Wert nicht beibehalten werden, es sei denn, Sie ordnen Sie einen Namen ein, oder verwenden Sie es direkt.

testing()  # call test, discard its value
test = testing()  # call test, store its value as `test`
print(testing())  # call test, use its value in `print`

So, um wieder etwas von einer Funktion, für spätere Verwendung, müssen Sie das Ergebnis speichern einen Namen. Sie können dann mit diesen Namen in einer späteren Aussage. Ein minimal-Beispiel für deinen Fall sieht wie folgt aus:

# we already can define testing here
# it is overwritten later on, then

def testing():
    # all names we use inside of testing are gone at the end
    # if we just want a value, we can skip temporary names
    return 1

# store the return value of testing() for later use
test = testing()
print(test)

Nachtrag: Es ist möglich, für eine Funktion zu ändern mit Umfang. Aber Namen müssen dann explizit deklariert werden wie Wesen von einem fremden Rahmen.

Den nichtlokale und global keywords erlaubt das anpassen von Namen aus den äußeren Bereichen. Ein nonlocal heißt es in dem am besten passenden Funktionsumfang. Ein global ist der name des Moduls Umfang, unabhängig von irgendwelchen Funktionen, die in-zwischen.

test = 0

def increment():
    global test  # declare test as belonging to a specific scope
    test += 1
    # no need to return something
    # we already modified the outer `test`

print(test)  # 0
increment()
print(test)  # 1

Beachten Sie, dass die änderung von äußeren Namen ist oft das Zeichen einer anti-Muster-ganz besonders für globals als nonlocals. Über kleine Skripte, wird es schwierig, zu verfolgen, was den Zugriff auf und ändern von globals. Oft ist es sinnvoller, die Verwendung von Klassen oder Generatoren zu halten Zustand.

Kann eine Funktion immer Lesen Namen von seinem enthaltenden Bereich, sofern es nie schreibt den gleichen Namen. Solche Verschlüsse sind sehr einfach zu erstellen, und der Mangel an Veränderung macht Ihnen einfacher, Sie zu verfolgen. Beachten Sie, dass die änderung einen Namen überall in einer Funktion macht es lokale, es sei denn, erklärt global oder nonlocal:

test = 0

def increment():
    global test
    test += 1

def show_test():
    # we never modify `test`, so it is fetched from the outside
    print(test)

def show_and_increment1():  # this function is broken!
    print(test)  # `test` is *not* the outer one, since we modify it in the function
    test += 1  # modifying `test` makes it local for the *entire* function

def show_and_increment2():  # this function works!
    global test  # force `test` to be global
    print(test)
    test += 1

show_test()  # 0
increment()
show_test()  # 1
show_and_increment2()  # 1
show_and_increment2()  # 2
show_and_increment2()  # 3
show_test()  # 4
show_and_increment1()  # UnboundLocalError: local variable 'test' referenced before assignment

InformationsquelleAutor MisterMiyagi