Objekte dynamisch erstellen

[BlackJack]

So sieht die Situation im Speicher nach den drei Schritten jeweils aus:

Code: Alles auswählen

   Names  |     Objects
  -----------------------------------------
 1.       |        +-------+
   i-------------->|<int> 1|
          |        +-------+
  -----------------------------------------
 2.       |        +-------+
   i-------------->|<int> 1|
          |        +-------+
          |              ^
          |              |
          |      +-------+-+
   l------------>|<list> 0 |
          |      +---------+
  -----------------------------------------
 3.       |        +-------+
   i-------------->|<int> 1|
          |        +-------+
          |
          |      +---------+    +-------+
   l------------>|<list> 0-+--->|<int> 2|
          |      +---------+    +-------+
          |

Wie man sieht existiert jedes der Objekte nur einmal, keines wurde kopiert.

[ms4py]

Ich wollte das ganze eigentlich mit "+=" machen, dann wäre das Beispiel wenigstens nicht ganz so nichtssagend.
Mir ist (jetzt...) durchaus bewusst, dass das natürlich trotzdem auf das gleiche hinausläuft, da bei "+=" ja auch eine neue Instanz erzeugt wird.
Irgendwie habe ich die Zusammenhänge, die ich eigentlich schon alle wusste, falsch verbunden.
Entschuldigung, dass ich hier irgendwelche Halbwahrheiten verbreitet habe.

Als Ausgleich bringe ich noch ein Beispiel, bei dem man den Unterschied von immutable und mutable Typen sieht

Code: Alles auswählen

>>> def mutable(l=[]):
...     l.append(1)
...     print l
...
>>> mutable()
[1]
>>> mutable()
[1, 1]
>>> def immutable(i=1):
...     i += 1
...     print i
...
>>> immutable()
2
>>> immutable()
2

[Darii]

Als Ausgleich bringe ich noch ein Beispiel, bei dem man den Unterschied von immutable und mutable Typen sieht

Eigentlich führst du nur völlig verschiedene Operationen aus. Viel fieser wäre:

Code: Alles auswählen

In [12]: def mutable1(l=[]):
   ....:         l += [1,]
   ....:     return l
   ....: 

In [13]: def mutable2(l=[]):
   ....:         l = l + [1,]
   ....:     return l
   ....: 

In [14]: mutable1()

Out[14]: [1]

In [15]: mutable1()

Out[15]: [1, 1]

In [16]: mutable2()

Out[16]: [1]

In [17]: mutable2()

Out[17]: [1]

Das += ab und zu auch mal in-place wirken kann war mir bis eben übrigens auch nicht bewusst.