Code: Alles auswählen
# counter.py
n = 0
def count():
global n
n += 1
Code: Alles auswählen
import counter
print counter.n
counter.count()
print counter.n
Code: Alles auswählen
from counter import *
print n
count()
print n
Code: Alles auswählen
# counter.py
n = 0
def count():
global n
n += 1
Code: Alles auswählen
import counter
print counter.n
counter.count()
print counter.n
Code: Alles auswählen
from counter import *
print n
count()
print n
Code: Alles auswählen
# changer.py
d = {}
def change():
d["key"] = "value"
Code: Alles auswählen
from changer import *
print d
change()
print d
Code: Alles auswählen
{}
{'key': 'value'}
Das verstehe ich jetzt nicht bzw. anscheinend habe ich bisher etwas falsch verstanden:BlackJack hat geschrieben:@numerix: Python kopiert keine Objekte wenn man das nicht explizit will, und macht da auch keinen Unterschied zwischen veränderbaren und nicht veränderbaren Objekten.
Code: Alles auswählen
a = 5
b = a # int ist immutable -> Kopie von a wird erzeugt
c = ["nix"]
d = c # list ist mutable -> Referenz von c wird erzeugt
Code: Alles auswählen
Namen | Objekte
|
a----------->+-------+
| |<int> 5|
b----------->+-------+
|
c----------->+--------+ +-----------+
| |<list> o+----------->|<str> "nix"|
d----------->+--------+ +-----------+
|
|
Code: Alles auswählen
In [1]: a = 5
In [2]: b = a
In [3]: a is b
Out[3]: True
In [4]: a += 1
In [5]: a, b
Out[5]: (6, 5)
Um den Sachverhalt mal zu verdeutlichen:numerix hat geschrieben:Was passiert hier, wenn nicht das, was die Kommentare sagen?
Code: Alles auswählen
a += 1 # und
a["key"] += 1
Code: Alles auswählen
a = a + 1
Code: Alles auswählen
a.__setitem__("key", a["key"] + 1)
Code: Alles auswählen
int eins = 1;
int zwei = 2;
int drei = 3;
...
int *name_a = &eins;
int *name_b = &eins;
// Neu binden bei name_a++
name_a = &zwei
// name_b bleibt weiterhin &eins
Das sind für mich Fragen auf einer Meta-Ebene, die über das hinausgehen, was für mich wichtig ist (meine Ansprüche sind halt bescheiden ...). Für mich genügt es zu wissen, wie es ist, und zu verstehen, wie es ist. Warum dies oder jenes in Python so oder so implementiert ist, warum eine Kopie erstellt werden sollte und wie Python irgendetwas feststellen sollte, das sind Fragen, mit denen ernsthaft mich zu beschäftigen ich keine Zeit habe - ich verdiene mein Geld nicht mit dem Programmieren.Trundle hat geschrieben:warum sollten denn von unveränderlichen Objekten überhaupt Kopien erstellt werden? Schließlich sind sie ja unveränderlich. Und wie soll Python feststellen, ob ein Typ unveränderlich ist oder nicht?
Naja. Wenn über den Namen eine Änderung am Objekt vorgenommen wird, kann es ja wohl kaum unveränderlich gewesen sein.numerix hat geschrieben:Wird jetzt über einen der Namen eine Änderung am Objekt vorgenommen, DANN kommt zum Tragen, ob das Objekt veränderlich ist oder nicht:
Das schon, ja.numerix hat geschrieben:Ist es veränderlich, dann wird es halt verändert, aber es bleibt das gleiche Objekt, das weiterhin an alle Namen gebunden ist, an die es vorher auch schon gebunden war.
Zuweisung erstellt immer neue Bindungen bzw überschreibt alte Bindungen; insofern - ja stimmt soweit.numerix hat geschrieben:Ist es aber nicht veränderlich, dann erfolgt gar keine Änderung (weil es ja nicht möglich ist), sondern es entsteht ein NEUES Objekt, das per Zuweisung an einen neuen Namen gebunden wird.
Das ist mir etwas zu kompliziert formuliert. Durch die Zuweisung bindest du das Objekt auf der rechten Seite (egal ob es jetzt frisch erstellt ist oder schon anderswo gebunden ist) an einen Namen auf der linken Seite. Das ist unabhängig davon ob das Objekt mutable ist oder nicht:numerix hat geschrieben:Ist der neue Name aber gar kein neuer Name, sondern der alte Name, dann sieht es zwar so aus, als wäre eine Änderung an einer Kopie des ursprünglichen Objekts erfolgt, in Wahrheit hat es aber nie eine Kopie gegeben, sondern es ist jetzt gerade ein neues Objekt erzeugt und an den alten Namen gebunden worden.
Code: Alles auswählen
l = [1, 2, 3]
l = [1, 3, 3, 7]
t = (1, 2, 3)
t = (1, 3, 3, 7)
Den Objekten ist es so oder so egal an was für Namen sie gebunden sind, sie wissen nicht wie sie heißen und es ist egal ob sie 0, 1 oder 23 Namen haben.numerix hat geschrieben:Da das dem ursprünglichen Objekt und dem daran gebundenen Namen egal ist, bleibt es wie es ist.
Jein. Es gibt auf Code-Ebene absolut keinen Unterschied zwischen der Behandlung von ver- und unveränderlichen Objekten. Gar keinen. Einfach deswegen, weil die Variablen/Namen untypisiert ist. Python weiß nicht was für Objekte dahinter stecken. Dementsprechend kann man dazwischen auch nicht unterscheiden.numerix hat geschrieben:Richtig?
Code: Alles auswählen
a = irgendein_objekt
b = a
a += 1
Nein, Leerzeichen sind an der Stelle egal. Ich schreibs zum Typ, weil der Punkt nicht zum Namen gehört.str1442 hat geschrieben:(Gibts eigentlich einen Unterschied zwischen int* name und int *name