Veränderbar und Unveränderbar in Python

Dieser Artikel erklärt Veränderbarkeit und Unveränderbarkeit in Python.

YouTube Video

Veränderbar und Unveränderbar in Python

"Veränderbar" und "unveränderbar" beziehen sich auf die Veränderbarkeit eines Objekts. Das Verständnis dieses Konzepts hilft, unerwartete Fehler zu vermeiden und eine effiziente Speicherverwaltung zu gewährleisten.

Was bedeutet Veränderbar?

Veränderbare Objekte können ihren internen Zustand nach der Erstellung ändern.

Haupttypen veränderbarer Daten

• list
• dict
• set
• Benutzerdefinierte Klassen (wenn ihre Attribute geändert werden können)

Beispiel: Bearbeiten einer Liste

1numbers = [1, 2, 3]
2numbers[0] = 100
3print(numbers)  # [100, 2, 3]

Eine Liste ist ein veränderbares Objekt, und ihre Elemente können frei bearbeitet werden.

Was bedeutet Unveränderbar?

Unveränderbare Objekte können nach ihrer Erstellung nicht geändert werden. Ein Versuch, sie zu ändern, führt zur Erstellung eines neuen Objekts.

Haupttypen unveränderbarer Daten

• int
• float
• str
• tuple
• bool
• frozenset

Beispiel: Bearbeiten eines Strings

1text = "hello"
2# text[0] = "H"  # TypeError: 'str' object does not support item assignment
3
4text = "H" + text[1:]  # Creates a new string
5print(text)  # "Hello"

Strings sind unveränderbar, daher können sie nicht teilweise geändert werden.

Vergleich von Veränderbar und Unveränderbar

 1# Mutable example
 2a = [1, 2, 3]
 3b = a
 4b[0] = 100
 5print(a)  # [100, 2, 3] -> a is also changed
 6
 7# Immutable example
 8x = 10
 9y = x
10y = 20
11print(x)  # 10 -> x is unchanged

Wie Sie an diesem Beispiel sehen können, werden veränderbare Objekte durch Referenz gemeinsam genutzt, sodass sie andere Variablen beeinflussen können. Andererseits erstellen unveränderliche Objekte neue Instanzen bei einer Neuzuweisung, wobei der ursprüngliche Wert unberührt bleibt.

Untersuchung des internen Verhaltens mithilfe von id()

In Python können Sie die Funktion id() verwenden, um die ID eines Objekts zu überprüfen. Die Objekt-ID ähnelt einer Speicheradresse.

 1# Immutable int behavior
 2a = 10
 3print(id(a))  # e.g., 140715920176592
 4a += 1
 5print(id(a))  # e.g., 140715920176624 -> ID has changed
 6
 7# Mutable list behavior
 8b = [1, 2, 3]
 9print(id(b))  # e.g., 2819127951552
10b.append(4)
11print(id(b))  # Same ID -> only the content has changed

Wie gezeigt, wird für unveränderliche Typen ein neues Objekt erstellt, während veränderliche Typen an Ort und Stelle geändert werden.

Funktionen und Vorsicht bei veränderlichen und unveränderlichen Objekten

Beim Übergeben eines veränderlichen Objekts an eine Funktion können die ursprünglichen Daten verändert werden.

Beispiel: Eine Funktion, die eine Liste modifiziert

1def modify_list(lst):
2    lst.append(100)
3
4my_list = [1, 2, 3]
5modify_list(my_list)
6print(my_list)  # [1, 2, 3, 100]

Beispiel: Eine Funktion, die eine Zahl verändert

Andererseits führt der Versuch, ein unveränderliches Objekt zu verändern, zur Erstellung eines neuen Objekts.

1def modify_number(n):
2    n += 10
3
4my_number = 5
5modify_number(my_number)
6print(my_number)  # 5 -> unchanged

Praktische Überlegungen

Vermeiden Sie die Verwendung veränderlicher Objekte als Standardargumente

 1# Bad example
 2def add_item(item, container=[]):
 3    container.append(item)
 4    return container
 5
 6print(add_item(1))  # [1]
 7print(add_item(2))  # [1, 2] -> unintended behavior
 8
 9# Good example
10def add_item(item, container=None):
11    if container is None:
12        container = []
13    container.append(item)
14    return container
15
16print(add_item(1))  # [1]
17print(add_item(2))  # [2]

Da Standardargumente nur einmal bei der Funktionsdefinition ausgewertet werden, kann die Verwendung veränderlicher Objekte zu unerwarteten Nebeneffekten führen.

• Im ersten Beispiel wird jedes Mal, wenn add_item aufgerufen wird, dasselbe Listenobjekt verwendet. Beim zweiten Aufruf von add_item(2) befindet sich das zuvor hinzugefügte 1 immer noch in der Liste, was zu [1, 2] führt.
• Im verbesserten Beispiel wird None als Standardwert verwendet, und innerhalb der Funktion wird eine neue Liste erstellt, wenn das Argument None ist. Dadurch wird sichergestellt, dass bei jedem Funktionsaufruf eine neue Liste erstellt wird, sodass vorherige Ergebnisse nachfolgende Aufrufe nicht beeinflussen.

Vermeiden Sie die Verwendung von veränderbaren Objekten wie Listen oder Dictionaries als Standardargumente; verwenden Sie stattdessen None und initialisieren Sie sie innerhalb der Funktion. Dies ist eine grundlegende und wichtige Best Practice in Python.

Zusammenfassung

Um Variablen und Datentypen in Python tiefgehend zu verstehen, ist es entscheidend, die Unterschiede zwischen veränderlichen und unveränderlichen Objekten zu begreifen. Das Verständnis dieser Eigenschaften hilft Ihnen, unbeabsichtigtes Verhalten in Ihrem Code zu vermeiden und robustere sowie besser lesbare Programme zu schreiben.

Sie können den obigen Artikel mit Visual Studio Code auf unserem YouTube-Kanal verfolgen. Bitte schauen Sie sich auch den YouTube-Kanal an.

YouTube Video