Perché una funzione può modificare alcuni argomenti come percepiti dal chiamante, ma non altri?

Sto cercando di capire l'approccio di Python all'ambito variabile. In questo esempio, perché è in f()grado di modificare il valore di x, come percepito all'interno main(), ma non il valore di n?

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

Produzione:

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

Alcune risposte contengono la parola "copia" in un contesto di una chiamata di funzione. Lo trovo confuso.

Python non copia gli oggetti si passa nel corso di una chiamata di funzione sempre .

I parametri di funzione sono nomi . Quando chiamate una funzione, Python associa questi parametri a qualunque oggetto passi (tramite nomi nell'ambito di un chiamante).

Gli oggetti possono essere mutabili (come liste) o immutabili (come numeri interi, stringhe in Python). Oggetto mutevole che puoi cambiare. Non puoi cambiare un nome, puoi semplicemente legarlo a un altro oggetto.

Il tuo esempio non riguarda gli ambiti o gli spazi dei nomi , riguarda la denominazione, l'associazione e la mutabilità di un oggetto 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

Ecco delle belle foto sulla differenza tra variabili in altre lingue e nomi in Python .

Hai già un numero di risposte, e sono ampiamente d'accordo con JF Sebastian, ma potresti trovare questo utile come scorciatoia:

Ogni volta che vedi varname =, stai creando un nuovo nome associato nell'ambito della funzione. Qualunque valore varnameprima era vincolato viene perso in questo ambito .

Ogni volta che vedi varname.foo()che stai chiamando un metodo varname. Il metodo può modificare varname (ad es list.append.). varname(o meglio l'oggetto chevarname nomina) può esistere in più di un ambito, e poiché è lo stesso oggetto, qualsiasi modifica sarà visibile in tutti gli ambiti.

[nota che la globalparola chiave crea un'eccezione al primo caso]

fin realtà non altera il valore di x(che è sempre lo stesso riferimento a un'istanza di un elenco). Piuttosto, altera il contenuto di questo elenco.

In entrambi i casi, una copia di un riferimento viene passata alla funzione. All'interno della funzione,

• nviene assegnato un nuovo valore. Viene modificato solo il riferimento all'interno della funzione, non quello esterno.
• xnon viene assegnato un nuovo valore: né il riferimento all'interno né all'esterno della funzione viene modificato. Al contrario, xil valore viene modificato.

Poiché sia ​​la xfunzione interna che quella esterna si riferiscono allo stesso valore, entrambi vedono la modifica. Al contrario, l' ninterno della funzione e l'esterno si riferiscono a valori diversi dopo che è nstato riassegnato all'interno della funzione.

Rinominerò le variabili per ridurre la confusione. n -> nf o nmain . x -> xf o 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()

Quando chiamate la funzione f , il runtime di Python crea una copia di xmain e la assegna a xf , e allo stesso modo assegna una copia di nmain a nf .

Nel caso di n , il valore che viene copiato è 1.

Nel caso di x il valore che viene copiato non è l'elenco letterale [0, 1, 2, 3] . È un riferimento a tale elenco. xf e xmain indicano lo stesso elenco, quindi quando si modifica xf si modifica anche xmain .

Se, tuttavia, dovessi scrivere qualcosa del tipo:

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

scopriresti che xmain non è cambiato. Questo perché, nella riga xf = ["foo", "bar"] hai cambiato xf per puntare a un nuovo elenco. Qualsiasi modifica apportata a questo nuovo elenco non avrà alcun effetto sull'elenco a cui punta ancora xmain .

Spero che aiuti. :-)

È perché un elenco è un oggetto mutabile. Non stai impostando x sul valore di [0,1,2,3], stai definendo un'etichetta per l'oggetto [0,1,2,3].

Dovresti dichiarare la tua funzione f () in questo modo:

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

n è un int (immutabile) e una copia viene passata alla funzione, quindi nella funzione si sta modificando la copia.

X è un elenco (modificabile) e viene passata una copia del puntatore della funzione in modo che x.append (4) cambi il contenuto dell'elenco. Tuttavia, hai detto x = [0,1,2,3,4] nella tua funzione, non cambieresti il ​​contenuto di x in main ().

Se le funzioni vengono riscritte con variabili completamente diverse e le chiamiamo id , illustra bene il punto. All'inizio non ho capito e ho letto il post di jfs con la grande spiegazione , quindi ho cercato di capire / convincermi:

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 e x hanno lo stesso id. Solo tag diversi per la stessa struttura sottostante come dice l'articolo.

Python è un linguaggio pass-by-value puro se ci pensi nel modo giusto. Una variabile python memorizza la posizione di un oggetto in memoria. La variabile Python non memorizza l'oggetto stesso. Quando si passa una variabile a una funzione, si passa una copia dell'indirizzo dell'oggetto a cui punta la variabile.

Contrasta queste due funzioni

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

def goo(x):
    x = []

Ora, quando si digita nella shell

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

Confronta questo con goo.

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

Nel primo caso, passiamo una copia all'indirizzo della mucca a foo e foo ha modificato lo stato dell'oggetto che vi risiede. L'oggetto viene modificato.

Nel secondo caso si passa una copia dell'indirizzo di vacca a goo. Quindi goo procede a modificare quella copia. Effetto: nessuno.

Io chiamo questo il principio della casa rosa . Se fai una copia del tuo indirizzo e dici a un pittore di dipingere la casa a quell'indirizzo rosa, finirai con una casa rosa. Se dai al pittore una copia del tuo indirizzo e gli dici di cambiarlo in un nuovo indirizzo, l'indirizzo della tua casa non cambia.

La spiegazione elimina molta confusione. Python passa le variabili degli indirizzi memorizzate per valore.

Python è una copia per valore di riferimento. Un oggetto occupa un campo in memoria e un riferimento è associato a quell'oggetto, ma esso stesso occupa un campo in memoria. E il nome / valore è associato a un riferimento. Nella funzione python, copia sempre il valore del riferimento, quindi nel tuo codice, n viene copiato per essere un nuovo nome, quando lo assegni, ha un nuovo spazio nello stack del chiamante. Ma per l'elenco, anche il nome è stato copiato, ma si riferisce alla stessa memoria (poiché non si assegna mai un nuovo valore all'elenco). Questa è una magia in pitone!

La mia comprensione generale è che qualsiasi variabile oggetto (come un elenco o un dict, tra gli altri) può essere modificata attraverso le sue funzioni. Ciò che credo non sia in grado di fare è riassegnare il parametro, ovvero assegnarlo per riferimento all'interno di una funzione richiamabile.

Ciò è coerente con molte altre lingue.

Esegui il seguente breve script per vedere come funziona:

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

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

Avevo modificato la mia risposta tonnellate di volte e mi sono reso conto che non dovevo dire nulla, si era già spiegato Python.

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)

Questo diavolo non è il riferimento / valore / mutabile o no / istanza, spazio dei nomi o variabile / lista o str, È LA SINTASSI, SEGNO UGUALE.