Welche Bedeutung und Verwendung haben Unterstriche in Python?

1. Einfacher führender Unterstrich: _var

Wenn es um Variablen- und Methodennamen geht, hat der einzelne Unterstrich-Präfix eine konventionelle Bedeutung. Es ist eine Erinnerung an Programmierer – das heißt, dass sich die Python-Community darüber einig ist, was es bedeuten soll, das Verhalten des Programms jedoch nicht beeinträchtigt wird.

Die Bedeutung des Unterstrich-Präfixes besteht darin, andere Programmierer darüber zu informieren, dass Variablen oder Methoden, die mit einem einzelnen Unterstrich beginnen, nur für den internen Gebrauch bestimmt sind. Diese Konvention ist in PEP 8 definiert.

Dies wird von Python nicht vorgeschrieben. Python kennt keine strenge Unterscheidung zwischen „privaten“ und „öffentlichen“ Variablen wie Java. Es ist, als hätte jemand ein kleines Unterstrich-Warnschild angebracht, auf dem steht:

„Hey, das ist eigentlich nicht dafür gedacht, Teil der öffentlichen Schnittstelle der Klasse zu sein. Lass es einfach in Ruhe.“

2. Single-End-Unterstrich var_

Manchmal ist der am besten geeignete 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 diesem Fall können Sie den Namenskonflikt lösen, indem Sie einen Unterstrich anhängen:

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

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

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

3. Doppelter führender Unterstrich __var

Die Bedeutung aller bisher behandelten Namensmuster ergibt sich aus vereinbarten Konventionen. Bei Python-Klassenattributen (einschließlich Variablen und Methoden), die mit einem doppelten Unterstrich beginnen, ist die Situation etwas anders.

Das doppelte Unterstrich-Präfix veranlasst den Python-Interpreter, Eigenschaftsnamen neu zu schreiben, um Namenskonflikte in Unterklassen zu vermeiden.

Dies wird auch Namensmangling genannt – der Interpreter ändert den Namen der Variablen, sodass es weniger wahrscheinlich zu Konflikten kommt, wenn die Klasse erweitert wird.

Ich weiß, das klingt abstrakt. Deshalb habe ich zur Veranschaulichung ein kleines Codebeispiel zusammengestellt:

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

Schauen wir uns die Eigenschaften dieses Objekts mit der integrierten dir()-Funktion an:

>>> 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']

Oben ist die Liste der Eigenschaften dieses Objekts. Werfen wir einen Blick auf diese Liste und suchen nach unseren ursprünglichen Variablennamen foo, _bar und __baz – ich garantiere Ihnen, dass Sie einige interessante Änderungen bemerken werden. foo，_bar和__baz - 我保证你会注意到一些有趣的变化。

self.foo变量在属性列表中显示为未修改为foo。self._bar的行为方式相同 - 它以_bar的形式显示在类上。 就像我之前说过的，在这种情况下，前导下划线仅仅是一个约定。 给程序员一个提示而已。然而，对于self.__baz而言，情况看起来有点不同。 当你在该列表中搜索__baz时，你会看不到有这个名字的变量。

__baz出什么情况了？

如果你仔细观察，你会看到此对象上有一个名为_Test__baz的属性。 这就是Python解释器所做的名称修饰。 它这样做是为了防止变量在子类中被重写。

让我们创建另一个扩展Test类的类，并尝试重写构造函数中添加的现有属性：

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

现在，你认为foo，_bar和__baz的值会出现在这个ExtendedTest类的实例上吗？ 我们来看一看：

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

等一下，当我们尝试查看t2 .__ baz的值时，为什么我们会得到AttributeError？ 名称修饰被再次触发了！ 事实证明，这个对象甚至没有__baz属性：

>>> 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']

正如你可以看到__baz变成_ExtendedTest__baz以防止意外修改：

>>> t2._ExtendedTest__baz
'overridden'

但原来的_Test__baz还在：

>>> t2._Test__baz
42

双下划线名称修饰对程序员是完全透明的。 下面的例子证实了这一点：

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

名称修饰是否也适用于方法名称？ 是的，也适用。名称修饰会影响在一个类的上下文中，以两个下划线字符（"dunders"）开头的所有名称：

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

这是另一个也许令人惊讶的运用名称修饰的例子：

_MangledGlobal__mangled = 23

class MangledGlobal:
   def test(self):
       return __mangled

>>> MangledGlobal().test()
23

在这个例子中，我声明了一个名为_MangledGlobal__mangled的全局变量。然后我在名为MangledGlobal的类的上下文中访问变量。由于名称修饰，我能够在类的test()方法内，以__mangled来引用_MangledGlobal__mangled全局变量。

Python解释器自动将名称__mangled扩展为_MangledGlobal__mangled

Die Variable self.foo erscheint unverändert als foo in der Eigenschaftenliste. self._bar verhält sich genauso – es erscheint in 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. Für self.__baz sieht die Sache jedoch etwas anders aus. Wenn Sie in dieser Liste nach __baz suchen, wird keine Variable mit diesem Namen angezeigt.

Was ist mit __baz passiert?

Wenn Sie genau hinsehen, werden Sie feststellen, dass es für dieses Objekt eine Eigenschaft namens _Test__baz gibt. Dies ist eine vom Python-Interpreter durchgeführte Namensverfälschung. Dies geschieht, um zu verhindern, dass Variablen in Unterklassen überschrieben werden.

Lassen Sie uns eine weitere Klasse erstellen, die die Testklasse erweitert, und versuchen, die im Konstruktor hinzugefügten vorhandenen Eigenschaften zu überschreiben: 🎜

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

>>> PrefixPostfixTest().__bam__
42

🎜Jetzt denken Sie, foo, _bar und __bazwerden der Wert sein of code> auf dieser Instanz der ExtendedTest-Klasse erscheinen? Werfen wir einen Blick darauf: 🎜

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

🎜Moment mal, warum erhalten wir einen AttributeError, wenn wir versuchen, den Wert von t2.__baz anzuzeigen? Namensänderung wird erneut ausgelöst! Es stellt sich heraus, dass dieses Objekt nicht einmal ein __baz-Attribut hat: 🎜

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

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

🎜 Wie Sie sehen können, wird __baz zu _ExtendedTest__baz, um versehentliche Änderungen zu verhindern : 🎜

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

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

🎜Aber der ursprüngliche _Test__baz ist immer noch da: 🎜rrreee🎜Die Namensdekoration mit doppeltem Unterstrich ist für Programmierer völlig transparent. Das folgende Beispiel bestätigt dies: 🎜rrreee🎜Gilt die Namensdekoration auch für Methodennamen? Ja, das gilt auch. Die Namensdekoration betrifft alle Namen, die im Kontext einer Klasse mit zwei Unterstrichen ("dunders") beginnen: 🎜rrreee🎜 Dies ist ein weiteres, vielleicht überraschendes Beispiel für die Verwendung der Namensdekoration :🎜rrreee 🎜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. Aufgrund des Namens mangling kann ich innerhalb der test()-Methode der Klasse auf die globale Variable _MangledGlobal__mangled als __mangled verweisen. 🎜🎜Der Python-Interpreter erweitert den Namen __mangled automatisch zu _MangledGlobal__mangled, da er mit zwei Unterstrichen beginnt. Dies weist darauf hin, dass die Namensdekoration nicht speziell mit Klassenattributen verknüpft ist. Es funktioniert für jeden Namen, der mit zwei Unterstrichen beginnt und in einem Klassenkontext verwendet wird. 🎜🎜Es gibt viel zu absorbieren. 🎜🎜Ganz ehrlich, diese Beispiele und Erklärungen sind mir nicht einfach so aus dem Kopf gegangen. Ich brauchte einige Recherche- und Verarbeitungsschritte, um darauf zu kommen. Ich habe Python immer und schon seit vielen Jahren verwendet, aber Regeln und Sonderfälle wie diese fallen mir nicht immer ein. 🎜🎜Manchmal ist die wichtigste Fähigkeit eines Programmierers die „Mustererkennung“ und das Wissen, wo er nach Informationen suchen muss. Wenn Sie sich zu diesem Zeitpunkt etwas überfordert fühlen, machen Sie sich keine Sorgen. Nehmen Sie sich Zeit und probieren Sie einige der Beispiele in diesem Artikel aus. 🎜

让这些概念完全沉浸下来，以便你能够理解名称修饰的总体思路，以及我向您展示的一些其他的行为。如果有一天你和它们不期而遇，你会知道在文档中按什么来查。

4.双前导和双末尾下划线 _var_

也许令人惊讶的是，如果一个名字同时以双下划线开始和结束，则不会应用名称修饰。 由双下划线前缀和后缀包围的变量不会被Python解释器修改：

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

>>> PrefixPostfixTest().__bam__
42

但是，Python保留了有双前导和双末尾下划线的名称，用于特殊用途。 这样的例子有，__init__对象构造函数，或__call__ — 它使得一个对象可以被调用。

这些dunder方法通常被称为神奇方法 - 但Python社区中的许多人（包括我自己）都不喜欢这种方法。

最好避免在自己的程序中使用以双下划线（“dunders”）开头和结尾的名称，以避免与将来Python语言的变化产生冲突。

5.单下划线 _

按照习惯，有时候单个独立下划线是用作一个名字，来表示某个变量是临时的或无关紧要的。

例如，在下面的循环中，我们不需要访问正在运行的索引，我们可以使用“_”来表示它只是一个临时值：

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

你也可以在拆分(unpacking)表达式中将单个下划线用作“不关心的”变量，以忽略特定的值。 同样，这个含义只是“依照约定”，并不会在Python解释器中触发特殊的行为。 单个下划线仅仅是一个有效的变量名称，会有这个用途而已。

在下面的代码示例中，我将汽车元组拆分为单独的变量，但我只对颜色和里程值感兴趣。 但是，为了使拆分表达式成功运行，我需要将包含在元组中的所有值分配给变量。 在这种情况下，“_”作为占位符变量可以派上用场：

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

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

除了用作临时变量之外，“_”是大多数Python REPL中的一个特殊变量，它表示由解释器评估的最近一个表达式的结果。

这样就很方便了，比如你可以在一个解释器会话中访问先前计算的结果，或者，你是在动态构建多个对象并与它们交互，无需事先给这些对象分配名字：

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

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

Das obige ist der detaillierte Inhalt vonWelche Bedeutung und Verwendung haben Unterstriche in Python?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!