Rôle du trait d'union (_) dans le tutoriel Python

De nombreux développeurs Python ne connaissent pas les fonctionnalités de l' underscore(_) en Python. Il aide les utilisateurs à écrire du code Python de manière productive.

Underscore(_) est un caractère unique dans Python.

Si vous êtes un programmeur Python, vous êtes probablement familier avec la syntaxe suivante :

• for _ in range(100)

• __init__(self)

• _ = 2

Il a une signification particulière dans différentes conditions. Voyons tout cela.

Vous trouverez au maximum six utilisations différentes du trait de soulignement (_). Si vous le souhaitez, vous pouvez l'utiliser à d'autres fins une fois que vous avez une idée de ce qu'est un trait de soulignement(_).

1. Utilisation dans l'interprète

Python stocke automatiquement la valeur de la dernière expression de l'interpréteur dans une variable particulière appelée "_". Vous pouvez également assigner ces valeurs à une autre variable si vous le souhaitez.

Vous pouvez l'utiliser comme une variable normale. Voir l'exemple

>>> 5 + 4
9
>>> _     # stores the result of the above expression
9
>>> _ + 6
15
>>> _
15
>>> a = _  # assigning the value of _ to another variable
>>> a
15

2. Ignorer les valeurs

Le trait de soulignement (_) est également utilisé pour ignorer les valeurs. Si vous ne souhaitez pas utiliser des valeurs spécifiques lors du décompactage, il vous suffit d'attribuer cette valeur à l' underscore(_).

Ignorer signifie assigner les valeurs à la variable spéciale underscore(_). Nous assignons les valeurs à underscore(_) étant donné que nous ne l'utiliserons pas dans le code futur.

Voir l'exemple

## ignoring a value
a, _, b = (1, 2, 3) # a = 1, b = 3
print(a, b)

## ignoring multiple values
## *(variable) used to assign multiple value to a variable as list while unpacking
## it's called "Extended Unpacking", only available in Python 3.x
a, *_, b = (7, 6, 5, 4, 3, 2, 1)
print(a, b)

1 3
7 1

3. Utilisation en boucle

Vous pouvez utiliser l'underscore(_) comme variable dans les boucles. Voyez les exemples ci-dessous pour vous faire une idée.

## lopping ten times using _
for _ in range(5):
    print(_)

## iterating over a list using _
## you can use _ same as a variable
languages = ["Python", "JS", "PHP", "Java"]
for _ in languages:
    print(_)

_ = 5
while _ < 10:
    print(_, end = ' ') # default value of 'end' id '\n' in python. we're changing it to space
    _ += 1

0
1
2
3
4
Python
JS
PHP
Java
5 6 7 8 9

4. Séparation des chiffres des nombres

Si vous avez un long numéro, vous pouvez séparer les groupes de chiffres comme vous le souhaitez pour une meilleure compréhension.

Ex:- million = 1_000_000

Ensuite, vous pouvez également utiliser le trait de soulignement (_) pour séparer les parties binaires, octales ou hexagonales des nombres.

Ex:- binary = 0b_0010, octa = 0o_64, hexa = 0x_23_ab

Exécutez tous les exemples ci-dessus pour voir les résultats.

## different number systems
## you can also check whether they are correct or not by coverting them into integer using "int" method
million = 1_000_000
binary = 0b_0010
octa = 0o_64
hexa = 0x_23_ab

print(million)
print(binary)
print(octa)
print(hexa)

1000000
2
52
9131

5. Nommer en utilisant le trait de soulignement (_)

Le tiret bas (_) peut être utilisé pour nommer des variables, des fonctions et des classes, etc..,

• Pré-écriture unique:- _variable

• Signle Post Underscore:- variable_

• Double soulignement:- __variable

• Double soulignement avant et après:- __variable__

5.1. _single_pre_underscore

_name

Single Pre Underscore est utilisé pour un usage interne. La plupart d'entre nous ne l'utilisent pas pour cette raison.

Voir l'exemple suivant.

class Test:

    def __init__(self):
        self.name = "datacamp"
        self._num = 7

obj = Test()
print(obj.name)
print(obj._num)

datacamp
7

ne vous empêche pas d'accéder à la variable "single pre underscore ".

Cependant, un simple trait de soulignement affecte les noms importés du module.

Écrivons le code suivant dans le fichier my_funtions.

## filename:- my_functions.py

def func():
    return "datacamp"

def _private_func():
    return 7

Maintenant, si vous importez toutes les méthodes et tous les noms de my_functions.py, Python n'importe pas les noms qui commencent par un seul trait de soulignement.

>>> from my_functions import *
>>> func()
'datacamp'
>>> _private_func()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name '_private_func' is not defined

Vous évitez l'erreur ci-dessus en important le module normalement.

>>> import my_functions
>>> my_functions.func()
'datacamp'
>>> my_functions._private_func()
7

Single Pre Underscore n'est destiné qu'à un usage interne.

5.2 single_postunderscore

name_

Parfois, si vous souhaitez utiliser des mots-clés Python comme noms de variables, de fonctions ou de classes, vous pouvez utiliser cette convention.

Vous pouvez éviter les conflits avec les mots-clés Python en ajoutant un trait de soulignement à la fin du nom que vous souhaitez utiliser.

Prenons un exemple.

>>> def function(class):
  File "<stdin>", line 1
    def function(class):
                 ^
SyntaxError: invalid syntax
>>> def function(class_):
...     pass
...
>>>

Le trait de soulignement est utilisé pour nommer vos variables comme des mots-clés Python et pour éviter les collisions en ajoutant un trait de soulignement à la fin de votre nom de variable.

5.3. Double pré-décalage

__name

Les doubles soulignés sont utilisés pour la confusion des noms.

Le double soulignement indique à l'interprète Python de réécrire le nom de l'attribut des sous-classes afin d'éviter les conflits de noms.

• Manipulation de noms: l'interprète de Python modifie le nom des variables de telle sorte qu'il est difficile de les confondre lorsque la classe est héritée.

Prenons un exemple.

class Sample():

    def __init__(self):
        self.a = 1
        self._b = 2
        self.__c = 3
obj1 = Sample()
dir(obj1)

['_Sample__c',
 '__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__',
 '_b',
 'a']

Le code ci-dessus renvoie tous les attributs de l'objet classe. Voyons nos variables dans la liste des attributs.

La variable self.a apparaît dans la liste sans aucune modification.

self._b La variable apparaît également dans la liste sans aucune modification. Comme nous l'avons vu plus haut, il s'agit uniquement d'un usage interne.

• Y a-t-il une variable self.__c dans la liste ?

  • Si vous regardez attentivement la liste des attributs, vous trouverez un attribut appelé _Sample__c. Il s'agit de l'altération du nom. Il s'agit d'éviter la surcharge de la variable dans les sous-classes.

Créons une autre classe en héritant de la classe Sample pour voir comment fonctionne la surcharge.

class SecondClass(Sample):

    def __init__(self):
        super().__init__()
        self.a = "overridden"
        self._b = "overridden"
        self.__c = "overridden"
obj2 = SecondClass()
print(obj2.a)
print(obj2._b)
print(obj2.__c)

overridden
overridden



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-2-4bf6884fbd34> in <module>()
      9 print(obj2.a)
     10 print(obj2._b)
---> 11 print(obj2.__c)


AttributeError: 'SecondClass' object has no attribute '__c'

Ici, la confusion des noms fonctionne à nouveau. Il remplace obj2.__c par _SecondClass__c. Imprimez maintenant cet élément à l'aide de l'attribut modifié.

print(obj2._SecondClass__c)

overridden

Vous voyez, c'est travaillé, vous pouvez aussi accéder à la variable précédemment créée en utilisant _Sample__c. Voyons ce qu'il en est

print(obj1._Sample__c)

3

Vous pouvez accéder aux variables Double Pre Underscore à l'aide des méthodes de la classe. Prenons un exemple.

class SimpleClass:

    def __init__(self):
        self.__datacamp = "Excellent"

    def get_datacamp(self):
        return self.__datacamp

obj = SimpleClass()
print(obj.get_datacamp()) ## it prints the "Excellent" which is a __var
print(obj.__datacamp)     ## here, we get an error as mentioned before. It changes the name of the variable

Excellent



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-5-8006c0a9b061> in <module>()
      9 obj = SimpleClass()
     10 print(obj.get_datacamp()) ## it prints the "Excellent" which is a __var
---> 11 print(obj.__datacamp)     ## here, we get an error as mentioned before. It changes the name of the variable


AttributeError: 'SimpleClass' object has no attribute '__datacamp'

Vous pouvez également utiliser le double soulignement pour les noms de méthodes. Prenons un exemple.

class SimpleClass:

    def __datacamp(self):
        return "datacamp"

    def call_datacamp(self):
        return self.__datacamp()

obj = SimpleClass()
print(obj.call_datacamp()) ## same as above it returns the Dobule pre underscore method
print(obj.__datacamp())    ## we get an error here

datacamp



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

<ipython-input-1-cd8ce2e83589> in <module>()
      9 obj = SimpleClass()
     10 print(obj.call_datacamp()) ## same as above it returns the Dobule pre underscore method
---> 11 print(obj.__datacamp())    ## we get an error here


AttributeError: 'SimpleClass' object has no attribute '__datacamp'

Considérons la confusion des noms d' une autre manière. Tout d'abord, nous allons créer une variable avec le nom _SimpleClass__name, puis nous allons essayer d'accéder à cette variable en utilisant le nom Doble Pre Underscore.

Prenons un exemple.

_SimpleClass__name = "datacamp"

class SimpleClass:

    def return_name(self):
        return __name

obj = SimpleClass()
print(obj.return_name()) ## it prints the __name variable

datacamp

Avez-vous compris le concept ? Si ce n'est pas le cas, essayez de le relire.

5.4. Double soulignement avant et après

__name__

Dans Python, vous trouverez différents noms qui commencent et se terminent par le double trait de soulignement. Elles sont appelées méthodes magiques ou méthodes de blanchiment.

class Sample():

    def __init__(self):
        self.__num__ = 7

obj = Sample()
obj.__num__

7

Cela entraînera des conflits si vous utilisez ces méthodes comme noms de variables. Il est donc préférable de s'en éloigner.

Conclusion

Félicitations ! Vous avez réussi. Vous avez terminé le concept le plus ennuyeux de Python. Mais il est très utile lorsque vous travaillez avec du code avancé.

La plupart des gens comme moi ne comprennent pas ce concept à la première lecture. Alors, ne perdez pas patience, relisez-le si vous ne l'avez pas compris la première fois. Si vous avez des doutes concernant l'article, n'hésitez pas à le mentionner dans la section des commentaires.

Si vous êtes débutant enPython, je vous recommande de suivre ce cours et de relire ensuite cet article pour bien comprendre.

Ressources :

• La signification des traits d'union en Python