Função do sublinhado (_) no tutorial de Python

Muitos dos desenvolvedores de Python não conhecem as funcionalidades do sublinhado (_) em Python. Ele ajuda os usuários a escrever código Python de forma produtiva.

O underscore(_) é um caractere exclusivo do Python.

Se você é um programador Python, provavelmente está familiarizado com a seguinte sintaxe:

• for _ in range(100)

• __init__(self)

• _ = 2

Ele tem um significado especial em diferentes condições. Vamos ver todos eles.

Você encontrará no máximo seis usos diferentes do sublinhado (_). Se quiser, você poderá usá-lo para diferentes finalidades depois de ter uma ideia sobre o sublinhado(_).

1. Uso no intérprete

O Python armazena automaticamente o valor da última expressão no interpretador em uma variável específica chamada "_". Se desejar, você também pode atribuir esses valores a outra variável.

Você pode usá-la como uma variável normal. Veja o exemplo

>>> 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. Ignorando valores

O underscore (_) também é usado para ignorar os valores. Se você não quiser usar valores específicos ao desempacotar, basta atribuir esse valor ao sublinhado (_).

Ignorar significa atribuir os valores à variável especial underscore(_). Estamos atribuindo os valores ao sublinhado (_), pois não o usaremos no código futuro.

Veja o exemplo

## 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. Uso em looping

Você pode usar o sublinhado (_) como uma variável no looping. Veja os exemplos abaixo para ter uma ideia.

## 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. Separação de dígitos de números

Se você tiver um número com dígitos longos, poderá separar o grupo de dígitos como quiser para melhor compreensão.

Ex:- million = 1_000_000

Em seguida, você também pode usar o sublinhado (_) para separar as partes binária, octal ou hexadecimal dos números.

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

Execute todos os exemplos acima para ver os resultados.

## 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. Nomeação usando sublinhado (_)

O underscore (_) pode ser usado para nomear variáveis, funções e classes, etc..,

• Pré sublinhado simples:- _variable

• Signle Post Underscore:- variable_

• Pré-pontos duplos:- __variável

• Dois sublinhados antes e depois:- __variable__

5.1. _single_pre_underscore

_name

O Single Pre Underscore é usado para uso interno. A maioria de nós não o utiliza por esse motivo.

Veja o exemplo a seguir.

class Test:

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

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

datacamp
7

single pre underscore não o impede de acessar a variável single pre underscore.

Porém, um único sublinhado afeta os nomes que são importados do módulo.

Vamos escrever o seguinte código no arquivo my_funtions.

## filename:- my_functions.py

def func():
    return "datacamp"

def _private_func():
    return 7

Agora, se você importar todos os métodos e nomes de my_functions.py, o Python não importará os nomes que começam com um único sublinhado.

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

Você evita o erro acima importando o módulo normalmente.

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

O Single Pre Underscore deve ser usado apenas para uso interno.

5.2 single_postunderscore

name_

Às vezes, se você quiser usar palavras-chave do Python como nomes de variáveis, funções ou classes, poderá usar essa convenção para isso.

Você pode evitar conflitos com as palavras-chave do Python adicionando um sublinhado no final do nome que deseja usar.

Vejamos o exemplo.

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

O Single Post Underscore é usado para nomear suas variáveis como palavras-chave do Python e para evitar conflitos adicionando um sublinhado no final do nome da variável.

5.3. Duplo Pré Underscore

__name

Os sublinhados duplos anteriores são usados para a confusão de nomes.

Double Pre Underscores informa ao interpretador Python para reescrever o nome do atributo das subclasses para evitar conflitos de nomes.

• Alteração de nome: o interpretador do Python altera o nome da variável de forma que seja difícil entrar em conflito quando a classe é herdada.

Vejamos um exemplo.

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

O código acima retorna todos os atributos do objeto de classe. Vamos ver nossas variáveis na lista de atributos.

A variável self.a aparece na lista sem nenhuma alteração.

self._b A variável também aparece na lista sem nenhuma alteração. Como discutimos acima, ele é apenas para uso interno.

• Há uma variável self.__c na lista?

  • Se você observar atentamente a lista de atributos, encontrará um atributo chamado _Sample__c. Essa é a confusão de nomes. Isso serve para evitar a substituição da variável em subclasses.

Vamos criar outra classe herdando a classe Sample para ver como funciona a substituição.

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'

Aqui, a confusão de nomes funciona novamente. Ele altera o obj2.__c para _SecondClass__c. Agora, imprima esse elemento usando o atributo modificado.

print(obj2._SecondClass__c)

overridden

Veja, funcionou, você também pode acessar a variável criada anteriormente usando _Sample__c. Vejamos

print(obj1._Sample__c)

3

Você pode acessar as variáveis Double Pre Underscore usando os métodos da classe. Vejamos um exemplo.

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'

Você também pode usar o Double Pre Underscore para os nomes dos métodos. Vejamos um exemplo.

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'

Vejamos o nome "mangling " de outra forma. Primeiro, criaremos uma variável com o nome _SimpleClass__name e, em seguida, tentaremos acessar essa variável usando o nome Doble Pre Underscore.

Vejamos um exemplo.

_SimpleClass__name = "datacamp"

class SimpleClass:

    def return_name(self):
        return __name

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

datacamp

Você entendeu o conceito? Se não o fez, tente reler.

5.4. Dupla marcação de pontos antes e depois

__name__

No Python, você encontrará nomes diferentes que começam e terminam com o sublinhado duplo. Eles são chamados de métodos mágicos ou métodos dunder.

class Sample():

    def __init__(self):
        self.__num__ = 7

obj = Sample()
obj.__num__

7

Isso levará a conflitos se você usar esses métodos como nomes de variáveis. Portanto, é melhor ficar longe deles.

Conclusão

Parabéns! Você conseguiu. Você concluiu o conceito mais chato do Python. Mas ajuda muito quando você está trabalhando com código avançado.

A maioria das pessoas, como eu, não entende esse conceito na primeira leitura. Portanto, não perca a paciência e releia se não tiver entendido na primeira vez. Se tiver alguma dúvida sobre o artigo, não hesite em mencioná-la na seção de comentários.

Se você for um iniciante em Python, recomendo que faça este curso e, em seguida, releia este artigo para ter uma compreensão completa.

Recursos:

• O significado dos sinais de sublinhado em Python