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

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.

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 ".

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.

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.

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!