Einführung in häufige Fehler bei der Verwendung von Python-Variablen

Bei der Python-Programmierung stoßen wir oft auf unerklärliche Fehler. Tatsächlich ist dies kein Problem mit der Sprache selbst, sondern dadurch, dass wir einige Eigenschaften der Sprache selbst ignorieren. Heute werfen wir einen Blick auf drei unglaubliche Fehler, die dadurch verursacht werden Fehler bei der Verwendung von Python-Variablen, bitte achten Sie bei der zukünftigen Programmierung stärker darauf.

1. Variable Datentypen werden als Standardparameter in Funktionsdefinitionen verwendet

Das scheint richtig zu sein? Sie schreiben eine kleine Funktion, die beispielsweise auf der aktuellen Seite nach einem Link sucht und diesen optional an eine andere bereitgestellte Liste anhängt.

def search_for_links(page, add_to=[]):
    new_links = page.search_for_links()
    add_to.extend(new_links)
    return add_to

Oberflächlich betrachtet sieht dies wie ganz normaler Python-Code aus, und tatsächlich ist er es auch, und er kann ausgeführt werden. Es gibt jedoch ein Problem. Wenn wir dem Parameter add_to eine Liste zur Verfügung stellen, funktioniert es wie erwartet. Aber wenn wir es den Standardwert verwenden lassen, passiert etwas Magisches.

Probieren Sie den folgenden Code aus:

def fn(var1, var2=[]):
    var2.append(var1)
    print(var2)
fn(3)
fn(4)
fn(5)

Vielleicht denken Sie, wir werden Folgendes sehen:

[3]
[4]
[5]

Aber tatsächlich sehen wir Folgendes:

[3]
[3,4]
[3,4,5]

Warum? Wie Sie sehen, wird jedes Mal dieselbe Liste verwendet. Warum ist die Ausgabe so? Wenn wir in Python eine solche Funktion schreiben, wird diese Liste als Teil der Funktionsdefinition instanziiert. Wenn eine Funktion ausgeführt wird, wird sie nicht jedes Mal instanziiert. Das bedeutet, dass diese Funktion immer genau dasselbe Listenobjekt verwendet, es sei denn, wir stellen ein neues Objekt bereit:

fn(3,[4])
[4,3]

Die Antwort ist genau das, was wir gedacht haben. Um dieses Ergebnis zu erhalten, ist der richtige Weg:

def fn(var1, var2=None):
    ifnot var2:
        var2 =[]
    var2.append(var1)

oder im ersten Beispiel:

def search_for_links(page, add_to=None):
    ifnot add_to:
        add_to =[]
    new_links = page.search_for_links()
    add_to.extend(new_links)
    return add_to

Dadurch wird die Instanziierung entfernt, wenn der Inhalt des Moduls geladen wird, sodass eine Listeninstanziierung erfolgt jedes Mal, wenn die Funktion ausgeführt wird. Bitte beachten Sie, dass diese Situation bei unveränderlichen Datentypen wie Tupeln, Zeichenfolgen und Ganzzahlen nicht berücksichtigt werden muss. Dies bedeutet, dass Code wie der folgende sehr gut machbar ist:

def func(message="my message"):
    print(message)

2. Veränderbare Datentypen als Klassenvariablen

Dies ist dem letzten oben erwähnten Fehler sehr ähnlich. Betrachten Sie den folgenden Code:

class URLCatcher(object):
    urls =[]
    def add_url(self, url):
        self.urls.append(url)

Dieser Code sieht völlig normal aus. Wir haben ein Objekt, das URLs speichert. Wenn wir die Methode add_url aufrufen, fügt sie dem Speicher eine bestimmte URL hinzu. Sieht ziemlich gut aus, oder? Mal sehen, wie es tatsächlich aussieht:

a =URLCatcher()
a.add_url('http://www.google.com')
b =URLCatcher()
b.add_url('http://www.pythontab.com')
print(b.urls)
print(a.urls)

Ergebnis:

['http://www.google.com','http://www.pythontab.com']
['http://www.google.com','http://www.pythontab.com']

Moment, was ist los? ! Das haben wir nicht gedacht. Wir instanziieren zwei separate Objekte a und b. Geben Sie eine URL an a und eine andere an b. Wie kommt es, dass diese beiden Objekte diese beiden URLs haben?

Dies ist das gleiche Problem wie im ersten Fehlerbeispiel. Wenn die Klassendefinition erstellt wird, wird die URL-Liste instanziiert. Alle Instanzen dieser Klasse verwenden dieselbe Liste. Es gibt Zeiten, in denen dies nützlich ist, aber meistens möchten Sie es nicht tun. Sie möchten für jedes Objekt einen separaten Speicher. Dazu ändern wir den Code wie folgt:

class URLCatcher(object):
    def __init__(self):
        self.urls =[]
    def add_url(self, url):
        self.urls.append(url)

Wenn nun das Objekt erstellt wird, wird die URL-Liste instanziiert. Wenn wir zwei separate Objekte instanziieren, verwenden sie jeweils zwei separate Listen.

3. Variablenzuordnungsfehler

Dieses Problem beschäftigt mich schon seit einiger Zeit. Nehmen wir einige Änderungen vor und verwenden wir einen anderen veränderlichen Datentyp – ein Wörterbuch.

a ={'1':"one",'2':'two'}

Angenommen, wir möchten dieses Wörterbuch woanders verwenden und dabei die Originaldaten beibehalten.

b = a
b['3']='three'

Einfach, oder?

Schauen wir uns nun das ursprüngliche Wörterbuch a an, das wir nicht ändern möchten:

{'1':"one",'2':'two','3':'three'}

Wow, Moment, schauen wir uns noch einmal b an?

{'1':"one",'2':'two','3':'three'}

Warte, was? Etwas chaotisch ... Lassen Sie uns einen Schritt zurückgehen und sehen, was in diesem Fall mit anderen unveränderlichen Typen wie einem Tupel passiert:

c =(2,3)
d = c
d =(4,5)

Jetzt ist c (2, 3) und d ist (4, 5). ).

Das Ergebnis dieser Funktion ist wie erwartet. Was genau ist im vorherigen Beispiel passiert? Bei Verwendung eines veränderlichen Typs verhält er sich in etwa wie ein Zeiger in C. Im obigen Code sei b = a, was wir eigentlich meinen: b wird eine Referenz von a. Sie verweisen alle auf dasselbe Objekt im Python-Speicher. Kommt Ihnen das bekannt vor? Das liegt daran, dass diese Frage der vorherigen ähnelt.

Wird das Gleiche auch mit Listen passieren? Ja. Wie lösen wir es? Dies muss sehr sorgfältig erfolgen. Wenn wir wirklich eine Liste zur Verarbeitung kopieren müssen, können wir Folgendes tun:

b = a[:]

Dadurch wird die Referenz jedes Objekts in der Liste durchlaufen, kopiert und in eine neue Liste eingefügt. Aber Vorsicht: Wenn jedes Objekt in der Liste veränderbar ist, erhalten wir erneut eine Referenz darauf und keine vollständige Kopie.

Angenommen, Sie erstellen eine Liste auf einem Blatt Papier. Im Originalbeispiel ist es gleichbedeutend damit, dass A und B auf dasselbe Blatt Papier schauen. Wenn eine Person diesen Eintrag ändert, sehen beide Personen die gleichen Änderungen. Wenn wir die Referenzen kopieren, hat nun jeder seine eigene Liste. Wir gehen jedoch davon aus, dass diese Liste Orte enthält, an denen man Essen finden kann. Wenn „Kühlschrank“ an erster Stelle in der Liste steht, verweisen die Einträge in beiden Listen auch beim Kopieren auf denselben Kühlschrank. Wenn also der Kühlschrank von A modifiziert wird und der große Kuchen darin isst, wird B auch das Verschwinden des Kuchens sehen. Hier führt kein einfacher Weg daran vorbei. Denken Sie daran und schreiben Sie Ihren Code so, dass dieses Problem nicht auftritt.

字典以相同的方式工作，并且你可以通过以下方式创建一个昂贵副本：

b = a.copy()

再次说明，这只会创建一个新的字典，指向原来存在的相同的条目。因此，如果我们有两个相同的列表，并且我们修改字典 a 的一个键指向的可变对象，那么在字典 b 中也将看到这些变化。

可变数据类型的麻烦也是它们强大的地方。以上都不是实际中的问题；它们是一些要注意防止出现的问题。在第三个项目中使用昂贵复制操作作为解决方案在 99% 的时候是没有必要的。

Das obige ist der detaillierte Inhalt vonEinführung in häufige Fehler bei der Verwendung von Python-Variablen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!