Bezeichner in Python verstehen

Einleitung

In diesem Lab erhalten Sie ein umfassendes Verständnis von Bezeichnern (Identifiers) in Python. Sie lernen die grundlegenden Regeln kennen, die festlegen, wie Variablen, Funktionen, Klassen und andere Objekte in Ihrem Python-Code benannt werden.

Durch praktische Übungen identifizieren Sie gültige und ungültige Bezeichnernamen und festigen die Namenskonventionen. Das Lab behandelt auch spezielle Bezeichnerkonventionen, die in Python verwendet werden, und stattet Sie mit dem Wissen aus, um klaren, lesbaren und wartbaren Code zu schreiben.

Regeln für Bezeichnernamen lernen

In diesem Schritt lernen wir die Regeln für die Benennung von Bezeichnern (Identifiers) in Python. Bezeichner sind Namen, die zur Identifizierung von Variablen, Funktionen, Klassen, Modulen und anderen Objekten in einem Programm verwendet werden. Das Verständnis der Benennungsregeln ist entscheidend für das Schreiben von lesbarem und wartbarem Code.

Wie in der Einleitung erwähnt, müssen Python-Bezeichner diesen Regeln folgen:

• Bezeichner können Buchstaben (a-z, A-Z), Ziffern (0-9) und Unterstriche (_) enthalten.
• Das erste Zeichen eines Bezeichners darf keine Ziffer sein.
• Bezeichner dürfen keine Leerzeichen oder Sonderzeichen wie @, %, $, * usw. enthalten.
• Bezeichner sind case-sensitiv (Groß- und Kleinschreibung wird unterschieden). myVariable und myvariable werden als unterschiedliche Bezeichner betrachtet.
• Sie dürfen keine Python-Schlüsselwörter oder Namen von integrierten Funktionen als Bezeichner verwenden.

Lassen Sie uns eine einfache Python-Datei erstellen, um das Definieren einiger Bezeichner zu üben.

Öffnen Sie das integrierte Terminal in der WebIDE, indem Sie auf Terminal -> New Terminal klicken. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.

Erstellen Sie nun eine neue Python-Datei namens identifier_rules.py im Verzeichnis ~/project mit dem VS Code-Editor. Sie können dies tun, indem Sie im Dateiexplorer-Bereich auf der linken Seite mit der rechten Maustaste klicken und New File auswählen, oder indem Sie die Befehlspalette (Ctrl+Shift+P oder Cmd+Shift+P) verwenden und File: New File eingeben. Benennen Sie die Datei identifier_rules.py.

Geben Sie in die Datei identifier_rules.py den folgenden Code ein:

## Dies ist ein gültiger Bezeichner
my_variable = 10

## Dies ist ebenfalls ein gültiger Bezeichner
anotherVariable = "Hello"

## Dies ist ein gültiger Bezeichner, der mit einem Unterstrich beginnt
_private_variable = True

## Dies ist ein ungültiger Bezeichner (beginnt mit einer Ziffer)
## 1st_variable = 5

## Dies ist ein ungültiger Bezeichner (enthält ein Leerzeichen)
## my variable = "invalid"

## Dies ist ein ungültiger Bezeichner (enthält ein Sonderzeichen)
## my-variable = 20

## Dies ist ein ungültiger Bezeichner (verwendet ein Schlüsselwort)
## if = 30

print(my_variable)
print(anotherVariable)
print(_private_variable)

Speichern Sie die Datei, indem Sie Ctrl+S (oder Cmd+S) drücken.

Führen wir nun dieses Python-Skript vom Terminal aus, um die Ausgabe zu sehen. Stellen Sie im Terminal sicher, dass Sie sich im Verzeichnis ~/project befinden, und führen Sie den folgenden Befehl aus:

python identifier_rules.py

Sie sollten die Ausgabe der print-Anweisungen sehen, was bestätigt, dass die gültigen Bezeichner korrekt verarbeitet wurden. Die Zeilen mit ungültigen Bezeichnern sind auskommentiert, sodass sie beim Ausführen des Skripts keine Fehler verursachen.

10
Hello
True

Diese Übung demonstriert die grundlegenden Regeln für die Erstellung gültiger Bezeichner in Python. In den nächsten Schritten werden wir mehr über gültige und ungültige Bezeichner sowie gängige Namenskonventionen erfahren.

Übung zu gültigen Bezeichnernamen

In diesem Schritt üben wir die Erstellung gültiger Bezeichnernamen in Python basierend auf den Regeln, die wir im vorherigen Schritt gelernt haben. Die Wahl aussagekräftiger und gültiger Namen für Ihre Variablen, Funktionen und andere Codeelemente ist ein grundlegender Bestandteil des Schreibens von gutem Code.

Erstellen Sie eine neue Python-Datei namens valid_identifiers.py im Verzeichnis ~/project mit dem VS Code-Editor.

Geben Sie in die Datei valid_identifiers.py den folgenden Code ein. Dieser Code definiert mehrere Variablen mit gültigen Bezeichnernamen und gibt deren Werte aus.

## Gültige Variablennamen
user_age = 30
total_count = 100
item_price_usd = 25.50
is_active = True
_internal_value = "secret"
MAX_RETRIES = 5

## Gültiger Funktionsname (wir werden später etwas über Funktionen lernen)
def calculate_total():
    return user_age * total_count

## Gültiger Klassenname (wir werden später etwas über Klassen lernen)
class UserProfile:
    def __init__(self, name):
        self.name = name

## Geben Sie die Werte der Variablen aus
print("User Age:", user_age)
print("Total Count:", total_count)
print("Item Price (USD):", item_price_usd)
print("Is Active:", is_active)
print("Internal Value:", _internal_value)
print("Maximum Retries:", MAX_RETRIES)

## Rufen Sie die Funktion auf und geben Sie das Ergebnis aus
## print("Calculated Total:", calculate_total())

## Erstellen Sie eine Instanz der Klasse und geben Sie eine Eigenschaft aus
## user = UserProfile("Alice")
## print("User Name:", user.name)

Speichern Sie die Datei, indem Sie Ctrl+S (oder Cmd+S) drücken.

Führen wir nun dieses Python-Skript vom Terminal aus. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden, und führen Sie den folgenden Befehl aus:

python valid_identifiers.py

Sie sollten die Werte der Variablen auf der Konsole ausgegeben sehen.

User Age: 30
Total Count: 100
Item Price (USD): 25.5
Is Active: True
Internal Value: secret
Maximum Retries: 5

Beachten Sie, wie die Variablennamen Unterstriche (_) zur Trennung von Wörtern verwenden, was in Python eine gängige Konvention für Variablen- und Funktionsnamen ist (snake_case). Klassennamen wie UserProfile verwenden typischerweise Großbuchstaben für den Anfangsbuchstaben jedes Wortes (PascalCase). Konstanten wie MAX_RETRIES werden oft in Großbuchstaben mit Unterstrichen geschrieben.

Durch das Üben mit diesen Beispielen werden Sie vertrauter mit der Erstellung gültiger und lesbarer Bezeichnernamen in Python.

Ungültige Bezeichnernamen identifizieren

In diesem Schritt konzentrieren wir uns auf die Identifizierung ungültiger Bezeichnernamen in Python. Zu wissen, was einen Bezeichner ungültig macht, ist genauso wichtig wie die Regeln für gültige Namen zu kennen. Der Versuch, einen ungültigen Bezeichner zu verwenden, führt zu einem SyntaxError, wenn Sie versuchen, Ihren Python-Code auszuführen.

Erstellen Sie eine neue Python-Datei namens invalid_identifiers.py im Verzeichnis ~/project mit dem VS Code-Editor.

Geben Sie in die Datei invalid_identifiers.py den folgenden Code ein. Dieser Code enthält Beispiele für ungültige Bezeichnernamen. Wir werden diese absichtlich einfügen, um die Fehler zu sehen, die sie verursachen.

## Ungültiger Bezeichner: beginnt mit einer Ziffer
## 1variable = 10

## Ungültiger Bezeichner: enthält ein Leerzeichen
## my variable = "hello"

## Ungültiger Bezeichner: enthält ein Sonderzeichen (@)
## user@name = "Alice"

## Ungültiger Bezeichner: enthält ein Sonderzeichen (-)
## product-id = "XYZ123"

## Ungültiger Bezeichner: verwendet ein Python-Schlüsselwort
## class = "Math"

## Ungültiger Bezeichner: verwendet ein weiteres Python-Schlüsselwort
## for = 100

## Ungültiger Bezeichner: enthält ein Sonderzeichen ($)
## total$amount = 50.75

## Ungültiger Bezeichner: enthält ein Sonderzeichen (%)
## discount%rate = 0.15

print("Der Versuch, ungültige Bezeichner zu definieren, führt zu einem SyntaxError.")

Speichern Sie die Datei, indem Sie Ctrl+S (oder Cmd+S) drücken.

Versuchen wir nun, dieses Python-Skript vom Terminal auszuführen. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden, und führen Sie den folgenden Befehl aus:

python invalid_identifiers.py

Da alle ungültigen Bezeichner auskommentiert sind, wird das Skript ohne Fehler ausgeführt und die Nachricht ausgegeben.

Der Versuch, ungültige Bezeichner zu definieren, führt zu einem SyntaxError.

Kommentieren wir nun einen der ungültigen Bezeichner aus, um den Fehler zu sehen. Entfernen Sie das # vom Anfang der Zeile ## 1variable = 10. Die Zeile sollte nun 1variable = 10 lauten.

Speichern Sie die Datei erneut.

Führen Sie das Skript nun erneut aus:

python invalid_identifiers.py

Dieses Mal sollten Sie einen SyntaxError sehen, der darauf hinweist, dass der Bezeichner ungültig ist, da er mit einer Ziffer beginnt.

  File "/home/labex/project/invalid_identifiers.py", line 4
    1variable = 10
    ^
SyntaxError: invalid decimal literal

Sie können versuchen, andere ungültige Bezeichner nacheinander auszukommentieren und das Skript auszuführen, um die verschiedenen Arten von SyntaxError-Meldungen zu sehen, die sie erzeugen. Denken Sie daran, den vorherigen ungültigen Bezeichner auszukommentieren, bevor Sie den nächsten auskommentieren, um den Fehler zu isolieren.

Dieser Schritt hilft Ihnen, häufige Fehler bei der Benennung von Bezeichnern zu erkennen und die Bedeutung der Einhaltung der Benennungsregeln zu verstehen, um Syntaxfehler zu vermeiden.

Spezielle Bezeichnerkonventionen verstehen

In diesem Schritt werden wir einige spezielle Konventionen für die Verwendung von Unterstrichen in Python-Bezeichnern untersuchen. Diese Konventionen beeinflussen nicht unbedingt, ob ein Bezeichner gemäß den Grundregeln gültig oder ungültig ist, sondern vermitteln spezifische Bedeutungen über die beabsichtigte Verwendung oder Sichtbarkeit des Bezeichners.

Hier sind die gängigen Unterstrichkonventionen:

• Einzelner führender Unterstrich (_name): Diese Konvention zeigt an, dass der Bezeichner für die interne Verwendung innerhalb eines Moduls oder einer Klasse bestimmt ist. Es ist ein Hinweis an andere Programmierer, dass sie nicht direkt auf diesen Bezeichner von außerhalb des Moduls oder der Klasse zugreifen sollten. Python erzwingt dies jedoch nicht streng; Sie können trotzdem darauf zugreifen, wenn Sie möchten.
• Doppelter führender Unterstrich (__name): Diese Konvention wird für Name Mangling (Namensveränderung) in Klassen verwendet. Wenn ein Bezeichner innerhalb einer Klasse mit zwei Unterstrichen beginnt (und nicht mit zwei Unterstrichen endet), ändert Python intern den Namen, um den direkten Zugriff von außerhalb der Klasse zu erschweren. Dies hilft, Namenskonflikte bei der Vererbung zu vermeiden.
• Doppelte führende und nachfolgende Unterstriche (__name__): Diese Bezeichner sind für die spezielle Verwendung durch den Python-Interpreter reserviert. Beispiele hierfür sind __init__ (Konstruktor), __str__ (String-Repräsentation) usw. Sie sollten vermeiden, eigene Bezeichner mit diesem Muster zu erstellen, es sei denn, Sie implementieren eine der speziellen Methoden von Python.
• Einzelner nachfolgender Unterstrich (name_): Diese Konvention wird verwendet, um Namenskonflikte mit Python-Schlüsselwörtern zu vermeiden. Wenn Sie einen Namen verwenden möchten, der ein Python-Schlüsselwort ist (wie class oder for), können Sie einen Unterstrich anhängen, um ihn zu einem gültigen Bezeichner zu machen (z. B. class_, for_).

Erstellen wir eine neue Python-Datei namens underscore_conventions.py im Verzeichnis ~/project mit dem VS Code-Editor, um diese Konventionen in Aktion zu sehen.

Geben Sie in die Datei underscore_conventions.py den folgenden Code ein:

## Single leading underscore: intended for internal use
_internal_data = "This is internal data"

## Double leading underscore: name mangling in classes
class MyClass:
    def __init__(self):
        self.__private_attribute = "This is a private attribute"

    def get_private_attribute(self):
        return self.__private_attribute

## Double leading and trailing underscores: special method
class MyString:
    def __init__(self, value):
        self.value = value

    def __str__(self):
        return f"MyString object with value: {self.value}"

## Single trailing underscore: to avoid keyword conflict
import builtins
class_ = "This variable name avoids conflict with the 'class' keyword"

print("Internal data:", _internal_data)

## Accessing the private attribute (demonstrating name mangling)
obj = MyClass()
## print(obj.__private_attribute) ## This will cause an AttributeError
print("Accessing private attribute via method:", obj.get_private_attribute())
## You can technically access it using the mangled name, but it's not recommended
## print("Accessing mangled name:", obj._MyClass__private_attribute)

## Using the special __str__ method
my_str_obj = MyString("Hello World")
print(my_str_obj) ## This calls the __str__ method

print("Variable name avoiding keyword conflict:", class_)

Speichern Sie die Datei, indem Sie Ctrl+S (oder Cmd+S) drücken.

Führen Sie das Skript nun vom Terminal aus:

python underscore_conventions.py

Sie sollten die Ausgabe sehen, die die Verwendung dieser Konventionen demonstriert.

Internal data: This is internal data
Accessing private attribute via method: This is a private attribute
MyString object with value: Hello World
Variable name avoiding keyword conflict: This variable name avoids conflict with the 'class' keyword

Beachten Sie, dass der Versuch, direkt auf obj.__private_attribute zuzugreifen, aufgrund des Name Mangling zu einem AttributeError führen würde. Der Zugriff über die Methode get_private_attribute oder den gemangelten Namen _MyClass__private_attribute funktioniert, aber die Konvention ist die Verwendung der Methode. Der Aufruf print(my_str_obj) verwendet automatisch die Methode __str__, da es sich um eine spezielle Methode für die String-Repräsentation handelt.

Das Verständnis dieser Konventionen hilft Ihnen, die Absicht hinter Bezeichnernamen in Python-Code zu interpretieren und Code zu schreiben, der gängigen Praktiken folgt.

Zusammenfassung

In diesem Lab haben wir die grundlegenden Regeln für die Benennung von Bezeichnern in Python gelernt. Wir haben geübt, gültige Bezeichnernamen unter Verwendung von Buchstaben, Ziffern und Unterstrichen zu erstellen und dabei die Regel eingehalten, dass Bezeichner nicht mit einer Ziffer beginnen dürfen. Wir haben auch ungültige Bezeichnernamen identifiziert, die Leerzeichen, Sonderzeichen enthielten oder Python-Schlüsselwörter waren. Darüber hinaus haben wir spezielle Bezeichnerkonventionen untersucht, wie z. B. die Verwendung eines führenden Unterstrichs für "private" Variablen.