Quelle est la signification du simple et du double soulignement devant un nom d'objet ?

Question

Quelqu'un peut-il expliquer la signification exacte de l'utilisation d'un simple ou d'un double trait de soulignement devant le nom d'un objet en Python, et la différence entre les deux ?

En outre, cette signification reste-t-elle la même, que l'objet en question soit une variable, une fonction, une méthode, etc.

Answer 1

Single Underscore

Les noms, dans une classe, avec un trait de soulignement en tête servent simplement à indiquer aux autres programmeurs que l'attribut ou la méthode est destiné à être privé. Cependant, rien de spécial n'est fait avec le nom lui-même.

Je cite PEP-8 :

_single_leading_underscore : indicateur faible "d'usage interne". Par exemple from M import * n'importe pas les objets dont le nom commence par un trait de soulignement.

Double Underscore (confusion de noms)

Desde la documentation Python :

Tout identifiant de la forme __spam (au moins deux traits de soulignement en tête, au plus un trait de soulignement en queue) est remplacé textuellement par _classname__spam , donde classname est le nom de la classe actuelle, sans le(s) trait(s) de soulignement en tête. Ce traitement est effectué sans tenir compte de la position syntaxique de l'identifiant, il peut donc être utilisé pour définir des variables d'instance et de classe class-private, des méthodes, des variables stockées dans des globales, et même des variables stockées dans des instances. private à cette classe sur des instances d'autres classes.

Et un avertissement de la même page :

La gestion des noms est destinée à donner aux classes un moyen facile de définir des variables d'instance et des méthodes "privées", sans avoir à se soucier des variables d'instance définies par des classes dérivées, ou de l'utilisation des variables d'instance par du code extérieur à la classe. Notez que les règles de mangement sont conçues principalement pour éviter les accidents ; il est toujours possible pour une âme déterminée d'accéder ou de modifier une variable qui est considérée comme privée.

Exemple

>>> class MyClass():
...     def __init__(self):
...             self.__superprivate = "Hello"
...             self._semiprivate = ", world!"
...
>>> mc = MyClass()
>>> print mc.__superprivate
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: myClass instance has no attribute '__superprivate'
>>> print mc._semiprivate
, world!
>>> print mc.__dict__
{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}

Answer 2

__foo__ Il s'agit simplement d'une convention, un moyen pour le système Python d'utiliser des noms qui n'entrent pas en conflit avec les noms d'utilisateur.

_foo Il s'agit juste d'une convention, une façon pour le programmeur d'indiquer que la variable est privée (quoi que cela signifie en Python).

__foo : cela a une signification réelle : l'interpréteur remplace ce nom par _classname__foo afin de s'assurer que le nom ne se superpose pas à un nom similaire dans une autre classe.

Aucune autre forme d'underscores n'a de sens dans le monde Python.

Il n'y a aucune différence entre classe, variable, global, etc. dans ces conventions.

Answer 3

D'excellentes réponses jusqu'à présent, mais il manque quelques éléments. Un simple trait de soulignement en tête n'est pas exactement juste une convention : si vous utilisez from foobar import * et module foobar ne définit pas un __all__ liste, les noms importés du module ne pas incluent ceux qui sont précédés d'un trait de soulignement. Disons que c'est principalement une convention, puisque ce cas est un coin assez obscur;-).

La convention "leading-underscore" est largement utilisée non seulement pour privé mais aussi pour ce que C++ appellerait protégé par exemple, les noms des méthodes qui sont entièrement destinées à être surchargées par les sous-classes (même celles qui ne peuvent pas être modifiées). ont doivent être surchargées car dans la classe de base, elles raise NotImplementedError !-) sont souvent des noms de sous-titres à une seule tête pour indiquer au code en utilisant les instances de cette classe (ou sous-classes) que lesdites méthodes ne sont pas destinées à être appelées directement.

Par exemple, pour créer une file d'attente thread-safe avec une discipline de mise en file d'attente différente de FIFO, on importe Queue, on sous-classe Queue.Queue et on surcharge des méthodes telles que _get y _put ; le "code client" n'appelle jamais ces méthodes ("hook"), mais plutôt les méthodes publiques ("organizing") telles que put y get (c'est ce que l'on appelle le Méthode du modèle modèle de conception -- voir par exemple aquí pour une présentation intéressante basée sur la vidéo d'une de mes conférences sur le sujet, avec l'ajout de synopsis de la transcription).

Edit : Les liens vidéo dans la description des conférences sont maintenant cassés. Vous pouvez trouver les deux premières vidéos aquí y aquí .

Answer 4

._variable est semi-privé et n'est utilisé que par convention.

.__variable est souvent considéré à tort comme superprivé, alors que sa signification réelle est juste de s'associer à empêcher tout accès accidentel [1]

.__variable__ est généralement réservé aux méthodes ou aux variables intégrées

Vous pouvez toujours accéder .__mangled des variables si vous le voulez désespérément. Le double soulignement ne fait que nommer, ou renommer, la variable comme suit instance._className__mangled

Exemple :

class Test(object):
    def __init__(self):
        self.__a = 'a'
        self._b = 'b'

>>> t = Test()
>>> t._b
'b'

t._b est accessible car il n'est caché que par convention

>>> t.__a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Test' object has no attribute '__a'

t.__a est introuvable car il n'existe plus à cause du namemangling.

>>> t._Test__a
'a'

En accédant instance._className__variable au lieu du simple nom à double soulignement, vous pouvez accéder à la valeur cachée

Answer 5

Parfois, vous avez ce qui semble être un tuple avec un trait de soulignement en tête, comme dans le cas suivant

def foo(bar):
    return _('my_' + bar)

Dans ce cas, _() est un alias pour une fonction de localisation qui opère sur le texte pour le mettre dans la bonne langue, etc. en fonction de la locale. Par exemple, Sphinx fait ceci, et vous trouverez parmi les importations

from sphinx.locale import l_, _

et dans sphinx.locale, _() est assigné comme alias d'une fonction de localisation.