• Einfacher führender Unterstrich:_var
  • Einfacher abschließender Unterstrich:var_
  • Doppelter führender Unterstrich:__var
  • Doppelter führender und abschließender Unterstrich:__var__
  • Einzelner Unterstrich:_

Am Ende des Artikels finden Sie eine kurze „Cheat Sheet“, die die fünf verschiedenen Benennungskonventionen mit Unterstrich und ihre Bedeutungen zusammenfasst, sowie ein kurzes Video-Tutorial, mit dem Sie ihr Verhalten selbst erleben können.

Fangen wir gleich an!

1. Einfacher führender Unterstrich _var

Bei Variablen- und Methodennamen hat ein einzelner Unterstrich als Präfix eine konventionelle Bedeutung. Er ist ein Hinweis für Programmierer – das heißt, die Python-Community ist sich darüber einig, was er bedeuten soll, aber das Verhalten des Programms wird nicht beeinflusst.

Die Bedeutung des Unterstrich-Präfixes besteht darin, andere Programmierer zu informieren: Eine Variable oder Methode, die mit einem einzelnen Unterstrich beginnt, ist nur für den internen Gebrauch bestimmt. Diese Konvention ist in PEP 8 definiert.

Das wird von Python nicht erzwungen. Python hat keine so starke Unterscheidung zwischen „privaten“ und „öffentlichen“ Variablen wie Java. Es ist, als hätte jemand ein kleines Warnschild mit Unterstrich aufgestellt, auf dem steht:

„Hey, das ist eigentlich nicht als Teil der öffentlichen Schnittstelle der Klasse gedacht. Lass es einfach in Ruhe.“

Schauen Sie sich das folgende Beispiel an:

class Test:
   def __init__(self):
       self.foo = 11
       self._bar = 23

Wenn Sie diese Klasse instanziieren und versuchen, auf die im __init__-Konstruktor definierten Attribute foo und _bar zuzugreifen, was passiert? Schauen wir es uns an:

>>> t = Test()
>>> t.foo
11
>>> t._bar
23

Sie werden sehen, dass der einzelne Unterstrich in _bar uns nicht daran hindert, in die Klasse „einzutreten“ und auf den Wert dieser Variable zuzugreifen.

Das liegt daran, dass das Präfix mit einem einzelnen Unterstrich in Python lediglich eine Konvention ist – zumindest bei Variablen- und Methodennamen.

Ein führender Unterstrich wirkt sich jedoch darauf aus, wie Namen aus einem Modul importiert werden.

Angenommen, Sie haben den folgenden Code in einem Modul namens my_module:

# This is my_module.py:

def external_func():
   return 23

def _internal_func():
   return 42

Wenn Sie nun einen Wildcard-Import verwenden, um alle Namen aus dem Modul zu importieren, wird Python keine Namen mit einem führenden Unterstrich importieren (es sei denn, das Modul definiert eine __all__-Liste, die dieses Verhalten überschreibt):

>>> from my_module import *
>>> external_func()
23
>>> _internal_func()
NameError: "name '_internal_func' is not defined"

Übrigens sollten Wildcard-Importe vermieden werden, weil sie unklar machen, welche Namen im Namespace existieren. Aus Gründen der Klarheit ist es besser, bei regulären Importen zu bleiben.

Im Gegensatz zu Wildcard-Importen sind reguläre Importe nicht von der Namenskonvention mit einem führenden einzelnen Unterstrich betroffen:

>>> import my_module
>>> my_module.external_func()
23
>>> my_module._internal_func()
42

Ich weiß, das mag ein wenig verwirrend sein. Wenn Sie die PEP-8-Empfehlung befolgen und Wildcard-Importe vermeiden, dann ist das Einzige, woran Sie sich wirklich erinnern müssen, Folgendes:

Ein einzelner Unterstrich ist eine Python-Namenskonvention, die anzeigt, dass dieser Name für die interne Verwendung gedacht ist. Er wird normalerweise nicht vom Python-Interpreter erzwungen, sondern dient lediglich als Hinweis für Programmierer.

2. Einzelner nachgestellter Unterstrich var_

Manchmal ist der passendste Name für eine Variable bereits durch ein Schlüsselwort belegt. Daher können Namen wie class oder def in Python nicht als Variablennamen verwendet werden. In solchen Fällen kannst du einen Unterstrich anhängen, um den Namenskonflikt aufzulösen:

>>> def make_object(name, class):
SyntaxError: "invalid syntax"

>>> def make_object(name, class_):
...    pass

Kurz gesagt, ein einzelner nachgestellter Unterstrich (Suffix) ist eine Konvention, um Namenskonflikte mit Python-Schlüsselwörtern zu vermeiden. PEP 8 erläutert diese Konvention.

3. Doppelter führender Unterstrich __var

Bisher stammen die Bedeutungen aller Namensmuster, die wir behandelt haben, aus vereinbarten Konventionen. Aber bei Attributen von Python-Klassen, die mit einem doppelten Unterstrich beginnen (einschließlich Variablen und Methoden), ist die Situation etwas anders.

Ein doppelter Unterstrich als Präfix veranlasst den Python-Interpreter, Attributnamen umzuschreiben, um Namenskonflikte in Unterklassen zu vermeiden.

Dies wird auch als Name Mangling bezeichnet – der Interpreter ändert den Namen der Variable, sodass Konflikte seltener auftreten, wenn die Klasse erweitert wird.

Ich weiß, das klingt abstrakt. Deshalb habe ich ein kleines Codebeispiel zusammengestellt, um es zu veranschaulichen:

class Test:
   def __init__(self):
       self.foo = 11
       self._bar = 23
       self.__baz = 23

Verwenden wir die integrierte Funktion dir(), um die Attribute des Objekts anzusehen:

>>> t = Test()
>>> dir(t)
['_Test__baz', '__class__', '__delattr__', '__dict__', '__dir__',
'__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
'__gt__', '__hash__', '__init__', '__le__', '__lt__', '__module__',
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'__weakref__', '_bar', 'foo']

Das Obige ist eine Liste der Attribute dieses Objekts. Gehen wir diese Liste durch und suchen wir nach unseren ursprünglichen Variablennamen foo, _bar und __baz – ich garantiere dir, dass dir einige interessante Änderungen auffallen werden.

Die Variable self.foo erscheint unverändert als foo in der Attributliste.

self._bar verhält sich genauso – es erscheint an der Klasse als _bar. Wie ich bereits sagte, ist der führende Unterstrich in diesem Fall nur eine Konvention. Nur ein Hinweis für Programmierer. Bei self.__baz sieht die Sache jedoch etwas anders aus. Wenn Sie in dieser Liste nach __baz suchen, werden Sie keine Variable mit diesem Namen sehen.

Was ist mit __baz passiert?

Wenn Sie genau hinsehen, werden Sie feststellen, dass es an diesem Objekt ein Attribut namens _Test__baz gibt. Das ist das Name-Mangling, das der Python-Interpreter durchführt. Er macht dies, um zu verhindern, dass die Variable in Unterklassen überschrieben wird.

Lassen Sie uns eine weitere Klasse erstellen, die die Test-Klasse erweitert, und versuchen, die im Konstruktor hinzugefügten vorhandenen Attribute zu überschreiben:

class ExtendedTest(Test):
   def __init__(self):
       super().__init__()
       self.foo = 'overridden'
       self._bar = 'overridden'
       self.__baz = 'overridden'

Glauben Sie nun, dass die Werte von foo, _bar und __baz in einer Instanz dieser ExtendedTest-Klasse erscheinen werden? Werfen wir einen Blick darauf:

>>> t2 = ExtendedTest()
>>> t2.foo
'overridden'
>>> t2._bar
'overridden'
>>> t2.__baz
AttributeError: "'ExtendedTest' object has no attribute '__baz'"

Moment mal, warum erhalten wir einen AttributeError, wenn wir versuchen, den Wert von t2 .__ baz anzuzeigen? Das Name-Mangling wurde erneut ausgelöst! Es stellt sich heraus, dass dieses Objekt nicht einmal ein __baz-Attribut hat:

>>> dir(t2)
['_ExtendedTest__baz', '_Test__baz', '__class__', '__delattr__',
'__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__gt__', '__hash__', '__init__', '__le__',
'__lt__', '__module__', '__ne__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__', '__weakref__', '_bar', 'foo', 'get_vars']

Wie Sie sehen können, wurde __baz zu _ExtendedTest__baz, um eine versehentliche Änderung zu verhindern:

>>> t2._ExtendedTest__baz
'overridden'

Aber das ursprüngliche _Test__baz ist immer noch da:

>>> t2._Test__baz
42

Das Name-Mangling mit doppeltem Unterstrich ist für den Programmierer vollständig transparent. Das folgende Beispiel bestätigt dies:

class ManglingTest:
   def __init__(self):
       self.__mangled = 'hello'

   def get_mangled(self):
       return self.__mangled

>>> ManglingTest().get_mangled()
'hello'
>>> ManglingTest().__mangled
AttributeError: "'ManglingTest' object has no attribute '__mangled'"

Gilt Name-Mangling auch für Methodennamen? Ja, das tut es. Name-Mangling betrifft alle Namen, die mit zwei Unterstrichzeichen ("Dunders") beginnen, im Kontext einer Klasse:

class MangledMethod:
   def __method(self):
       return 42

   def call_it(self):
       return self.__method()

>>> MangledMethod().__method()
AttributeError: "'MangledMethod' object has no attribute '__method'"
>>> MangledMethod().call_it()
42

Hier ist ein weiteres, vielleicht überraschendes Beispiel für Name-Mangling in Aktion:

_MangledGlobal__mangled = 23

class MangledGlobal:
   def test(self):
       return __mangled

>>> MangledGlobal().test()
23

In diesem Beispiel habe ich eine globale Variable namens _MangledGlobal__mangled deklariert. Dann greife ich im Kontext einer Klasse namens MangledGlobal auf die Variable zu. Dank Name-Mangling kann ich die globale Variable _MangledGlobal__mangled innerhalb der Methode test() der Klasse als __mangled referenzieren.

Der Python-Interpreter erweitert den Namen __mangled automatisch zu _MangledGlobal__mangled, weil er mit zwei Unterstrichzeichen beginnt. Das zeigt, dass Name Mangling nicht speziell mit Klassenattributen verbunden ist. Es gilt für jeden Namen, der mit zwei Unterstrichzeichen beginnt und im Kontext einer Klasse verwendet wird.

Das ist ganz schön viel auf einmal, nicht wahr?

Ehrlich gesagt sind diese Beispiele und Erklärungen nicht einfach so aus meinem Kopf gepurzelt. Ich habe etwas recherchiert und daran gearbeitet. Ich benutze Python seit vielen Jahren, aber Regeln und Sonderfälle wie diese fallen mir nicht immer ein.

Manchmal ist die wichtigste Fähigkeit für einen Programmierer die "Mustererkennung" und zu wissen, wo man Informationen nachschlägt. Wenn du dich an diesem Punkt etwas überfordert fühlst, keine Sorge. Lass dir Zeit und probiere einige der Beispiele in diesem Artikel aus.

Lass diese Konzepte vollständig sacken, damit du die Gesamtidee von Name Mangling und einige der anderen Verhaltensweisen, die ich dir gezeigt habe, verstehen kannst. Wenn du jemals unerwartet darauf stößt, weißt du, was du in der Dokumentation nachschlagen musst.

4. Doppelter führender und doppelter abschließender Unterstrich _var_

Vielleicht überraschend: Name Mangling wird nicht angewendet, wenn ein Name mit doppelten Unterstrichen beginnt und endet. Variablen, die von einem doppelten Unterstrich als Präfix und Suffix umgeben sind, werden vom Python-Interpreter nicht verändert:

class PrefixPostfixTest:
   def __init__(self):
       self.__bam__ = 42

>>> PrefixPostfixTest().__bam__
42

Allerdings reserviert Python Namen mit doppelt führenden und doppelt abschließenden Unterstrichen für spezielle Zwecke. Beispiele sind der Objektkonstruktor __init__ oder __call__ --- der ein Objekt aufrufbar macht.

Diese Dunder-Methoden werden oft als Magic Methods bezeichnet – aber viele Leute in der Python-Community (mich eingeschlossen) mögen diesen Begriff nicht.

Es ist am besten, in eigenen Programmen Namen zu vermeiden, die mit doppelten Unterstrichen beginnen und enden ("Dunders"), um Konflikte mit zukünftigen Änderungen der Python-Sprache zu vermeiden.

5. Einzelner Unterstrich _

Per Konvention wird ein einzelner alleinstehender Unterstrich manchmal als Name verwendet, um anzuzeigen, dass eine Variable temporär oder unbedeutend ist.

Zum Beispiel müssen wir in der folgenden Schleife nicht auf den laufenden Index zugreifen, daher können wir "_" verwenden, um anzuzeigen, dass es sich nur um einen temporären Wert handelt:

>>> for _ in range(32):
...    print('Hello, World.')

Du kannst einen einzelnen Unterstrich auch als "Don't-care"-Variable in Entpackungsausdrücken verwenden, um bestimmte Werte zu ignorieren. Auch hier ist diese Bedeutung nur "per Konvention" und löst kein spezielles Verhalten im Python-Interpreter aus. Ein einzelner Unterstrich ist einfach ein gültiger Variablenname, der diesem Zweck dient.

Im folgenden Codebeispiel entpacke ich ein Auto-Tupel in separate Variablen, aber ich bin nur an den Werten für Farbe und Kilometerstand interessiert. Damit der Entpackungsausdruck erfolgreich ausgeführt werden kann, muss ich jedoch alle im Tupel enthaltenen Werte Variablen zuweisen. In diesem Fall ist "_" als Platzhaltervariable praktisch.

>>> car = ('red', 'auto', 12, 3812.4)
>>> color, _, _, mileage = car

>>> color
'red'
>>> mileage
3812.4
>>> _
12

Neben der Verwendung als temporäre Variable ist "_" in den meisten Python-REPLs eine spezielle Variable, die das Ergebnis des zuletzt vom Interpreter ausgewerteten Ausdrucks darstellt.

Das ist sehr praktisch: Du kannst beispielsweise in einer Interpreter-Sitzung auf zuvor berechnete Ergebnisse zugreifen oder dynamisch mehrere Objekte erstellen und mit ihnen interagieren, ohne diesen Objekten im Voraus Namen zuweisen zu müssen.

>>> 20 + 3
23
>>> _
23
>>> print(_)
23

>>> list()
[]
>>> _.append(1)
>>> _.append(2)
>>> _.append(3)
>>> _
[1, 2, 3]

Python-Unterstrich-Namensmuster - Zusammenfassung

Das Folgende ist eine kurze Zusammenfassung, ein "Spickzettel", der die Bedeutungen der fünf in diesem Artikel besprochenen Python-Unterstrichmuster auflistet:

Original-URL: https://zhuanlan.zhihu.com/p/36173202