Pular para o conteúdo principal
InicioTutoriaisPython

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

Neste tutorial, você aprenderá sobre os usos do sublinhado (_) em python.
abr. de 2024  · 8 min leer

Run and edit the code from this tutorial online

Run Code

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:

Temas

Cursos de Python

Course

Introduction to Python

4 hr
5.5M
Master the basics of data analysis with Python in just four hours. This online course will introduce the Python interface and explore popular packages.
See DetailsRight Arrow
Start Course
Veja MaisRight Arrow
Relacionado

blog

Como aprender Python do zero em 2024: um guia especializado

Descubra como aprender Python, suas aplicações e a demanda por competências em Python. Comece sua jornada em Python hoje mesmo ​com nosso guia detalhado.
Matt Crabtree's photo

Matt Crabtree

19 min

blog

Mais de 60 projetos Python para todos os níveis de conhecimento

60 ideias de projetos de ciência de dados que os cientistas de dados podem usar para criar um portfólio sólido, independentemente de sua especialização.
Bekhruz Tuychiev's photo

Bekhruz Tuychiev

16 min

tutorial

Como comentar um bloco de código em Python

O uso de comentários é fundamental para trabalhar efetivamente com Python. Neste breve tutorial, aprenda a comentar um bloco de código em Python.
Adel Nehme's photo

Adel Nehme

3 min

tutorial

Como aparar uma cadeia de caracteres em Python: Três métodos diferentes

Aprenda os fundamentos do corte de caracteres à esquerda e à direita de uma string em Python.
Adel Nehme's photo

Adel Nehme

5 min

tutorial

Declaração de caso de troca do Python: Um guia para iniciantes

Explore o match-case do Python: um guia sobre sua sintaxe, aplicativos em ciência de dados, ML e uma análise comparativa com o switch-case tradicional.
Matt Crabtree's photo

Matt Crabtree

5 min

tutorial

Tutorial de Python

Em Python, tudo é objeto. Números, cadeias de caracteres (strings), DataFrames, e até mesmo funções são objetos. Especificamente, qualquer coisa que você usa no Python tem uma classe, um modelo associado por trás.
DataCamp Team's photo

DataCamp Team

3 min

See MoreSee More