Curso
Introdução ao Python
4 h
7M
CtaWorkspaceButton.null
Executar códigoMuitos 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:
Tópicos
