Python-Zuweisung und -Referenz

Einführung

In diesem Lab werden wir die Grundlagen der Python-Zuweisung und -Referenz behandeln. Wir werden untersuchen, wie Python Zuweisungen behandelt, wie Referenzen erstellt werden und wie mit veränderlichen und unveränderlichen Objekten gearbeitet wird.

Skills Graph

Einführung in Python-Zuweisungen

In Python ist die Zuweisung der Prozess, bei dem einem Namen ein Objekt zugewiesen wird. Zuweisungsanweisungen haben die folgende allgemeine Form:

variable = expression

Der Ausdruck auf der rechten Seite wird ausgewertet, und sein Wert wird der Variablen auf der linken Seite zugewiesen.

Schauen wir uns ein einfaches Beispiel an:

Einfache Tests

Öffnen Sie das Terminal und geben Sie im Terminal den folgenden Befehl ein.

python3

Geben Sie dann den folgenden Code ein.

## Weisen Sie dem Variablen 'x' den Wert 42 zu und geben Sie ihn aus.
x = 42
print(x)

Ausgabe:

42

Hier weisen wir x mit dem Operator = der Variable 42 zu. Anschließend geben wir die Werte von x aus.

Das Verständnis von Referenzen

In Python sind Variablen Referenzen auf Objekte. Wenn Sie einem Variablen einen Wert zuweisen, erstellen Sie tatsächlich eine Referenz auf das Objekt, das den Wert repräsentiert.

Hier ist ein Beispiel, um diesen Begriff zu veranschaulichen:

## Veranschaulicht Python-Referenzen.
x = [1, 2, 3]
y = x
y.append(4)

print("x:", x)
print("y:", y)

Ausgabe:

x: [1, 2, 3, 4]
y: [1, 2, 3, 4]

In diesem Beispiel verweisen sowohl x als auch y auf dasselbe Listenobjekt. Wenn wir die Liste über die y-Referenz ändern, indem wir 4 anhängen, wird die Änderung sowohl in x als auch in y sichtbar.

Veränderliche und unveränderliche Objekte

Python hat zwei Arten von Objekten: veränderliche und unveränderliche.

Veränderliche Objekte können nach ihrer Erstellung geändert werden. Listen, Dictionaries und Mengen sind Beispiele für veränderliche Objekte.

Unveränderliche Objekte können nicht geändert werden, nachdem sie erstellt wurden. Integer, Floats, Strings und Tupel sind Beispiele für unveränderliche Objekte.

Schauen wir uns ein Beispiel an, das den Unterschied zwischen veränderlichen und unveränderlichen Objekten zeigt:

## Beispiel für ein veränderliches Objekt
mutable_list = [1, 2, 3]
another_mutable_list = mutable_list
another_mutable_list.append(4)
print("mutable_list:", mutable_list)

Ausgabe:

mutable_list: [1, 2, 3, 4]

mutable_list fügt am Ende der Liste eine 4 hinzu, weil es sich um ein veränderliches Objekt handelt, aber unveränderliche Objekte können nicht geändert werden, nachdem sie erstellt wurden.

## Beispiel für ein unveränderliches Objekt
immutable_string = "hello"
another_immutable_string = immutable_string
another_immutable_string = another_immutable_string.upper()
print("immutable_string:", immutable_string)

Ausgabe:

immutable_string: hello

Es ändert sich nicht, und wenn wir das immutable_string wie folgt ändern möchten, wirft die Python-Shell einen TypeError:

immutable_string[0] = '1'

Ausgabe:

TypeError: 'str' object does not support item assignment

Beispiele

Schauen wir uns ein paar weitere Beispiele an, um die Konzepte, die wir gelernt haben, zu vertiefen:

Beispiel 1: Funktion mit veränderlichem Standardargument

Vermeiden Sie die Verwendung von veränderlichen Objekten als Standardargumente in Funktionen:

def bad_append(new_item, a_list=[]):
    a_list.append(new_item)
    return a_list

print(bad_append('one'))

Ausgabe:

['one']

Es sieht gut aus, aber wenn wir diese Funktion erneut aufrufen:

print(bad_append('two'))

Ausgabe:

['one', 'two']

Das Problem hier ist, dass der Standardwert von a_list zur Funktiondefinitionszeit ausgewertet wird. Also wird jedes Mal, wenn Sie die Funktion aufrufen, derselbe Standardwert verwendet. Die richtige Methode ist es, ihn stattdessen zur Laufzeit innerhalb der Funktion zu erstellen.

def append_to_list(item: int, a_list: list = None) -> list:
    """Fügt ein Element einer Liste hinzu und gibt die aktualisierte Liste zurück."""
    if a_list is None:
        a_list = []
    a_list.append(item)
    return a_list

list_a = append_to_list(1, [1, 2, 3])
print(list_a)

Ausgabe:

[1, 2, 3, 1]

Beispiel 2: Kopieren von veränderlichen Objekten

Verwenden Sie das copy-Modul, um ein neues Objekt zu erstellen, wenn Sie eine Kopie eines veränderlichen Objekts verwenden möchten:

import copy

## Demonstriert die Verwendung des copy-Moduls.
original_list = [1, 2, 3]
copied_list = copy.copy(original_list)
copied_list.append(4)

print("original_list:", original_list)
print("copied_list:", copied_list)

Ausgabe:

original_list: [1, 2, 3]
copied_list: [1, 2, 3, 4]

In diesem Beispiel ist copied_list ein neues Objekt, das eine Kopie von original_list ist. Wenn wir 4 an copied_list anhängen, bleibt original_list unverändert.

Beispiel 3: Tiefkopieren von veränderlichen Objekten

Für geschachtelte veränderliche Objekte funktioniert die Verwendung der copy-Funktion nicht:

## Ihr Copy-Beispiel hier
original_nested_list = [[1, 2], [3, 4]]
copied_nested_list = copy.copy(original_nested_list)
copied_nested_list[0].append(5)

print("original_nested_list:", original_nested_list)
print("copied_nested_list:", copied_nested_list)

Ausgabe:

original_nested_list: [[1, 2, 5], [3, 4]]
copied_nested_list: [[1, 2, 5], [3, 4]]

Wir können sehen, dass wenn wir 5 an copied_nested_list anhängen, auch original_nested_list 5 anhängt. Sie sollten daher stattdessen die deepcopy-Funktion verwenden:

## Ihr Deepcopy-Beispiel hier
original_nested_list = [[1, 2], [3, 4]]
deep_copied_list = copy.deepcopy(original_nested_list)
deep_copied_list[0].append(5)

print("original_nested_list:", original_nested_list)
print("deep_copied_list:", deep_copied_list)

Ausgabe:

original_nested_list: [[1, 2], [3, 4]]
deep_copied_list: [[1, 2, 5], [3, 4]]

In diesem Beispiel kopiert die deepcopy-Funktion das original_nested_list rekursiv, während die copy-Funktion ein Referenzobjekt auf die ersten Ebenen der Daten von original_nested_list erstellt.

Zusammenfassung

In diesem Python-Programmier-Tutorial haben wir die Grundlagen der Python-Zuweisung und -Referenz behandelt. Wir haben untersucht, wie Python Zuweisungen behandelt, wie Referenzen erstellt werden und wie mit veränderlichen und unveränderlichen Objekten umgegangen wird. Indem Sie diese Konzepte verstehen, werden Sie in der Lage sein, effizientes und korrektes Python-Code zu schreiben.