• Underscore simple en tête:_var
  • Underscore simple en fin:var_
  • Double underscore en tête:__var
  • Double underscore en tête et en fin:__var__
  • Underscore simple:_

À la fin de l'article, vous trouverez un court « aide-mémoire » qui résume les cinq différentes conventions de nommage avec underscore et leurs significations, ainsi qu'un court tutoriel vidéo qui vous permet d'expérimenter leur comportement par vous-même.

Commençons tout de suite !

1. Underscore simple en tête _var

Lorsqu'il s'agit de noms de variables et de méthodes, un préfixe avec un seul underscore a une signification conventionnelle. C'est un indice pour les programmeurs - ce qui signifie que la communauté Python s'accorde sur ce que cela devrait signifier, mais le comportement du programme n'est pas affecté.

La signification du préfixe underscore est d'informer les autres programmeurs : une variable ou une méthode commençant par un seul underscore est réservée à un usage interne. Cette convention est définie dans la PEP 8.

Ce n'est pas imposé par Python. Python n'a pas de distinction forte entre les variables « privées » et « publiques » comme Java. C'est comme si quelqu'un avait mis un petit panneau d'avertissement avec un underscore disant :

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

Jetez un œil à l'exemple ci-dessous :

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

Si vous instanciez cette classe et essayez d'accéder aux attributs foo et _bar définis dans le constructeur __init__, que se passe-t-il ? Regardons :

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

Vous verrez que le simple underscore dans _bar ne nous empêche pas d'« entrer » dans la classe et d'accéder à la valeur de cette variable.

C'est parce que le préfixe à simple underscore en Python n'est qu'une convention - du moins en ce qui concerne les noms de variables et de méthodes.

Cependant, un underscore initial affecte bel et bien la façon dont les noms sont importés depuis un module.

Supposons que vous ayez le code suivant dans un module nommé my_module :

# This is my_module.py:

def external_func():
   return 23

def _internal_func():
   return 42

Maintenant, si vous utilisez un import avec joker pour importer tous les noms du module, Python n'importera pas les noms avec un underscore initial (sauf si le module définit une liste __all__ qui remplace ce comportement) :

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

Au fait, les imports avec joker devraient être évités car ils ne permettent pas de savoir clairement quels noms existent dans l'espace de noms. Pour plus de clarté, il vaut mieux s'en tenir aux imports classiques.

Contrairement aux imports avec joker, les imports classiques ne sont pas affectés par la convention de nommage avec un underscore initial :

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

Je sais que cela peut être un peu déroutant. Si vous suivez la recommandation PEP 8 et évitez les imports avec joker, alors la seule chose dont vous devez vraiment vous souvenir est ceci :

Un seul trait de soulignement est une convention de nommage Python indiquant que ce nom est destiné à un usage interne. Il n'est généralement pas imposé par l'interpréteur Python, mais sert simplement d'indication aux programmeurs.

2. Trait de soulignement final unique var_

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

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

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

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

3. Double trait de soulignement initial __var

Jusqu'à présent, les significations de tous les modèles de nommage que nous avons abordés proviennent de conventions convenues. Mais pour les attributs des classes Python qui commencent par un double trait de soulignement (y compris les variables et les méthodes), la situation est un peu différente.

Un préfixe à double trait de soulignement amène l'interpréteur Python à réécrire les noms d'attributs afin d'éviter les conflits de nommage dans les sous-classes.

C'est aussi appelé name mangling - l'interpréteur modifie le nom de la variable afin que les conflits soient moins susceptibles de survenir lorsque la classe est étendue.

Je sais que cela semble abstrait. J'ai donc préparé un petit exemple de code pour l'illustrer :

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

Utilisons la fonction intégrée dir() pour examiner les attributs de l'objet :

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

Ce qui précède est une liste des attributs de cet objet. Parcourons cette liste et recherchons nos noms de variables d'origine foo, _bar et __baz - je vous garantis que vous remarquerez quelques changements intéressants.

La variable self.foo apparaît non modifiée en tant que foo dans la liste des attributs.

self._bar se comporte de la même manière - il apparaît sur la classe en tant que _bar. Comme je l'ai déjà dit, dans ce cas, le trait de soulignement initial n'est qu'une convention. Juste un indice pour les programmeurs. Cependant, pour self.__baz, la situation est un peu différente. 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 un attribut sur cet objet nommé _Test__baz. C'est le name mangling effectué par l'interpréteur Python. Il fait cela pour empêcher la variable d'être redéfinie dans les sous-classes.

Créons une autre classe qui étend la classe Test et essayons de redéfinir les attributs existants ajoutés dans le constructeur :

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

Maintenant, pensez-vous que les valeurs de foo, _bar et __baz apparaîtront sur une instance de cette classe ExtendedTest ? Jetons un coup d'œil :

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

Attendez un instant, pourquoi obtenons-nous une AttributeError lorsque nous essayons de consulter la valeur de t2 .__ baz ? Le name mangling a encore été déclenché ! Il s'avère que cet objet n'a même pas d'attribut __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']

Comme vous pouvez le voir, __baz est devenu _ExtendedTest__baz pour éviter toute modification accidentelle :

>>> t2._ExtendedTest__baz
'overridden'

Mais le _Test__baz d'origine est toujours là :

>>> t2._Test__baz
42

Le name mangling avec double trait de soulignement est complètement transparent pour le programmeur. L'exemple suivant le confirme :

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

Le name mangling s'applique-t-il aussi aux noms de méthodes ? Oui. Le name mangling affecte tous les noms qui commencent par deux caractères de soulignement (« dunders ») dans le contexte d'une classe :

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

Voici un autre exemple peut-être surprenant de name mangling en action :

_MangledGlobal__mangled = 23

class MangledGlobal:
   def test(self):
       return __mangled

>>> MangledGlobal().test()
23

Dans cet exemple, j'ai déclaré une variable globale nommée _MangledGlobal__mangled. Ensuite, j'accède à la variable dans le contexte d'une classe nommée MangledGlobal. Grâce au name mangling, je peux référencer la variable globale _MangledGlobal__mangled sous le nom __mangled dans la méthode test() de la classe.

L'interpréteur Python développe automatiquement le nom __mangled en _MangledGlobal__mangled parce qu'il commence par deux caractères de soulignement. Cela montre que le mangling des noms n'est pas spécifiquement associé aux attributs de classe. Il s'applique à tout nom commençant par deux caractères de soulignement utilisé dans le contexte d'une classe.

Il y a beaucoup de choses à assimiler, n'est-ce pas ?

Honnêtement, ces exemples et explications ne sont pas sortis tout droit de mon esprit. J'ai fait des recherches et j'ai travaillé dessus. J'utilise Python depuis de nombreuses années, mais des règles et des cas particuliers comme ceux-ci ne me viennent pas toujours à l'esprit.

Parfois, la compétence la plus importante pour un programmeur est la « reconnaissance de motifs » et le fait de savoir où chercher l'information. 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.

Laissez ces concepts bien s'imprégner afin que vous puissiez comprendre l'idée générale du mangling des noms, ainsi que certains des autres comportements que je vous ai montrés. Si vous les rencontrez un jour de manière inattendue, vous saurez quoi rechercher dans la documentation.

4. Double trait de soulignement au début et à la fin _var_

Étonnamment peut-être, le mangling des noms n'est pas appliqué si un nom commence et se termine par deux traits de soulignement. Les variables entourées d'un préfixe et d'un suffixe à double trait de soulignement ne sont pas modifiées par l'interpréteur Python :

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

>>> PrefixPostfixTest().__bam__
42

Cependant, Python réserve les noms avec un double trait de soulignement au début et à la fin à des usages spéciaux. Les exemples incluent le constructeur d'objet __init__, ou __call__ --- qui rend un objet appelable.

Ces méthodes dunder sont souvent appelées méthodes magiques - mais beaucoup de personnes dans la communauté Python (y compris moi-même) n'aiment pas ce terme.

Il est préférable d'éviter d'utiliser des noms qui commencent et se terminent par deux traits de soulignement (« dunders ») dans vos propres programmes, afin d'éviter des conflits avec de futures modifications du langage Python.

5. Trait de soulignement unique _

Par convention, un seul trait de soulignement isolé est parfois utilisé comme nom pour indiquer qu'une variable est temporaire ou insignifiante.

Par exemple, dans la boucle ci-dessous, nous n'avons pas besoin d'accéder à l'indice courant, nous pouvons donc utiliser « _ » pour indiquer qu'il s'agit simplement d'une valeur temporaire :

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

Vous pouvez également utiliser un seul trait de soulignement comme variable « sans importance » dans les expressions de déballage pour ignorer des valeurs spécifiques. Là encore, cette signification n'est que « par convention » et ne déclenche aucun comportement spécial dans l'interpréteur Python. Un seul trait de soulignement est simplement un nom de variable valide qui remplit cet objectif.

Dans l'exemple de code ci-dessous, je déballe un tuple car en variables séparées, mais seules les valeurs de couleur et de kilométrage m'intéressent. Cependant, pour que l'expression de déballage s'exécute correctement, je dois affecter toutes les valeurs contenues dans le tuple à des variables. Dans ce cas, « _ » comme variable de remplacement est bien utile.

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

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

En plus d'être utilisé comme variable temporaire, « _ » est une variable spéciale dans la plupart des REPL Python, qui représente le résultat de l'expression la plus récente évaluée par l'interpréteur.

C'est très pratique, par exemple, vous pouvez accéder à des résultats précédemment calculés dans une session d'interpréteur, ou vous pouvez construire dynamiquement plusieurs objets et interagir avec eux sans avoir à attribuer des noms à ces objets à l'avance.

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

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

Modèles de nommage avec underscore en Python - Résumé

Voici un bref résumé, un « aide-mémoire », listant les significations des cinq modèles d'underscore Python abordés dans cet article :

URL d'origine : https://zhuanlan.zhihu.com/p/36173202