Como Utilizar a Variável_no Python?

[

Variáveis de Python: Nomes que Utilizam Sublinhado Simples e Duplo

Introdução

No Python, existem algumas convenções importantes de nomenclatura que são baseadas no uso de um ou dois sublinhados (_). Essas convenções permitem diferenciar entre nomes públicos e não públicos em APIs, escrever classes seguras para fins de herança, evitar conflito de nomes e muito mais.

Seguir e respeitar essas convenções permite que você escreva um código que parece Pythonico e consistente aos olhos de outros desenvolvedores Python. Essa habilidade é especialmente útil quando você está escrevendo código destinado a outros desenvolvedores trabalharem.

Neste tutorial, você irá:

• Aprender sobre as convenções de nomenclatura em Python que utilizam sublinhados (_)
• Diferenciar nomes públicos e não públicos usando um sublinhado simples
• Usar dois sublinhados para aproveitar o name mangling em classes Python
• Explorar outros usos comuns de sublinhados em nomes Python

Interfaces Públicas e Convenções de Nomenclatura em Python

Como programador Python, você frequentemente trabalhará com interfaces públicas, ou interfaces de programação de aplicativos (API). Uma API é um tipo de interface de programação que oferece um serviço para outras partes de um programa ou outros programas.

No entanto, muitos desses pacotes e módulos definem objetos que não são destinados ao acesso direto. Esses objetos são para uso interno específico do pacote ou módulo apenas. Eles não fazem parte de sua interface pública.

No contexto de programação orientada a objetos Python, a convenção de nomenclatura do Python é usar um sublinhado simples no início do nome de um objeto para indicar que ele é um objeto não público, ou seja, não deve ser acessado diretamente por outros códigos. Este uso de sublinhado simples é uma convenção e não impede acessos diretos aos objetos.

Além disso, o Python também utiliza dois sublinhados no início do nome de um objeto para realizar o name mangling, uma técnica que permite evitar conflitos de nomes quando uma classe herda de outra classe.

A convenção de nomenclatura com um sublinhado simples e dois sublinhados não esconde nem protege o acesso aos objetos. Porém, essas convenções indicam a intenção desses objetos e ajudam a manter um código mais organizado e consistente.

Sublinhado Simples: Nomes Públicos e Não Públicos em Python

Criando Nomes Públicos e Não Públicos em Python

Em Python, é comum usar um sublinhado simples no início do nome de um objeto para indicar que ele não é público. Esses objetos não são destinados a serem acessados diretamente fora do escopo em que são definidos.

Por exemplo, vamos supor que você esteja escrevendo uma classe chamada Person. Essa classe possui um método chamado _calculate_age. O uso do sublinhado simples no início do nome desse método indica que ele não é considerado parte da interface pública da classe Person, embora ele possa ser acessado diretamente se necessário.

class Person:
    def __init__(self, name, birth_year):
        self.name = name
        self.birth_year = birth_year

    def _calculate_age(self):
        current_year = 2023
        age = current_year - self.birth_year
        return age

Nesse exemplo, o método _calculate_age é um exemplo de um nome não público. Você pode chamar esse método diretamente, mas a convenção sugere que você o considere como uma parte interna da classe e evite chamá-lo fora dela.

Usando Nomes Públicos vs Não Públicos em Python

Embora não exista uma restrição formal em Python para acessar nomes que começam com sublinhado simples, a convenção é considerar esses nomes como não públicos e deixá-los de serem acessados diretamente fora do escopo em que são definidos.

No entanto, qualquer nome que não comece com um sublinhado simples pode ser acessado diretamente em qualquer lugar do seu código. Esses nomes são considerados públicos e fazem parte da interface pública.

Aqui está um exemplo que ilustra o uso de nomes públicos e não públicos em Python:

class Example:
    def __init__(self):
        self.public_variable = 1
        self._non_public_variable = 2

    def public_method(self):
        return "This is a public method."

    def _non_public_method(self):
        return "This is a non-public method."

example = Example()
print(example.public_variable)
print(example._non_public_variable)
print(example.public_method())
print(example._non_public_method())

Nesse exemplo, public_variable e public_method são considerados nomes públicos, enquanto _non_public_variable e _non_public_method são considerados nomes não públicos. Embora seja possível acessar os nomes não públicos diretamente, a convenção sugere que você os trate como objetos internos da classe e evite chamá-los fora dela.

Nomes Públicos e Não Públicos em Módulos e Pacotes

As convenções de nomenclatura com sublinhado simples não se limitam apenas às classes. Elas também podem ser aplicadas em módulos e pacotes Python.

Variáveis e Constantes Internas

Em um módulo ou pacote, você pode usar um sublinhado simples no início do nome de uma variável ou constante para indicar que ela é de uso interno e não faz parte da interface pública do módulo ou pacote.

_public_variable = 1
_non_public_variable = 2

No exemplo acima, _public_variable e _non_public_variable são exemplos de variáveis internas não públicas.

Normalmente, essas variáveis devem ser tratadas como objetos internos e não devem ser acessadas diretamente fora do módulo ou pacote.

Funções Auxiliares

Assim como as variáveis internas, você também pode usar um sublinhado simples no início do nome de uma função para indicar que ela é uma função auxiliar interna e não faz parte da interface pública do módulo ou pacote.

def _helper_function():
    return "This is a helper function."

Nesse exemplo, _helper_function é um exemplo de uma função auxiliar interna não pública.

Da mesma forma que as variáveis internas, as funções auxiliares devem ser tratadas como objetos internos e não devem ser acessadas diretamente fora do módulo ou pacote.

Módulos Não Públicos

Além de variáveis e funções, você também pode usar um sublinhado simples no início do nome de um módulo para indicar que ele é um módulo não público.

Um exemplo comum é o uso do sublinhado simples no início do nome de um arquivo de módulo para indicar que esse módulo não deve ser importado diretamente por outros módulos ou pacotes.

|- main.py
|- _internal_module.py

Nesse exemplo, _internal_module.py é um exemplo de um módulo não público.

A convenção sugere que você não faça importações diretas de módulos não públicos. Em vez disso, você pode acessar funcionalidades desses módulos por meio de APIs públicas fornecidas por outros módulos ou pacotes.

Imports de Vários Objetos e Nomes Não Públicos

Em Python, o uso de asteriscos (*) em um import permite importar todos os nomes públicos de um módulo para o escopo atual. No entanto, essa abordagem não inclui nomes não públicos.

Por exemplo, considere o seguinte módulo chamado example_module.py:

_public_variable = 1
_non_public_variable = 2

def public_function():
    return "This is a public function."

def _non_public_function():
    return "This is a non-public function."

Se você quiser importar todos os nomes públicos do módulo example_module.py, você pode usar o seguinte código:

from example_module import *

Nesse caso, apenas o nome public_variable e a função public_function serão importados e estarão disponíveis no escopo atual. O nome _non_public_variable e a função _non_public_function não serão importados. É importante respeitar e seguir essas convenções ao fazer importações em seu código Python.

Classe com Membros Não Públicos

Uma classe também pode conter membros não públicos, como atributos e métodos.

Atributos Não Públicos

Da mesma forma que para variáveis e constantes em módulos e pacotes, você pode usar um sublinhado simples no início do nome de um atributo de classe para indicar que ele é um atributo não público.

class Example:
    def __init__(self):
        self.public_attribute = 1
        self._non_public_attribute = 2

example = Example()
print(example.public_attribute)
print(example._non_public_attribute)

Nesse exemplo, public_attribute é considerado um nome público, enquanto _non_public_attribute é considerado um nome não público. Você pode acessar o nome não público diretamente, mas a convenção sugere que você o trate como um atributo interno da classe e evite acessá-lo fora dela.

Métodos Não Públicos

Da mesma forma que para funções em módulos e pacotes, você pode usar um sublinhado simples no início do nome de um método de classe para indicar que ele é um método não público.

class Example:
    def public_method(self):
        return "This is a public method."

    def _non_public_method(self):
        return "This is a non-public method."

example = Example()
print(example.public_method())
print(example._non_public_method())

Nesse exemplo, public_method é considerado um nome público, enquanto _non_public_method é considerado um nome não público. Embora seja possível chamar o método não público diretamente, a convenção é considerá-lo como um método interno da classe e evite chamá-lo fora dela.

Dois Sublinhados no Início do Nome de Classes: Name Mangling do Python

O Python também utiliza dois sublinhados no início do nome de uma classe para aplicar o name mangling, uma técnica que permite evitar conflitos de nomes quando uma classe herda de outra classe.

Compreendendo o Name Mangling

O name mangling é uma convenção interna do Python que substitui nomes de atributos ou métodos em tempo de execução para evitar conflitos de nomes com as subclasses.

Por exemplo, vamos supor que você tenha definido duas classes, Parent e Child, onde Child herda de Parent. Ambas as classes possuem um atributo chamado __name. Se você tentar acessar diretamente o atributo __name da instância da classe Child, ocorrerá um conflito de nomes.

O name mangling resolve esse conflito alterando o nome do atributo para _ClassName__attribute. No caso do exemplo, o atributo __name da classe Child seria renomeado para _Child__name.

class Parent:
    def __init__(self):
        self.__name = "Parent"

class Child(Parent):
    def __init__(self):
        super().__init__()
        self.__name = "Child"

child = Child()
print(child._Child__name)

Nesse exemplo, __name é um atributo das classes Parent e Child. Com o name mangling, o atributo __name da classe Child é renomeado para _Child__name, evitando assim o conflito de nomes.

Usando o Name Mangling em Herança

O name mangling é especialmente útil em casos de herança, quando diferentes classes podem ter atributos ou métodos com o mesmo nome.

class Parent:
    def __init__(self):
        self.__name = "Parent"

    def display_name(self):
        return self.__name

class Child(Parent):
    def __init__(self):
        super().__init__()
        self.__name = "Child"

    def display_name(self):
        return self.__name

child = Child()
print(child.display_name())
print(child._Parent__name)
print(child._Child__name)

Nesse exemplo, ambas as classes, Parent e Child, possuem um atributo __name e um método display_name. Com o name mangling, o atributo __name e o método display_name das classes Parent e Child não entrarão em conflito.

Sublinhado Final: Nomes que Terminam com Sublinhado

Além dos sublinhados no início dos nomes, o Python também utiliza um sublinhado final para nomes específicos.

Um exemplo comum é usar um sublinhado final para evitar conflitos com palavras-chave do Python.

class Example_:
    def __init__(self):
        self.class_ = "Example"

example = Example_()
print(example.class_)

Nesse exemplo, a classe Example_ possui um atributo chamado class_, que utiliza um sublinhado final para evitar conflitos com a palavra-chave class do Python.

Dunder Names em Python

O Python também utiliza sublinhados duplos (dunder names) para indicar funções especiais ou métodos especiais.

Esses sublinhados duplos são usados para sobrecarregar comportamentos padrão do Python, como operadores aritméticos (+, -, *, /), métodos de comparação (__eq__, __lt__, __gt__, etc), e muito mais.

class Example:
    def __init__(self, value):
        self.value = value

    def __eq__(self, other):
        return self.value == other.value

example1 = Example(1)
example2 = Example(2)

print(example1 == example2)

Nesse exemplo, a classe Example sobrecarrega o método especial __eq__ para comparar se dois objetos do tipo Example são iguais com base no valor do atributo value.

Outros Usos de Sublinhados em Nomes Python

Além dos usos padrões de sublinhados em nomes Python, existem outros usos específicos em diferentes contextos.

Um exemplo é o uso de sublinhados para indicar que um atributo ou método é temporário ou privado em um contexto específico.

class Example:
    def __init__(self):
        self._temporary_variable = 1

    def _temporary_method(self):
        return "This is a temporary method."

example = Example()
print(example._temporary_variable)
print(example._temporary_method())

Nesse exemplo, _temporary_variable e _temporary_method são usados para indicar que eles são atributos e métodos temporários, respectivamente.

Esses usos de sublinhados são convenções e indicam a intenção desses objetos específicos no contexto em que eles são utilizados.

Conclusão

As convenções de nomenclatura em Python que utilizam sublinhados simples e duplos ajudam a diferenciar entre nomes públicos e não públicos em APIs, escrever classes seguras para fins de herança, evitar conflitos de nomes e manter um código organizado e consistente.

Ao seguir essas convenções, você será capaz de escrever código que parece Pythonico e será mais compreensível para outros desenvolvedores Python. Isso é especialmente importante quando você está compartilhando seu código com outras pessoas ou trabalhando em colaboração.

O Python oferece uma série de recursos poderosos para nomenclatura de variáveis, métodos, classes e outros objetos. Aproveite esses recursos para escrever um código conciso, legível e Pythonico. E lembre-se de seguir as convenções de nomenclatura para garantir um código mais consistente e de fácil entendimento.