Quelles sont les significations et les utilisations des traits de soulignement en Python ?

1. Tiret de soulignement unique : _var

En ce qui concerne les noms de variables et de méthodes, le préfixe de trait de soulignement unique a une signification conventionnelle. Il s'agit d'un rappel aux programmeurs, ce qui signifie que la communauté Python est d'accord sur ce que cela devrait signifier, mais que le comportement du programme n'est pas affecté.

La signification du préfixe de trait de soulignement est d'informer les autres programmeurs que les variables ou méthodes commençant par un seul trait de soulignement sont destinées à un usage interne uniquement. Cette convention est définie dans PEP 8.

Ceci n'est pas mandaté par Python. Python n'a pas de distinction nette entre les variables "privées" et "publiques" comme le fait Java. C'est comme si quelqu'un avait affiché un petit panneau d'avertissement de soulignement disant :

"Hé, ce n'est pas vraiment censé faire partie de l'interface publique de la classe. Laissez-le tranquille

2. Single end Underscore var_

." Parfois, le nom le plus approprié pour une variable est déjà pris par un mot-clé. Par conséquent, les noms comme class ou def ne peuvent pas être utilisés comme noms de variables en Python. Dans ce cas, vous pouvez résoudre le conflit de nom en ajoutant un trait de soulignement :

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

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

En bref, un seul trait de soulignement (suffixe) de fin est une convention pour éviter les conflits de nom avec les mots-clés Python. PEP 8 explique cette convention.

3. Double trait de soulignement __var

La signification de tous les modèles de dénomination que nous avons abordés jusqu'à présent provient de conventions convenues. Pour les attributs de classe Python (y compris les variables et les méthodes) qui commencent par un double trait de soulignement, la situation est un peu différente.

Le préfixe double trait de soulignement amène l'interpréteur Python à réécrire les noms de propriétés pour éviter les conflits de noms dans les sous-classes.

Cela s'appelle également la modification du nom - l'interpréteur modifie le nom de la variable afin qu'elle soit moins susceptible d'entrer en conflit lorsque la classe est étendue.

Je sais que cela semble abstrait. J'ai donc mis en place un petit exemple de code pour illustrer :

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

Jetons un coup d'œil aux propriétés de cet objet à l'aide de la fonction dir() intégrée :

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

Ci-dessus se trouve la liste des propriétés de cet objet. Jetons un coup d'œil à cette liste et recherchons nos noms de variables d'origine foo, _bar et __baz - je vous garantis que vous remarquerez des changements intéressants. 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

La variable self.foo apparaît non modifiée sous la forme foo dans la liste des propriétés. self._bar se comporte de la même manière : il apparaît dans la classe sous la forme _bar. Comme je l'ai déjà dit, le trait de soulignement principal n'est qu'une convention dans ce cas. Juste un indice pour les programmeurs. Cependant, pour self.__baz, les choses semblent un peu différentes. Lorsque vous recherchez __baz dans cette liste, vous ne verrez pas de variable portant ce nom.

Qu'est-il arrivé à __baz ?

Si vous regardez attentivement, vous verrez qu'il y a une propriété appelée _Test__baz sur cet objet. Il s'agit d'une modification de nom effectuée par l'interpréteur Python. Cela permet d'éviter que les variables soient remplacées dans les sous-classes.

Créons une autre classe qui étend la classe Test et essayons de remplacer les propriétés existantes ajoutées dans le constructeur : 🎜

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

>>> PrefixPostfixTest().__bam__
42

🎜Maintenant, vous pensez que foo, _bar et __baz la valeur du code> apparaît-elle sur cette instance de la classe ExtendedTest ? Jetons un coup d'oeil : 🎜

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

🎜Attendez une minute, pourquoi obtenons-nous une AttributeError lorsque nous essayons d'afficher la valeur de t2.__baz ? La modification du nom est à nouveau déclenchée ! Il s'avère que cet objet n'a même pas d'attribut __baz : 🎜

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

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

🎜 Comme vous pouvez le voir, __baz devient _ExtendedTest__baz pour éviter toute modification accidentelle : 🎜

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

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

🎜Mais le _Test__baz original est toujours là : 🎜rrreee🎜La décoration du nom à double trait de soulignement est complètement transparente pour les programmeurs. L'exemple suivant le confirme : 🎜rrreee🎜La décoration des noms s'applique-t-elle également aux noms de méthodes ? Oui, cela s'applique également. La décoration de nom affecte tous les noms commençant par deux caractères de soulignement ("dunders") dans le contexte d'une classe : 🎜rrreee🎜 Ceci est un autre exemple, peut-être surprenant, d'utilisation de la décoration de nom :🎜rrreee 🎜Dans cet exemple, j'ai déclaré une variable globale appelée _MangledGlobal__mangled. Ensuite, j'accède à la variable dans le contexte d'une classe appelée MangledGlobal. En raison de la modification du nom, je peux référencer la variable globale _MangledGlobal__mangled comme __mangled dans la méthode test() de la classe. 🎜🎜L'interpréteur Python étend automatiquement le nom __mangled en _MangledGlobal__mangled car il commence par deux caractères de soulignement. Cela indique que la décoration du nom n'est pas spécifiquement associée aux propriétés de classe. Cela fonctionne pour n'importe quel nom commençant par deux caractères de soulignement utilisés dans un contexte de classe. 🎜🎜Il y a beaucoup de choses à absorber. 🎜🎜Honnêtement, ces exemples et explications ne sont pas sortis de ma tête. Il m’a fallu quelques recherches et traitements pour y parvenir. J'ai toujours utilisé Python, et ce depuis de nombreuses années, mais les règles et les cas particuliers comme celui-ci ne me viennent pas toujours à l'esprit. 🎜🎜Parfois, la compétence la plus importante pour un programmeur est la « reconnaissance de formes » et savoir où chercher des informations. Si vous vous sentez un peu dépassé à ce stade, ne vous inquiétez pas. Prenez votre temps et essayez quelques-uns des exemples de cet article. 🎜

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

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]

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!