Różnice w działaniu funkcji

Question

Mam dwie funkcje:

def func(a=""):
     a += "1"
     print(a)
 
func()
func()
func()
 
def func1(a=[]):
     a += [1]
     print(a)
 
func1()
func1()
func1()

Co zwrócą, to nie filozofia dla mnie odgandąć. Jednak zastanawiam się dlaczego przy drugiej funkcji będzie [1], [1,1] i [1,1,1], a przy pierwszej wynik cały czas jest '1'? Od czego to zależy? I jak będzie sytuacja wyglądała przy krotkach i zbiorach? 

Answer 1

String nie jest skomplikowaną strukturą danych i jest przesyłany przez wartość, a że ty nie przesyłasz stringa to za każdym razem tworzysz nowy pusty string jak zrobisz:

def func(a):
    a += str(1)
    print(a)
    return a
  
b = ""
b = func(b)
b = func(b)
b = func(b)
print b

to działa tak samo innej opcji nie widzę. Cały program do sprawdzenia działania:

def func(a):
    a += str(1)
    print(a)
    return a
  
b = ""
b = func(b)
b = func(b)
b = func(b)
print(b)

def func1(a = []):
     a += [1]
     print(a)

c = []
func1(c)
func1(c)
func1(c)
print(c)

def func3(a = {}):
     a["one"] = 1
     print(a)
	 
d = {}
func3(d)
func3(d)
func3(d)
print(d)

def func4(a):
	b = list(a)
	b += [1]
	a = tuple(b)
	print(a)
	return a

e = ()
e = func4(e)
e = func4(e)
e = func4(e)
print (e)

W ostatnim przypadku mamy też przez wartość bo tuple(tak wolę angielską nazwę) nie powinien być modywikowany a ze słownikiem to wiadomo. Jak już jeden klucz istnieje to drugi raz się go nie zrobi.

Comments

To nie jest prawda. W Pythonie nie ma czegoś takiego jak "przekazywanie przez wartość" ("przez referencję" w rozumieniu na przykład C++'owym też nie; jakby się bardzo czepiać to najbliższe prawdzie jest "przekazuję referencję przez wartość").

to za każdym razem tworzysz nowy pusty string

To też nie jest prawda, za każdym razem to jest ten sam obiekt i to się tyczy wszystkich Twoich przykładów.

Prawdziwa różnica polega na tym, że w przypadku stringów "a += b" oraz "a = a + b" zachowują się tak samo: tworzą nowy string i przypisują go do a (bo stringi w Pythonie są niemutowalne). Ale dla list "a += b" dla odmiany modyfikuje istniejący obiekt (a) Dowód:

>>> a=[]
>>> b=a
>>> a is b # a i b wskazuja na ta sama liste
True
>>> b += [1]
>>> b
[1]
>>> a
[1]
>>> a is b # to wciaz ten sam obiekt
True
>>> b = b + a
>>> b
[1, 1]
>>> a
[1]
>>> a is b # to juz inny obiekt
False

Answer 2

Dzieje się tak dlatego, że listy są zmiennym typem danych ( mutable ), więc do funkcji zostaje wysłany odnośnik do danej listy ( reference ), wtedy każda operacja modyfikuje oryginał.

Stringi natomiast, są typem danych niezmiennym ( czyli immutable - btw. nie polecam się uczyć pythona po polsku ), więc do funkcji zostaje wysłana kopia danego stringa. Jaki więc można zmienić stringa poprzez funkcję, na przykład dodać do niego "abc" lub cokolwiek innego ?: 

def func(old_string):
	something = "abc"
	new_string = old_string + something
	return new_string

Jest to na pewien sposób obejście - musimy potem posługiwać się zwracaną wartością przez funkcje a nie bezpośrednio stringiem który wysłaliśmy do funkcji.

Comments

Patrz moja odpowiedź do drugiej odpowiedzi - masz rację o mutowalności/niemutowalności listy i stringa, ale nie o kopiowaniu argumentów. Ba, z definicji jedną z głównych zalet niezmienności stringów jest to że nigdy nie trzeba ich kopiować.

---

Faktycznie - musiałem kiedyś źle zrozumieć to co pisali na so i już tak zapamiętałem:

http://stackoverflow.com/questions/986006/how-do-i-pass-a-variable-by-reference

Answer 3

Dziwne zachowanie kodu 

def func1(a=[]):

wynika stąd, że Python wartości domyślne (w powyższym jest to [ ] )
tworzy tylko raz - przy uruchamianiu programu - a potem korzysta z odnośnika do tej wartości. 

Przy każdym uruchomieniu tej funkcji bez podania własnego parametru "a"
korzysta ona z tej wczejśniej utworzonej listy a nie tworzy za każdym razem nowej.

Można powiedzieć, że jest to równoważne z 

ukryta_lista = [] # utworzenie jednej listy na poczatku
def func1(a=ukryta_lista): # przypisywanie `ukrytej_listy` do `a`

Do tego dochodzi fakt, że po poniższym przypisaniu 

a = ukryta_lista

Zmienna `a` nie zawiera kopii `ukrytej listy` tylko wskazuje dokładnie na `ukrytą listę` (na to samo miejsce w pamięci). Tak więc późniejsze działania na liście `a` jest równoważne działaniu bezpośrednio na `ukrytej liście`.

Problem rozwiązuje się z użyciem `None`

def func1(a=None):
    if a is None:
        a = []