Umfassende Anleitung zu Python -Namespaces und variablen Scopes

Einführung

Das Verständnis der Namespaces, Scopes und des Verhaltens von Variablen in Python -Funktionen ist entscheidend, um effizient zu schreiben und Laufzeitfehler oder Ausnahmen zu vermeiden. In diesem Artikel werden wir uns mit verschiedenen Aspekten von Namespaces und Python -variablen Reichweiten befassen und erfahren, wie Python lokale, globale und beitrete Variablen ausführlich verwaltet.

Wir haben bereits Python -Funktionen detailliert besprochen, was zu finden ist. Python verwendet Abstraktionsgrundsätze, um komplexe Logik zu verbergen und nur die erforderlichen Ausgänge aufzudecken, während die Zersetzung modulare, lesbare und wiederverwendbare Funktionen erzeugt.

Diese Prinzipien sind offensichtlich genug, um zu verstehen, wie Python seine variablen Bereiche für eine Funktionsdefinition und verschachtelte Funktionen umgeht, die wir durch detaillierte Beispiele untersuchen werden. Am Ende dieses Artikels sollten Sie diese Konzepte klar verstehen und wie Sie sie effektiv in Ihren Programmen anwenden.

Überblick

• Pythons Namespaces und variable Bereiche sind für eine effiziente Codierung und Fehlerverhütung von entscheidender Bedeutung.
• Der Artikel untersucht das Verhalten der lokalen, globalen und umschließenden Variablen in Python.
• Die Legb -Regel beschreibt die variable Namensuche von Python über verschiedene Bereiche hinweg.
• Praktische Beispiele zeigen die globale und lokale variable Verwendung und Änderung.
• Verschachtelte Funktionen und umschließender Umfang werden abgedeckt, wodurch das nichtlokale Schlüsselwort betont wird.

Inhaltsverzeichnis

• Was sind die Variablen in Python?
  • Globale Variablen
  • Lokale Variablen
• Was sind die Namespaces?
• Was sind die variablen Bereiche in Python?
• Was ist die Beinregel?
• Wie kann Python -variable Bereiche?
  • 1. Verwenden Sie die globale Variable im lokalen Bereich verwenden
  • 2. Lokale Variable im lokalen Bereich verwenden
  • 3.. Ändern der globalen Variablen im lokalen Bereich
  • 4. Modifizierung der globalen Variablen im lokalen Bereich mithilfe einer Deklaration
  • 5. Modifizierung des lokalen Bereichs der globalen Variable in der Funktion mit Funktion
• Was sind die verschachtelten Funktionen?
• Was ist ein umschließender Umfang einer Variablen?
  • 7.modifizieren der globalen Variablen innerhalb des Umschlusses ohne Deklaration
  • 8. Ändern der verschachtelten Variablen im lokalen Bereich mithilfe einer Deklaration
• Häufig gestellte Fragen

Was sind die Variablen in Python?

Variablen in Python sind Container, die Daten oder Werte speichern (wie int, float, str, bool usw.). Der Speicherort, an dem eine Variable gespeichert und auch für die zukünftige Verwendung zugänglich ist, wird als Thescope einer Variablen bezeichnet.

In Python gibt es zwei Arten von Variablen, nämlich:

Globale Variablen

• Diese Variablen werden unter den Geltungsbereich des Hauptprogramms geraten.
• Das Hauptprogramm kann die lokale Variable nicht verwenden, da es nur für die Funktion verfügbar ist.

Lokale Variablen

• Diese Variablen werden unter den Funktionsumfang.
• Außerdem kann die lokale Variable die globale Variable innerhalb der Funktion verwenden, wenn die lokale Variable im lokalen Bereich nicht definiert ist.

Lesen Sie auch: Veränderlich gegenüber unveränderlichen Objekten in Python

Was sind die Namespaces?

Der Python -Namespace ist Aspace oder Wörterbuch, das Kennungen (allgemein als Variablennamen bezeichnete Namen) als Tasten und ihre jeweiligen Objekte als Werte im Speicherraum enthält. Python -Programmiersprache Has4 Arten von Namespaces, nämlich:

• Eingebauter Namespace
• Globaler Namespace
• Namespace einschließen
• Lokaler Namespace

Wir werden uns bald verschiedene Beispiele ansehen, um dieses Konzept besser zu verstehen. Aber vorher ist es wirklich wichtig, die oben genannten variablen Bereiche zu verstehen.

Was sind die variablen Bereiche in Python?

In Python bezieht sich Scope auf den Bereich oder die Textregion eines Programms, in der die Variablen direkt zugänglich sind. Bei der Ausführung gibt es: Es gibt:

• Lokaler Bereich : Dies ist das innerste Umfang, der in einer Funktion definiert ist. Für diesen Bereich sucht Python nach der lokalen Variablen.
• Umfang der Umfang : Dies sind die Bereiche der verschachtelten Funktionen. Sie enthalten nicht lokale Variablen, die weder lokal noch global sind.
• Globaler Bereich : Dieser Bereich enthält die auf Modulebene definierten Variablen und ist im gesamten Modul zugänglich.

Hinweis: Sie erstellen diese benutzerdefinierten Bereiche in Ihrem Programm, um sie effizient auszuführen. Die integrierten Variablen von Python haben jedoch auch einen als eingebauten Umfang.

• Eingebauter Bereich : Dies ist der Umfang aller vordefinierten Schlüsselwörter oder Methoden, die Python für das Schreiben besserer Codes anbietet. Daher stehen Ihnen diese zur Verfügung, sobald der Python -Dolmetscher beginnt. Beachten Sie auch, dass diese Bereiche nie gelöscht werden und im gesamten Modul zugänglich sind.

Was ist die Beinregel?

Jetzt haben Sie ein grundlegendes Verständnis von Namespaces und variablen Umfang. Tauchen wir tiefer ein, um zu verstehen, wie Scoping -Regeln in der Python -Programmiersprache angewendet werden. Es gibt eine gemeinsame Abkürzung, eine Legb-Regel, die verlassen, eingeschlossen, global und eingebaut ist.

Legb -Regel besagt, dass der Interpreter von innen nach einem Kenner suchen kann, was bedeutet, dass er zunächst nach einem variablen Namen oder Namespace sucht. Wenn der Namespace dort nicht vorhanden ist, wird er in Richtung des umschließenden Umfangs Ihres Programms bewegt. Ext, es überprüft den globalen Bereich, um den Namespace zu finden. Wenn der Kennung noch nicht gefunden wird, befasst sich der Dolmetscher auf den integrierten Bereich von Python.

Wenn der Dolmetscher den Namen in keinem dieser Orte findet, erhöht Python eine Ausnahme von nameError " , was bedeutet, dass die Variable im Programm nicht definiert ist.

Es ist auch sehr wichtig, sich daran zu erinnern, dass Sie sich in der Hierarchie der Legb -Regel aus dem aktuellen Bereich nach oben bewegen müssen .

Lesen Sie auch: umfassende Anleitung zur fortschrittlichen Python -Programmierung

Wie kann Python -variable Bereiche?

Lassen Sie uns nun durch all diese Beispiele eins von anderen auf, um all diese Konzepte ausführlich zu verstehen:

1. Verwenden Sie die globale Variable im lokalen Bereich verwenden

Um dies zu verstehen, nehmen wir ein Beispiel: Hier druckt die Funktion ` g (y) ` nicht nur die globale Variable ` x` , sondern modifiziert sie auch als " x 1 ".

Da "x " in " G (y)" nicht definiert ist, holt Python den Wert der globalen Variablen ` x` ab.

 Def g (y):
  Druck (x)
  drucken (x 1)

# Da X nicht im lokalen Bereich ist, wird es den Wert von X aus der globalen Variablen holen
x = 1
g (x) # Globale Innere lokale Variable
Druck (x) # Globale Variable

Ausgabe

 1<br><br> 2<br><br> 1

Die Ausgabe zeigt den Wert von "x` und " x 1 ", der bestätigt, dass die globale Variable "x " unverändert bleibt, aber vom lokalen Bereich verwendet wurde, damit die Ergebnisse ordnungsgemäß ausgegeben werden.

2. Lokale Variable im lokalen Bereich verwenden

Schauen Sie sich dieses Beispiel an, hier haben wir eine Funktionsdefinition ` g (y) ` und innerhalb der folgenden angegebenen Funktion ` g` wird der Name ` x` als lokale Variable definiert und auch modifiziert.

 Def g (y):
  x = 10 # Lokale Variable
  x = 1
  Druck (x)


x = 1 # Globale Variable
g (x)
Druck (x)

Ausgabe

 11<br><br> 1

Als Beweis bleibt das globale " x " unverändert, und die lokale Variable verwendete seine lokale Bereichsvariable, um die Anweisungen zu drucken, die 11 als Ausgabe durch die Funktion und 1 Ausgabe nach dem globalen Bereich wie erwartet zeigen.

Lesen Sie auch: umfassende Anleitung zu Python-integrierten Datenstrukturen

3.. Ändern der globalen Variablen im lokalen Bereich

Aber ist es möglich, die globale Variable zu ändern "x ", ohne sie als " global " zu erklären?

Die Antwort lautet nein! Sie können keinen globalen variablen Wert aus dem lokalen Bereich ändern, da dies zu einem Fehler führt.

 Def H (y):

  # Funktion kann globale Variable verwenden, wenn sie keine hat
  x = 10 #, kann aber den globalen Wert innerhalb der lokalen Variablen nicht ändern

x = 1
H (x)
Druck (x)

Ausgabe

 Ungebundener Traceback (neulicher Anruf letztes)<br><br> <ipython-input-3-130c677cc9ab> in <zelllinie:> ()<br><br> 3<br><br> 4 x = 1<br><br> ----> 5 h (x)<br><br> 6 Druck (x)<br><br> <ipython-input-3-130c677cc9ab> in H (y)<br><br> 1def H (y):<br><br> ----> 2 x = 10<br><br> 3<br><br> 4 x = 1<br><br> 5 h (x)</ipython-input-3-130c677cc9ab></zelllinie:></ipython-input-3-130c677cc9ab>

Ungebundener ERROR: Lokale Variable "X` Bezogen vor der Zuweisung

Dies führt zu einem " ungebundenen ERRORError ", weil Python aufgrund der Zuordnungsoperation "x " als lokale Variable behandelt, aber nicht lokal initialisiert wurde. Obwohl lokale Variablen auf globale Variablen zugreifen können, können Sie auch nicht Änderungen an der globalen Variablen vornehmen (Sie können nur lesen, nicht schreiben).

Lesen Sie auch: Grundlagen der Python -Programmierung für Anfänger

4. Modifizierung der globalen Variablen innerhalb des lokalen Bereichs mithilfe einer Deklaration

Aber da ich Ihnen immer gesagt habe, dass Python tatsächlich eine süße Sprache ist und obwohl es nicht empfohlen wird, Änderungen oder Änderungen an der globalen Variablen vorzunehmen. Das bedeutet nicht, dass Python Ihnen diese Funktionalität nicht gibt, da die Funktion "X" als "global" mit demselben Schlüsselwort die globale Variable `x` ändern kann.

 Def H (y):
  Global X # jetzt kann es den globalen Wert innerhalb der lokalen Variablen verändern
  # Dies ist jedoch keine gute Art der Codierung, Sie sollten sich darauf konzentrieren, diese globale Keyword -Nutzung zu verringern
  x = 10

x = 1
H (x)
Druck (x)

Ausgabe

 11

Die Ausgabe bestätigt, dass " x " weltweit aktualisiert wurde. Denken Sie jedoch daran, dass sich die Änderungen auf das gesamte Programm auswirken, da die Änderung der Hauptfunktion auch andere Funktionen beeinflusst, was keine gute Programmierpraxis ist.

5. Modifizierung des lokalen Bereichs der globalen Variable in der Funktion mit Funktion

Außerdem können Sie die globale Variable in der Funktion ` g (x)` ` durch inkrementieren " x `um 10) ändern. Es wird den neuen Wert drucken und zurückgeben.

HINWEIS : Dies bedeutet nicht, dass Sie die globale Variable selbst ändern, wie es sowieso ohne das Schlüsselwort "Global" möglich ist.

 def g (x):
  x = 10
  print ("in f (x): x =", x)
  Return X # Rückgabe f (x)

x = 2
z = g (x)
print ("im Hauptprogramm Umfang: z =", z)
print ("im Hauptprogramm Umfang: x =", x)

Ausgabe

 in f (x): x = 12<br><br> im Hauptprogrammbereich: z = 12<br><br> Im Hauptprogrammbereich: x = 2

Hier bleibt der globale " x " unverändert, während der zurückgegebene Wert ` z` der neue aktualisierte Wert ist.

Was sind die verschachtelten Funktionen?

Die Funktionen, die in einer anderen " definitiven Funktion" definiert sind, werden als verschachtelte Funktionen oder innere Funktionen bezeichnet.

Hier ist ein Beispiel für eine verschachtelte Funktion für ein besseres Verständnis:

 def f ():
  def g ():
    print ("Inside -Funktion G")
  G()
  print ("Inside -Funktion f")

F()

Ausgabe

 Inside -Funktion g<br><br> Innenfunktion f

HINWEIS : Die verschachtelte Funktion ` g` wird innerhalb der Funktion ` f` aufgerufen, die Nachrichten aus beiden Funktionen druckt. Aufrufen der Funktion ` g` außerhalb der Fehler in einem Fehler, da " G " nicht im globalen Bereich definiert ist.

 g () # Diese Funktion ist außerhalb der Funktion f nicht definiert

Ausgabe

 TypeError Traceback (letzte Anruflast)<br><br> <ipython-input-8-5fd69ddb5074> in <zelllinie:> ()<br><br> ----> 1 g ()<br><br> TypeError: g () Fehlende 1 Erforderliche Positionsargument: 'x'</zelllinie:></ipython-input-8-5fd69ddb5074>

Was ist ein umschließender Umfang einer Variablen?

Python bietet nur die Namen, die in der verschachtelten Funktion definiert sind, einen anderen und speziellen variablen Bereich, der als umschließender Umfang bezeichnet wird. Es ist auch als " nicht-lokaler " Umfang bekannt. Das Einschließen des Umfangs ist der Umfang der äußeren Funktion, wenn es eine lokale Funktion gibt, die eine innere oder verschachtelte Funktion ist.

 def f ():
  x = 1
  def g ():
    print ("Inside -Funktion G")
    Druck (x)
  G()
  print ("Inside -Funktion f")
  
F()

Diese Variable `x` ist im umschließenden Umfang vorhanden, den Sie auch im lokalen Bereich verwenden können, wie im obigen Beispiel gezeigt. Hier ist es Ausgabe:

Ausgabe

 Inside -Funktion g<br><br> 1<br><br> Innenfunktion f

Lassen Sie uns nun weiterentwickeln und diesen neuen Bereich besser verstehen.

7.modifizieren der globalen Variablen innerhalb des Umschlusses ohne Deklaration

Auch hier ist das Ändern der globalen Variablen ` x` innerhalb der verschachtelten Funktion unmöglich .

 def g (x):
  def H ():
    x = 1
    print ('in h (x): x =', x)
  x = x 1
  print ('in g (x): x =', x)
  H (x)
  Rückkehr x

x = 3
z = g (x)
print ('im Hauptprogramm Umfang: x =', x)
print ('im Hauptprogramm Scope: Z =', Z)

Ausgabe

 in g (x): x = 4<br><br> -----------------------------------------------------------------------<br> TypeError Traceback (letzte Anruflast)<br><br> <ipython-input-12-5bcfb2edb396> In <zelllinie:> ()<br><br> 9<br><br> 10 x = 3<br><br> ---> 11 z = g (x)<br><br> 12 Print ('im Hauptprogramm Umfang: x =', x)<br><br> 13 Print ('im Hauptprogramm Umfang: Z =', Z)<br><br> <ipython-input-12-5bcfb2edb396> in G (x)<br><br> 5 x = x 1<br><br> 6 print ('in g (x): x =', x)<br><br> ----> 7 h (x)<br><br> 8 Return x<br><br> 9<br><br> TypeError: g. <locals> .h () nimmt 0 Positionsargumente ein, aber 1 wurde gegeben</locals></ipython-input-12-5bcfb2edb396></zelllinie:></ipython-input-12-5bcfb2edb396>

Da die Funktion ` h () `, wird ohne Parameter definiert, aber `H (x)` wird mit einem Argument aufgerufen. Dies ergibt eine "TypeError ".Also, obwohl die einschließende Variable auf die globale Variable zugreifen kann, können Sie keine Änderungen in der globalen Variablen vornehmen.

8. Ändern der verschachtelten Variablen im lokalen Bereich mithilfe einer Deklaration

Ähnlich wie das " Global " -Spython bietet Python seinen Entwicklern ein " nichtlokales " Keyword. Dadurch kann die verschachtelte Funktion ` H` die in der eingeschlossene Funktion ` g` definierte Variable "x` definiert.

 def g (x):
  def H ():
    Nichtlokaler X # Sagen Sie H (), X von G (x) zu verwenden
    x = 1
    print ('in h (x): x =', x)
  x = x 1
  print ('in g (x): x =', x)
  h () # rufen Sie H () ohne Argumente an
  Rückkehr x

x = 3
z = g (x)
print ('im Hauptprogramm Umfang: x =', x)
print ('im Hauptprogramm Scope: Z =', Z)

Ausgabe

 in g (x): x = 4<br><br> in h (x): x = 5<br><br> im Hauptprogrammbereich: x = 3<br><br> Im Hauptprogrammbereich: z = 5

Die Ausgänge zeigen die in beiden Funktionen vorgenommenen Änderungen und dass die globale Variable ` x` unverändert bleibt.

Beachten Sie schließlich, dass jedes Umfang unterschiedlichen Zugriffsebenen im gesamten Programm entspricht und eine unterschiedliche Lebensdauer für den Namespace/s innerhalb des Code hat, je nachdem, wo die Bereiche definiert sind.

Lesen Sie auch: Ein vollständiges Python -Tutorial zum Erlernen von Datenwissenschaft von Grund auf neu

Abschluss

In diesem Artikel wurde untersucht, wie Python lokale und globale Variablen und verschachtelte Funktionen umgeht. Wir haben erfahren, dass ein Namespace ein Wörterbuch ist, das Python Entwicklern anbietet, aus denen Sie einen variablen Namen und seinen Wert finden können, der im Bereich des Python -Speichers gespeichert ist. Darüber hinaus sind die Bereiche von vier Arten: lokal, eingeschlossen, global und eingebaut.

Diese sind wirklich nützlich, um Konflikte zu vermeiden und zu verfolgen, welche Namen/Kennungen auf welche Objekte in den verschiedenen Teilen des Programms verweisen.

Wenn Sie eine Variable im globalen Bereich aus dem lokalen Bereich ändern möchten, können Sie das globale Schlüsselwort " Global " verwenden. In ähnlicher Weise können Sie das Schlüsselwort "Nicht -Local" verwenden, um den Umfang zu schließen.

1. Lokaler Bereich : Variablen, die in einer Funktion erstellt wurden, die nur innerhalb dieser Funktion zugänglich ist, und gelöscht werden, wenn die Funktion zurückgibt oder eine Ausnahme erhöht wird, dh beim Schreiben der Funktion nicht gehandhabt.
2. Einschließlicher oder nicht lokaler Umfang : Variablen, die in der äußeren Funktion verschachtelter Funktionen erstellt wurden und für die innere Funktion zugänglich sind.
3. Globaler Bereich : Variablen, die im ` __main__` -Programm erstellt wurden, das im gesamten Programm zugänglich ist und bis zum Ende des Dolmetschers zugänglich ist.

Ich hoffe, dies hat Ihnen geholfen, Einblicke in das Schreiben von Codes auf Produktionsebene zu erhalten, wobei Sie branchenbezogenen Best Practices verfolgen und Entwickler definierte Ausnahmen reduzieren. Dies ist jedoch der erste Schritt, um unser Programm robuster zu machen, und wir haben viel mehr zu verdecken.

Seien Sie also gespannt auf den nächsten Artikel, in dem wir die Serialisierung und Deserialisierung der Datei in der Python -Programmiersprache diskutieren werden!

Häufig gestellte Fragen

Q1. Was ist der Namespace in Python?

Ans. Namespaces in Python organisieren und verwalten die Namen oder Kennungen in einem Programm. Grundsätzlich handeln sie wie Container oder Wörterbücher, die Namen speichern, die ihren Objekten wie Variablen und Funktionen zugeordnet sind.

Q2. Wie lautet die Legb -Regel in Python?

Ans. Die Legb -Regel in Python ist die Reihenfolge, in der ein Python -Dolmetscher aufsieht, während er mit den Namen oder allgemein als Kennleistung bezeichnet wird. Es steht für lokale, umschließende, globale und eingebaute: eingebaut:
1. LOCAL : In einer Funktion definierten Namen.
2. Einschließen : Namen im örtlichen Bereich einer schließenden Funktion (verschachtelte Funktion).
3. Global : Namen auf der obersten Ebene eines Skripts oder Moduls.
Eingebaut : Namen, die in Python vorgeprägt sind, wie " Print` oder " Len ".

Q3. Was nutzt das Schlüsselwort "Global" in Python?

Ans. Das globale Schlüsselwort ermöglicht es einer Funktion, eine im globalen Bereich definierte Variable zu ändern, und ermöglicht die Variablen, außerhalb des Betriebs zu sein. Hinweis: Nur weil Sie es können, heißt das nicht, dass Sie dies (oft) verwenden sollten, da es keine gute Programmierpraxis ist.

Q4. Warum wird empfohlen, die Verwendung globaler Variablen zu minimieren?

Ans. Überbeanspruchung globaler Variablen kann zu Programmen führen, die schwer zu verstehen und aufrechtzuerhalten. Es kann auch unbeabsichtigte Veränderungen verursachen und das Debuggen erschweren. Es ist im Allgemeinen besser, lokale Variablen zu verwenden und nach Bedarf zu bestehen.

Q5. Was nutzen das "nichtlokale" Schlüsselwort in verschachtelten Funktionen?

Ans. Ähnlich wie bei globalen Schlüsselwörtern bietet Python "nicht lokale" Keywords, um die umschließenden Variablen zu ändern. Die nicht-lokalen Schlüsselwörter können Variablen ändern, die in der beigefügten Funktion einer verschachtelten Funktion definiert sind und eine Möglichkeit bieten, den variablen Umfang in verschachtelten Funktionen zu steuern.

Das obige ist der detaillierte Inhalt vonUmfassende Anleitung zu Python -Namespaces und variablen Scopes. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!