Warum kann eine Funktion einige Argumente ändern, die vom Aufrufer wahrgenommen werden, andere jedoch nicht?

Ich versuche, Pythons Ansatz für den variablen Bereich zu verstehen. Warum kann in diesem Beispiel f()der Wert von x, wie in ihm wahrgenommen main(), aber nicht der Wert von ngeändert werden?

def f(n, x):
    n = 2
    x.append(4)
    print('In f():', n, x)

def main():
    n = 1
    x = [0,1,2,3]
    print('Before:', n, x)
    f(n, x)
    print('After: ', n, x)

main()

Ausgabe:

Before: 1 [0, 1, 2, 3]
In f(): 2 [0, 1, 2, 3, 4]
After:  1 [0, 1, 2, 3, 4]

Einige Antworten enthalten das Wort "Kopie" in einem Kontext eines Funktionsaufrufs. Ich finde es verwirrend.

Python kopiert niemals Objekte, die Sie während eines Funktionsaufrufs übergeben .

Funktionsparameter sind Namen . Wenn Sie eine Funktion aufrufen, bindet Python diese Parameter an alle Objekte, die Sie übergeben (über Namen in einem Aufruferbereich).

Objekte können veränderlich (wie Listen) oder unveränderlich (wie Ganzzahlen, Zeichenfolgen in Python) sein. Veränderbares Objekt, das Sie ändern können. Sie können einen Namen nicht ändern, sondern nur an ein anderes Objekt binden.

In Ihrem Beispiel geht es nicht um Bereiche oder Namespaces , sondern um das Benennen und Binden sowie die Veränderbarkeit eines Objekts in Python.

def f(n, x): # these `n`, `x` have nothing to do with `n` and `x` from main()
    n = 2    # put `n` label on `2` balloon
    x.append(4) # call `append` method of whatever object `x` is referring to.
    print('In f():', n, x)
    x = []   # put `x` label on `[]` ballon
    # x = [] has no effect on the original list that is passed into the function

Hier sind schöne Bilder zum Unterschied zwischen Variablen in anderen Sprachen und Namen in Python .

Sie haben bereits eine Reihe von Antworten, und ich stimme JF Sebastian weitgehend zu, aber Sie finden dies möglicherweise als Abkürzung nützlich:

Jedes Mal varname =, wenn Sie sehen , erstellen Sie eine neue Namensbindung im Funktionsumfang. Welcher Wert zuvor varnamegebunden war, geht in diesem Bereich verloren .

Jedes Mal, wenn Sie sehen, dass varname.foo()Sie eine Methode aufrufen varname. Die Methode kann den Variablennamen ändern (z list.append. B. ). varname(oder vielmehr das Objekt, das benannt wird varname) kann in mehr als einem Bereich vorhanden sein, und da es sich um dasselbe Objekt handelt, sind alle Änderungen in allen Bereichen sichtbar.

[Beachten Sie, dass das globalSchlüsselwort eine Ausnahme zum ersten Fall erstellt]

fändert den Wert von nicht wirklich x(was immer der gleiche Verweis auf eine Instanz einer Liste ist). Vielmehr ändert es den Inhalt dieser Liste.

In beiden Fällen wird eine Kopie einer Referenz an die Funktion übergeben. Innerhalb der Funktion,

• nwird ein neuer Wert zugewiesen. Nur die Referenz innerhalb der Funktion wird geändert, nicht die außerhalb.
• xwird kein neuer Wert zugewiesen: Weder die Referenz innerhalb noch außerhalb der Funktion wird geändert. Stattdessen wird xder Wert von geändert.

Da sich sowohl die xInnenseite als auch die Außenseite auf denselben Wert beziehen, sehen beide die Änderung. Im Gegensatz ndazu beziehen sich das Innere der Funktion und das Äußere auf unterschiedliche Werte, nachdem nsie innerhalb der Funktion neu zugewiesen wurden.

Ich werde Variablen umbenennen, um Verwirrung zu vermeiden. n -> nf oder nmain . x -> xf oder xmain :

def f(nf, xf):
    nf = 2
    xf.append(4)
    print 'In f():', nf, xf

def main():
    nmain = 1
    xmain = [0,1,2,3]
    print 'Before:', nmain, xmain
    f(nmain, xmain)
    print 'After: ', nmain, xmain

main()

Wenn Sie die Funktion f aufrufen , erstellt die Python-Laufzeit eine Kopie von xmain und weist sie xf zu . In ähnlicher Weise weist sie nf eine Kopie von nmain zu .

Im Fall von n ist der kopierte Wert 1.

Im Fall von x ist der kopierte Wert nicht die Literalliste [0, 1, 2, 3] . Es ist ein Verweis auf diese Liste. xf und xmain zeigen auf dieselbe Liste. Wenn Sie also xf ändern, ändern Sie auch xmain .

Wenn Sie jedoch etwas schreiben würden wie:

    xf = ["foo", "bar"]
    xf.append(4)

Sie würden feststellen, dass sich xmain nicht geändert hat. Dies liegt daran, dass Sie in der Zeile xf = ["foo", "bar"] xf so geändert haben, dass es auf eine neue Liste verweist . Alle Änderungen, die Sie an dieser neuen Liste vornehmen, haben keine Auswirkungen auf die Liste, auf die xmain noch verweist.

Hoffentlich hilft das. :-)

Das liegt daran, dass eine Liste ein veränderbares Objekt ist. Sie setzen x nicht auf den Wert [0,1,2,3], sondern definieren eine Beschriftung für das Objekt [0,1,2,3].

Sie sollten Ihre Funktion f () folgendermaßen deklarieren:

def f(n, x=None):
    if x is None:
        x = []
    ...

n ist ein int (unveränderlich), und eine Kopie wird an die Funktion übergeben. In der Funktion ändern Sie also die Kopie.

X ist eine Liste (veränderbar), und eine Kopie des Zeigers wird an die Funktion übergeben, sodass x.append (4) den Inhalt der Liste ändert. Wenn Sie jedoch in Ihrer Funktion x = [0,1,2,3,4] gesagt haben, würden Sie den Inhalt von x in main () nicht ändern.

Wenn die Funktionen mit völlig unterschiedlichen Variablen neu geschrieben werden und wir sie mit id aufrufen , wird der Punkt gut veranschaulicht. Ich habe das zuerst nicht verstanden und den Beitrag von jfs mit der großartigen Erklärung gelesen , also habe ich versucht, mich selbst zu verstehen / zu überzeugen:

def f(y, z):
    y = 2
    z.append(4)
    print ('In f():             ', id(y), id(z))

def main():
    n = 1
    x = [0,1,2,3]
    print ('Before in main:', n, x,id(n),id(x))
    f(n, x)
    print ('After in main:', n, x,id(n),id(x))

main()
Before in main: 1 [0, 1, 2, 3]   94635800628352 139808499830024
In f():                          94635800628384 139808499830024
After in main: 1 [0, 1, 2, 3, 4] 94635800628352 139808499830024

z und x haben die gleiche ID. Nur verschiedene Tags für dieselbe zugrunde liegende Struktur wie im Artikel angegeben.

Python ist eine reine Pass-by-Value-Sprache, wenn Sie richtig darüber nachdenken. Eine Python-Variable speichert den Speicherort eines Objekts im Speicher. Die Python-Variable speichert das Objekt selbst nicht. Wenn Sie eine Variable an eine Funktion übergeben, übergeben Sie eine Kopie der Adresse des Objekts, auf das die Variable zeigt.

Vergleichen Sie diese beiden Funktionen

def foo(x):
    x[0] = 5

def goo(x):
    x = []

Nun, wenn Sie in die Shell eingeben

>>> cow = [3,4,5]
>>> foo(cow)
>>> cow
[5,4,5]

Vergleichen Sie dies mit goo.

>>> cow = [3,4,5]
>>> goo(cow)
>>> goo
[3,4,5]

Im ersten Fall übergeben wir eine Kopie der Adresse der Kuh an foo und foo hat den Status des dort befindlichen Objekts geändert. Das Objekt wird geändert.

Im zweiten Fall übergeben Sie eine Kopie der Adresse der Kuh an goo. Dann ändert goo diese Kopie. Wirkung: keine.

Ich nenne das das Prinzip des rosa Hauses . Wenn Sie eine Kopie Ihrer Adresse erstellen und einem Maler sagen, dass er das Haus an dieser Adresse rosa streichen soll, erhalten Sie ein rosa Haus. Wenn Sie dem Maler eine Kopie Ihrer Adresse geben und ihn auffordern, diese in eine neue Adresse umzuwandeln, ändert sich die Adresse Ihres Hauses nicht.

Die Erklärung beseitigt viel Verwirrung. Python übergibt die Adressvariablen, die nach Wert gespeichert sind.

Python wird nach Referenzwert kopiert. Ein Objekt belegt ein Feld im Speicher, und diesem Objekt ist eine Referenz zugeordnet, die jedoch selbst ein Feld im Speicher belegt. Und Name / Wert ist einer Referenz zugeordnet. In der Python-Funktion wird immer der Wert der Referenz kopiert, sodass in Ihrem Code n als neuer Name kopiert wird. Wenn Sie diesen zuweisen, hat es einen neuen Platz im Aufruferstapel. Für die Liste wurde der Name ebenfalls kopiert, bezieht sich jedoch auf denselben Speicher (da Sie der Liste niemals einen neuen Wert zuweisen). Das ist eine Magie in Python!

Mein allgemeines Verständnis ist, dass jede Objektvariable (wie z. B. eine Liste oder ein Diktat) durch ihre Funktionen geändert werden kann. Ich glaube, Sie können den Parameter nicht neu zuweisen, dh ihn innerhalb einer aufrufbaren Funktion als Referenz zuweisen.

Das stimmt mit vielen anderen Sprachen überein.

Führen Sie das folgende kurze Skript aus, um zu sehen, wie es funktioniert:

def func1(x, l1):
    x = 5
    l1.append("nonsense")

y = 10
list1 = ["meaning"]
func1(y, list1)
print(y)
print(list1)

Ich hatte meine Antwort tonnenweise geändert und festgestellt, dass ich nichts zu sagen habe, Python hatte sich bereits erklärt.

a = 'string'
a.replace('t', '_')
print(a)
>>> 'string'

a = a.replace('t', '_')
print(a)
>>> 's_ring'

b = 100
b + 1
print(b)
>>> 100

b = b + 1
print(b)
>>> 101

def test_id(arg):
    c = id(arg)
    arg = 123
    d = id(arg)
    return

a = 'test ids'
b = id(a)
test_id(a)
e = id(a)

# b = c  = e != d

# this function do change original value
del change_like_mutable(arg):
    arg.append(1)
    arg.insert(0, 9)
    arg.remove(2)
    return

test_1 = [1, 2, 3]
change_like_mutable(test_1)



# this function doesn't 
def wont_change_like_str(arg):
     arg = [1, 2, 3]
     return


test_2 = [1, 1, 1]
wont_change_like_str(test_2)
print("Doesn't change like a imutable", test_2)

Dieser Teufel ist nicht die Referenz / Wert / veränderlich oder nicht / Instanz, Namensraum oder Variable / Liste oder str, ES IST DER SYNTAX, GLEICHES ZEICHEN.