MPK23-ZwischenlagerAus Attraktor WikiInhaltsverzeichnisDiese Seite dient zum Zwischenspeichern von Artikeln für den Micropythonkurs 2023FunktionenPositions- oder SchlüsselwortargumenteNamensräume
Python-Namespace – Die Psychologie hinter der dynamischen Programmierung
Rinu Gour
PythonFlood
Rinu Gour
·
Folgen
Veröffentlicht in
PythonFlood
·
5 Minuten gelesen
·
23. Mai
43
Python ist eine weit verbreitete High-Level-Programmiersprache, die aufgrund ihrer Einfachheit und Flexibilität an Popularität gewonnen hat. Es bietet verschiedene Funktionen, die das Schreiben und Verstehen von Code erleichtern. Eine dieser Funktionen ist das Konzept von Namespace und Scope.
In Python ist jede Variable, Funktion und jedes Objekt in einem bestimmten Namensraum definiert und hat einen bestimmten Gültigkeitsbereich. Für jeden Python-Programmierer ist es von entscheidender Bedeutung zu verstehen, wie Namespaces und Bereiche funktionieren.
Python-Namespace und -Bereich
Was ist Namespace?
In Python ist ein Namespace im Wesentlichen ein Container, der eine Reihe von Namen oder Bezeichnern zusammen mit den entsprechenden Objekten enthält. Stellen Sie sich das wie ein Verzeichnis vor, das Dateien enthält – der Namespace enthält die Namen und Objekte und das Verzeichnis enthält die Dateien.
Der Hauptzweck eines Namespace besteht darin, jedem Objekt in einem Programm einen eindeutigen Namen zu geben, damit die Objekte leicht identifiziert und darauf zugegriffen werden kann.
Arten von Namespaces:
In Python gibt es zwei Arten von Namespaces: Lokal und Global.
1. Lokaler Namespace:
Ein lokaler Namespace wird bei jedem Aufruf einer Funktion erstellt und enthält alle Namen oder Bezeichner, die innerhalb dieser Funktion definiert sind.
Auf den lokalen Namespace kann nur innerhalb der Funktion zugegriffen werden, und daran vorgenommene Änderungen werden außerhalb der Funktion nicht widergespiegelt.
Hier ist ein Beispiel eines von PythonFlood geschriebenen lokalen Namespace:
def my_function ():
x = 10
print (x)
my_function ()
In diesem Beispiel enthält der lokale Namespace nur einen Namen – „x“, der den Wert 10 hat. Wenn die Funktion aufgerufen wird, wird der Wert von „x“ auf der Konsole ausgegeben.
Sobald die Ausführung der Funktion abgeschlossen ist, wird der lokale Namespace zerstört.
2. Globaler Namespace:
Ein globaler Namespace wird erstellt, wenn ein Modul importiert oder definiert wird, und er enthält alle Namen oder Bezeichner, die außerhalb von Funktionen definiert werden.
Dies bedeutet, dass der globale Namespace im gesamten Programm zugänglich ist und alle Änderungen, die an den Namen oder Objekten im globalen Namespace vorgenommen werden, überall widergespiegelt werden.
Hier ist ein Beispiel für einen globalen Namespace:
x = 10
def my_function ():
print ( x )
my_function ()
In diesem Beispiel enthält der globale Namespace nur einen Namen – „x“, der den Wert 10 hat. Wenn die Funktion aufgerufen wird, wird der Wert von „x“ auf der Konsole ausgegeben. Da „x“ im globalen Namespace definiert ist, kann die Funktion darauf zugreifen. Alle Änderungen an „x“ innerhalb der Funktion wirken sich auch auf den Wert von „x“ außerhalb der Funktion aus.
Beispiel aus der Praxis mit Namespace:
Nehmen wir an, Sie sind Lehrer und möchten die Noten Ihrer Schüler im Auge behalten. Sie könnten ein Programm erstellen, das Namespaces verwendet, um die Namen und Noten der Schüler zu speichern.
Der globale Namespace würde die Namen der Schüler enthalten, während der lokale Namespace die Noten für jeden Schüler enthalten würde.
Hier ist ein von PythonFlood geschriebenes Beispiel:
Students = [ 'John' , 'Mary' , 'Bob' ]
def grades ():
john_grade = 85
mary_grade = 92
bob_grade = 78
print (students[ 0 ] + ': ' + str (john_grade))
print (students[ 1 ] + ': ' + str (mary_grade))
print (students[ 2 ] + ': ' + str (bob_grade))
grades()
In diesem Beispiel enthält der globale Namespace die Liste der Schüler, während der lokale Namespace die Noten für jeden Schüler enthält. Die Funktion „grades()“ gibt den Namen und die Note jedes Schülers auf der Konsole aus.
Da die Namen der Schüler im globalen Namensraum gespeichert sind, kann die Funktion auf sie zugreifen. Die Noten hingegen werden im lokalen Namespace gespeichert und sind nur innerhalb der Funktion zugänglich.
Regeln für die Namensraum- und Bereichsauflösung
Wenn es um die Namensraum- und Bereichsauflösung in Python geht, sind einige wichtige Regeln zu beachten:
Python verwendet eine LEGB-Regel (Local, Enclosing, Global, Built-in), um Namespaces und Bereiche aufzulösen. Python sucht nach einer referenzierten Variablen zuerst im lokalen Namespace, dann in allen umschließenden Namespaces, dann im globalen Namespace und schließlich im integrierten Namespace, der die integrierten Funktionen und Module von Python enthält.
Wenn eine Variable in einer Funktion definiert ist, wird davon ausgegangen, dass sie sich im lokalen Namensraum dieser Funktion befindet. Python sucht zunächst im lokalen Namensraum nach einer Variablen. Wenn sie nicht lokal definiert ist, sucht sie im umschließenden Namensraum ( (falls vorhanden) und fahren Sie in der Kette fort, bis die Variable gefunden wird oder der globale Namespace erreicht wird.
Wenn Sie eine Variable in einer Funktion definieren, wird sie standardmäßig als im lokalen Namespace liegend betrachtet. Um eine globale Variable innerhalb einer Funktion zu ändern, verwenden Sie das Schlüsselwort global, um anzugeben, dass die globale Variable verwendet werden soll, anstatt eine neue lokale Variable zu erstellen.
Hier ist ein Beispiel, das diese von PythonFlood geschriebenen Regeln veranschaulicht:
x = 1
def foo ():
x = 2
print ( "Inside foo:" , x)
def bar ():
global x
x = 3
print ( "Inside bar:" , x)
foo()
print ( "Outside foo: " , x)
bar()
print ( "Outside bar:" , x)
In diesem Beispiel definieren wir eine globale Variable x mit dem Wert 1. Anschließend definieren wir zwei Funktionen, foo und bar. foo erstellt eine neue Variable x mit dem Wert 2 in ihrem lokalen Namensraum und gibt sie aus. bar verwendet das Schlüsselwort global, um die globale Variable x zu ändern und auf 3 zu setzen.
Wenn wir foo aufrufen, gibt es den Wert von x in seinem lokalen Namensraum (der 2 ist) aus, aber wenn wir den Wert von x außerhalb von foo ausdrucken, sehen wir, dass er immer noch den Wert 1 hat. Das liegt daran, dass foo hat eine neue lokale Variable x erstellt, anstatt die globale Variable zu ändern.
Wenn wir bar aufrufen, ändert es die globale Variable x so, dass sie einen Wert von 3 hat. Wenn wir den Wert von x außerhalb von bar ausgeben, sehen wir, dass er auf 3 geändert wurde.
Best Practices für Namespace und Scope
Hier sind einige Best Practices für die Verwendung von Namespaces und Bereichen in Ihrem Python-Code:
Vermeiden Sie nach Möglichkeit die Verwendung globaler Variablen. Globale Variablen können das Lesen und Debuggen Ihres Codes erschweren, da es schwierig sein kann, den Überblick darüber zu behalten, wo eine Variable geändert wird.
Verwenden Sie beschreibende Variablennamen, um deutlich zu machen, wofür jede Variable verwendet wird. Dies kann dazu beitragen, Namenskonflikte zu vermeiden und Ihren Code verständlicher zu machen.
Verwenden Sie Funktionen und Klassen, um Code zu kapseln und Namensraumverschmutzung zu vermeiden. Indem Sie verwandten Code in Funktionen und Klassen gruppieren, können Sie die Anzahl der Variablen im globalen Namespace minimieren und die Überlegungen zu Ihrem Code erleichtern.
Vermeiden Sie die Verwendung von Wildcard-Importen (vom Modulimport *), da diese zu Namenskonflikten führen und das Aufspüren von Fehlern erschweren können.
Hier ist ein Beispiel dafür, wie Sie diese von PythonFlood geschriebenen Best Practices befolgen können:
def berechne_durchschnittlich ( Zahlen ):
„““
Berechnen Sie anhand einer Liste von Zahlen den Durchschnitt und geben Sie ihn zurück.
„““
total = sum (Zahlen)
count = len (Zahlen)
Durchschnitt = total / count
Zusammenfassend lässt sich sagen, dass das Verständnis des Konzepts von Namespace und Scope in Python für jeden Programmierer, der effizienten und effektiven Code schreiben möchte, von entscheidender Bedeutung ist. Namespaces und Scopes bieten eine Möglichkeit, Variablen und Funktionen in einem Python-Programm zu organisieren und darauf zuzugreifen.
Durch das Verständnis der verschiedenen Arten von Namespaces und Bereichen sowie der Lösungsregeln können Programmierer Namenskonflikte vermeiden und sicherstellen, dass ihr Code reibungslos läuft.
Best Practices für die Namensraum- und Bereichsverwaltung, wie die Vermeidung globaler Variablen und die Verwendung beschreibender Namenskonventionen, können ebenfalls dazu beitragen, die Lesbarkeit und Wartbarkeit von Code zu verbessern.
Insgesamt sind Namespaces und Bereiche wichtige Konzepte, die jeder Python-Programmierer verstehen muss, der hochwertigen, gut strukturierten Code schreiben möchte.
Zurück zu Micropython Kurs 2023 - Teil 1 |