Lassen Sie uns verstehen, wie Argumente übergeben werden (Python Edition)

In Python werde ich die Behandlung (Evaluierungsstrategie) beim Übergeben von Argumenten an Funktionen und Objektmethoden zusammenfassen. Wie unter Informationen zu Python-Variablen und -Objekten erläutert, sind in Python alle Werte Objekte, und Variablen speichern Objektreferenzen (Referenzen). Es ist gewesen. Wenn eine Funktion aufgerufen wird, können Sie sich diese als Referenz des tatsächlichen Arguments (Aufruferargument) vorstellen, das in das formale Argument (Funktionsargument) "kopiert" und übergeben wird. Diese Methode wird als "Call by Sharing" oder "Call by Value" bezeichnet, wobei value die Referenzkopie ist.

■ Wenn Sie einen unveränderlichen Wert als Argument übergeben

Wenn Sie in Python einem Argument innerhalb einer Funktion einen anderen Wert zuweisen und die Referenz oder Referenz der Variablen ändern, wird dieser nicht für den Aufrufer angezeigt. Betrachten wir zunächst den Fall, dass eine unveränderliche Wertvariable wie ein numerischer Wert oder eine Zeichenfolge als Argument übergeben wird. Im folgenden Beispiel wird 10 zum Wert des Arguments arg innerhalb der Funktion test1 () hinzugefügt. Es erstellt tatsächlich ein neues ganzzahliges Objekt mit dem Wert des Arguments plus 10 und weist seinen Verweis der Variablen arg neu zu.

def test1(arg):
    arg += 10 #① Addieren Sie 10 zum Wert von arg und weisen Sie ihn neu zu

num = 3
test1(num)
print(num) #② Zeigen Sie den Wert von num an

Wenn Sie nach dem Aufruf der Funktion test1 () versuchen, den Wert der Variablen num außerhalb der Funktion ② anzuzeigen, wird die Änderung des Argumentwerts innerhalb der Funktion ① nicht berücksichtigt.

$ python3 arg_test1.py 
3 ← ② Der Wert der Variablen num bleibt "3"

Dies liegt daran, dass das Referenzziel des Arguments arg geändert wurde, indem es dem Argument arg in (1) neu zugewiesen wurde. Bevor ① ausgeführt wird, beziehen sich die globale Variable num außerhalb der Funktion und das Argument arg auf denselben Wert, nach ① jedoch auf unterschiedliche Werte. Sie können überprüfen, ob sich die Referenz mit der Funktion id () geändert hat, die die ID-Nummer des Objekts wie folgt anzeigt.

def test1(arg):
    #Ändern Sie die Argumente innerhalb der Funktion
    print("arg: {}".format(id(arg))) 
    arg += 10 # ①
    print("arg: {}".format(id(arg)))
    
num = 3
test1(num)
print(num) #Wert von num anzeigen

Das Ausführungsergebnis ist wie folgt

$ python3 arg_test1.py 
arg:4297537952 ← Vor ①
arg:4297538272 ← ID geändert nach ①
3 ← Der Wert der Variablen num bleibt außerhalb der Funktion gleich

■ Wenn Sie einen veränderlichen Wert als Argument übergeben (Teil 1)

Das Gleiche gilt, wenn Sie einen veränderlichen Wert wie eine Liste oder ein Wörterbuch als Argument übergeben. Wenn sich die Referenz ändert, wird sie nicht an den Aufrufer weitergegeben. Im folgenden Beispiel wird die Liste als Argument übergeben, das Element wird durch "arg + [4, 5]" innerhalb der Funktion hinzugefügt und arg neu zugewiesen.

def test2(arg):
    #Ändern Sie die Argumente innerhalb der Funktion
    print("arg: {}".format(id(arg)))
    arg = arg + [4, 5] #① Element hinzufügen
    print("arg: {}".format(id(arg)))

myLst = [1, 2, 3]
test2(myLst)
print(myLst) #Zeigen Sie den Wert von myLst an

In diesem Fall (1) ändert sich die Referenz, da durch Kombinieren von "[4, 5]" mit dem Operator "+" ein neues Listenobjekt erstellt wird. Daher wird es im Anrufer nicht wiedergegeben.

$ python3 arg_test2.py 
arg: 4329564104
arg:4329566024 ← ID geändert
[1, 2, 3]← Der Wert ändert sich außerhalb der Funktion nicht

■ Wenn Sie einen veränderlichen Wert als Argument übergeben (Teil 2)

Wenn Sie einen veränderlichen Wert als Argument übergeben und die Referenz in der Funktion nicht geändert wird, wird die Änderung in der Funktion für den Aufrufer übernommen. Zum Beispiel, wenn Sie eine Methode ausführen, die den Wert eines Objekts direkt ändert. Im folgenden Beispiel wird das Element durch die Extend () -Methode anstelle des Operators "+" im vorherigen Beispiel in ① innerhalb der Funktion zur Liste hinzugefügt. Außerdem wird in ② das zweite Element der Liste durch "arg [1] = 10" in "10" geändert.

def test3(arg):
    #Ändern Sie die Argumente innerhalb der Funktion
    print("arg: {}".format(id(arg)))
    arg.extend([4, 5]) # ① [4, 5]Hinzufügen
    arg[1] = 10 #② Ändern Sie das zweite Element
    print("arg: {}".format(id(arg)))

myLst = [1, 2, 3]
test3(myLst)
print(myLst) #Zeigen Sie den Wert von myLst an

In diesem Fall ändert sich die Referenz nicht, da in ①② kein neues Objekt erstellt wird. Daher werden Änderungen im Wert von Argumenten innerhalb der Funktion im Aufrufer berücksichtigt.

$ python3 arg_test3.py 
arg: 4321175496
arg:4321175496 ← ID ändert sich nicht
[1, 10, 3, 4, 5]