Como usar const em python corretamente?

Constantes em Python: Melhore a Manutenibilidade do seu Código

Introdução

Na programação, o termo constante se refere a nomes que representam valores que não mudam durante a execução de um programa. As constantes são um conceito fundamental na programação e os desenvolvedores em Python as utilizam em muitos casos. No entanto, o Python não possui uma sintaxe dedicada para definir constantes. Na prática, as constantes em Python são apenas variáveis que nunca mudam.

Para evitar que os programadores façam uma nova atribuição a um nome que deve representar uma constante, a comunidade Python adotou uma convenção de nomenclatura: usar letras maiúsculas. Para todo programador Python, é essencial saber o que são constantes, além de saber por que e quando usá-las.

Neste tutorial, você aprenderá como:

• Definir corretamente constantes em Python
• Identificar algumas constantes embutidas
• Usar constantes para melhorar a legibilidade, reutilização e manutenibilidade do seu código
• Aplicar diferentes abordagens para organizar e gerenciar constantes em um projeto
• Usar várias técnicas para tornar constantes rigidamente constantes em Python

Ao aprender a definir e usar constantes, você melhorará dramaticamente a legibilidade, manutenibilidade e reutilização do seu código.

Para tirar o máximo deste tutorial, você precisará de conhecimento básico sobre:

• Conceitos básicos de Programação Orientada a Objetos em Python

Entendendo Variáveis e Constantes

Variáveis e constantes são dois conceitos históricos e fundamentais na programação de computadores. A maioria das linguagens de programação usa esses conceitos para manipular dados e trabalhar de maneira efetiva e lógica.

Variáveis e constantes provavelmente estarão presentes em cada projeto, aplicativo, biblioteca ou outro código que você já escreveu ou escreverá.

O que são Variáveis?

Em Python, uma variável é um nome que se refere a um valor. Esses valores podem ser alterados ao longo do tempo e podem ser de diferentes tipos, como números, strings ou objetos personalizados. Ao atribuir um valor a uma variável, você pode usá-la posteriormente referindo-se a esse nome.

Aqui está um exemplo simples de uma variável em Python:

age = 25
print(age)

Neste exemplo, a variável age está atribuída ao valor 25. Em seguida, o valor da variável é impresso no console. Você pode observar que uma variável pode ser atribuída a um novo valor a qualquer momento:

age = 25
print(age)

age = 30
print(age)

Neste caso, a variável age é inicialmente atribuída ao valor 25 e, em seguida, ao valor 30. Quando você executa esse código, o valor 30 é impresso no console.

O que são Constantes?

Ao contrário das variáveis, uma constante em Python é um nome que se refere a um valor que nunca muda ao longo do tempo. Eles representam informações estáticas que são usadas em um programa. O valor de uma constante é definido uma vez e nunca pode ser alterado.

No entanto, Python não tem uma sintaxe dedicada para definir constantes. Em vez disso, as constantes em Python são apenas variáveis que são convencionalmente escritas em letras maiúsculas para indicar que são valores que não devem ser alterados.

Por exemplo, vamos definir uma constante chamada PI, que representa o valor matemático de π:

PI = 3.14159

Neste caso, a variável PI é atribuída ao valor 3.14159. Conforme o nome sugere, o valor dessa variável não deve ser alterado durante a execução do programa.

Agora que você entende a diferença entre variáveis e constantes em Python, vamos explorar por que e quando usar constantes.

Por que usar Constantes?

O uso de constantes em seu código Python traz vários benefícios:

Melhor Legibilidade do Código

O uso de constantes torna seu código mais legível, pois os nomes das constantes descrevem o valor que elas representam. Ao usar constantes em vez de valores literais, seu código se torna mais descritivo e mais fácil de entender. Por exemplo, imagine que você está escrevendo um programa que calcula a área de um círculo. Em vez de usar o valor literal de π (como 3.14159), você pode usar uma constante chamada PI, que torna seu código mais compreensível:

PI = 3.14159

raio = 5
area = PI * raio**2

Aqui, o uso da constante PI torna o cálculo da área do círculo mais legível e evita a repetição de um valor literal difícil de lembrar.

Facilidade de Manutenção

Quando você usa constantes em seu código, fica mais fácil fazer alterações futuras. Se você precisar atualizar ou modificar um valor usado em várias partes do código, basta modificar a constante correspondente. Isso evita que você tenha que procurar todos os usos desse valor em seu código e atualizá-los manualmente. O uso de constantes economiza tempo e reduz a possibilidade de erros durante a manutenção do código.

Reusabilidade de Código

O uso de constantes também promove a reutilização de código. Se você está trabalhando em um projeto com várias classes ou módulos diferentes, pode definir constantes compartilhadas em um local central e importá-las conforme necessário em todo o projeto. Isso evita a duplicação de código e garante consistência nas informações usadas em todo o código.

Quando usar Constantes

Aqui estão alguns casos comuns em que é recomendado o uso de constantes:

• Valores matemáticos fixos, como π ou a constante de Euler (e)
• Constantes de configuração, como senhas ou URLs
• Valores específicos do domínio, como limites de pontuação em um jogo
• Códigos de erro ou mensagens de status no seu programa

Definindo suas Próprias Constantes em Python

Como mencionado anteriormente, Python não tem uma sintaxe dedicada para definir constantes. No entanto, o Python adota uma convenção de nomenclatura para indicar que um nome deve ser tratado como uma constante. Por convenção, os programadores Python usam letras maiúsculas para nomear constantes.

# Exemplo de uma constante em Python
CONSTANTE = 42

Esta é apenas uma convenção e o Python não faz nada de especial com nomes de constantes. No entanto, outros programadores que lerem seu código saberão que aquele nome deve ser uma constante.

Constantes Definidas pelo Usuário

Em Python, você pode criar suas próprias constantes definindo nomes e atribuindo valores a eles. Essas constantes são apenas variáveis que são convencionalmente escritas em letras maiúsculas. Aqui está um exemplo de uma constante definida pelo usuário:

PI = 3.14159

Constantes Dunder de Nível de Módulo

Outra forma de definir constantes em Python é usando constantes Dunder de nível de módulo. Dunder é uma abreviação para Double Underscore (sublinhado duplo) e esses nomes são reservados no Python para uso especial.

Podemos definir uma constante em um módulo usando o Dunder __all__. Este atributo especial permite listar os nomes que devem ser exportados quando alguém usa o comando from <módulo> import *. Aqui está um exemplo de como definir uma constante em um módulo usando __all__:

__all__ = ['PI']

PI = 3.14159

Desta forma, a constante PI é exportada apenas quando alguém importar todas as definições do módulo com o comando from <módulo> import *.

Colocando Constantes em Ação

Agora que você aprendeu como definir constantes em Python, vamos ver como você pode usá-las para melhorar seu código.

Substituindo Números Mágicos para Legibilidade

Em muitos casos, você pode encontrar números mágicos em seu código. Números mágicos são valores literais que aparecem no meio do código sem um contexto claro. Esses valores podem ser difíceis de entender e lembrar o seu significado, especialmente quando vistos em diferentes partes do código fonte.

Nesses casos, usar constantes em vez de números mágicos é uma boa prática para melhorar a legibilidade do código. As constantes fornecem um nome descritivo para o valor e facilitam o entendimento do seu objetivo. Aqui está um exemplo:

# Número mágico
if score > 75:
    print("Aprovado!")

# Usando uma constante
NOTA_DE_APROVACAO = 75
if score > NOTA_DE_APROVACAO:
    print("Aprovado!")

O uso da constante NOTA_DE_APROVACAO torna claro o critério para aprovação e torna o código mais legível.

Reutilizando Objetos para Manutenibilidade

Outra maneira de usar constantes é reutilizando objetos comuns para melhorar a manutenibilidade do código. Quando você tem um valor que é usado em várias partes do código, é melhor criar uma constante para representar esse valor em vez de repetir o valor literal em vários lugares.

Por exemplo, imagine que você está escrevendo um programa que realiza cálculos matemáticos e precisa usar o valor de π em várias partes do código. Em vez de escrever o valor literal de π em todos os lugares onde é necessário, você pode criar uma constante para representar esse valor:

# Usando o valor literal de pi em várias partes do código
area_circulo = 3.14159 * raio**2
circunferencia_circulo = 2 * 3.14159 * raio

# Usando uma constante para representar o valor de pi
PI = 3.14159

area_circulo = PI * raio**2
circunferencia_circulo = 2 * PI * raio

Ao usar a constante PI, você evita repetir o valor literal de π em várias partes do código. Se você precisar atualizar o valor de π no futuro, basta modificá-lo em um único lugar.

Fornecendo Valores de Argumentos Padrão

As constantes também podem ser usadas para fornecer valores de argumentos padrão em funções. Ao usar uma constante como valor padrão para um argumento, você oferece aos usuários da função a opção de substituir o valor padrão por outros valores, se desejarem.

Aqui está um exemplo:

NOTA_DE_APROVACAO = 75

def verificar_aprovacao(nota, nota_minima=NOTA_DE_APROVACAO):
    if nota >= nota_minima:
        print("Aprovado!")
    else:
        print("Reprovado!")

Neste exemplo, a função verificar_aprovacao possui um argumento nota_minima com um valor padrão definido pela constante NOTA_DE_APROVAÇÃO. Isso permite que os usuários da função especifiquem um valor mínimo de aprovação personalizado, caso desejem.

Tratando suas Constantes em um Projeto do Mundo Real

Ao desenvolver projetos maiores e mais complexos em Python, é necessário gerenciar um grande número de constantes e garantir que elas sejam organizadas e acessíveis. Aqui estão algumas abordagens comuns para lidar com constantes em um projeto do mundo real:

Juntando Constantes com Código Relacionado

Para melhorar a organização do seu código, é recomendado agrupar constantes com o código relacionado em módulos ou classes. Isso torna mais fácil encontrar e visualizar todas as informações relacionadas a uma determinada parte do código.

Por exemplo, se você tem um programa que usa constantes para representar informações de configuração, é uma boa prática criar um módulo de configuração separado que contenha todas essas constantes:

config.py

URL_API = "https:https://codemdd.io/api.example.com"
API_KEY = "my_api_key"

Dessa forma, todas as constantes relacionadas à configuração do programa estão agrupadas em um único local.

Criando um Módulo Dedicado para Constantes

Em projetos maiores, pode ser útil criar um módulo dedicado apenas para constantes. Esse módulo pode ser importado em outras partes do seu código sempre que você precisar usar essas constantes.

constants.py

PI = 3.14159
GRAVIDADE = 9.8

main.py

import constants

raio = 5
area_circulo = constants.PI * raio**2

Dessa forma, todas as constantes são mantidas em um local central e podem ser facilmente acessadas em qualquer parte do código.

Armazenando Constantes em Arquivos de Configuração

Em alguns casos, é recomendado armazenar constantes em arquivos de configuração separados. Isso permite que você altere os valores das constantes sem precisar modificar o código-fonte e, assim, reduz o tempo necessário para fazer alterações nas constantes, especialmente em um ambiente de produção.

Por exemplo, você pode armazenar informações sensíveis, como senhas de banco de dados, em um arquivo de configuração separado. Em seguida, seu código lê essas constantes do arquivo de configuração no momento apropriado.

Lidando com Constantes como Variáveis de Ambiente

Outra prática comum é armazenar constantes sensíveis, como informações de login ou chaves de API, como variáveis de ambiente. As variáveis de ambiente são variáveis globais definidas no sistema operacional e podem ser acessadas por qualquer processo em execução.

Em Python, você pode acessar variáveis de ambiente usando o módulo os, que fornece uma API para interagir com o sistema operacional.

import os

API_KEY = os.environ["API_KEY"]

Dessa forma, você pode configurar essas constantes sensíveis no ambiente de execução, sem precisar inserir os valores diretamente no código do seu programa.

Explorando Outras Constantes em Python

Além das constantes definidas pelo usuário, Python possui várias constantes embutidas que são disponibilizadas através de módulos integrados.

Constantes Embutidas

O módulo embutido math em Python fornece uma série de constantes matemáticas úteis:

import math

print(math.pi) # Valor de pi
print(math.e)  # Valor da constante de Euler

Além disso, o módulo sys fornece algumas constantes úteis relacionadas ao sistema:

import sys

print(sys.maxsize)  # O maior inteiro representável em Python
print(sys.float_info.max)  # O maior número de precisão dupla em Python

Nomes Dunder Internos

Python também possui várias constantes dunder (double underscore) internas que estão disponíveis em módulos integrados:

import string

print(string.ascii_letters)  # Todas as letras maiúsculas e minúsculas
print(string.digits)  # Todos os dígitos decimais
print(string.punctuation)  # Todos os caracteres de pontuação

Constantes de String e Matemáticas Úteis

O módulo math também fornece várias constantes matemáticas úteis:

import math

print(math.inf)  # Infinito positivo
print(math.nan)  # Not a Number (NaN)
print(math.tau)  # Representação da constante tau (2pi)

Além disso, o módulo string fornece várias constantes úteis para manipulação de strings:

import string

print(string.ascii_letters)  # Todas as letras maiúsculas e minúsculas
print(string.digits)  # Todos os dígitos decimais
print(string.punctuation)  # Todos os caracteres de pontuação

Anotação de Tipos em Constantes

A partir do Python 3.6, você pode adicionar anotações de tipos a suas constantes usando a sintaxe de anotação de tipos do Python. As anotações de tipo fornecem informações sobre os tipos esperados ou retornados pelos valores das constantes.

from typing import Final

PI: Final[float] = 3.14159

Neste exemplo, a anotação Final[float] indica que PI é uma constante de ponto flutuante imutável.

Embora as anotações de tipo sejam opcional, elas podem ser úteis para fornecer informações adicionais sobre suas constantes e melhorar a legibilidade e a manutenibilidade do seu código.

Definindo Constantes Estritas em Python

Embora Python não tenha uma sintaxe dedicada para definir constantes estritas, ou seja, valores que não podem ser alterados, existem várias técnicas e boas práticas que você pode usar para tornar suas constantes mais estritas.

O Atributo .__slots__

Uma maneira de tornar suas constantes estritas é usando o atributo . __ slots__. O atributo __slots__ permite que você defina um conjunto estático de atributos para uma classe. Uma vez definidos, esses atributos não podem ser alterados.

class Constantes:
    __slots__ = ("PI",)
    PI = 3.14159

constantes = Constantes()
print(constantes.PI)

constantes.PI = 3.14  # Erro: Não é possível atribuir um novo valor a uma constante estrita

Neste exemplo, a classe Constantes possui uma constante chamada PI. O atributo __slots__ indica que a classe só pode ter o atributo PI. Qualquer tentativa de atribuir um novo valor a essa constante resultará em um erro.

O Decorador @property

Outra maneira de tornar suas constantes estritas é usando o decorador @property. O decorador @property permite que você defina uma propriedade apenas para leitura, que retorna um valor fixo e não pode ser alterado.

class Constantes:
    @property
    def PI(self):
        return 3.14159

constantes = Constantes()
print(constantes.PI)

constantes.PI = 3.14  # Erro: Não é possível atribuir um novo valor a uma constante estrita

Neste exemplo, a classe Constantes possui uma propriedade chamada PI, que retorna o valor fixo 3.14159. Qualquer tentativa de atribuir um novo valor a essa propriedade resultará em um erro.

A Função namedtuple()

Você também pode usar a função namedtuple() para definir uma constante estrita. A função namedtuple() cria uma classe imutável com campos nomeados, que não podem ser modificados.

from collections import namedtuple

Constantes = namedtuple("Constantes", ["PI"])
constantes = Constantes(3.14159)

print(constantes.PI)

Neste exemplo, a constante PI é um campo nomeado da tupla nomeada Constantes. A tupla nomeada é imutável, portanto não é possível alterar seu valor após a criação.

O Decorador @dataclass

O decorador @dataclass é uma maneira mais moderna de definir classes de dados em Python. Você pode usá-lo para definir uma classe de dados imutável e criar constantes estritas.

from dataclasses import dataclass

@dataclass(frozen=True)
class Constantes:
    PI: float = 3.14159

constantes = Constantes()
print(constantes.PI)

constantes.PI = 3.14  # Erro: Não é possível atribuir um novo valor a uma constante estrita

Neste exemplo, a classe Constantes é decorada com @dataclass(frozen=True), o que torna a classe imutável. Qualquer tentativa de atribuir um novo valor à constantes resultará em um erro.

O Método Especial .__setattr__()

Você também pode criar sua própria classe e usar o método especial .__setattr__() para impedir que as constantes sejam alteradas.

class Constantes:
    def __setattr__(self, name, value):
        raise TypeError("As constantes não podem ser alteradas")

constantes = Constantes()
constantes.PI = 3.14159  # Erro: Não é possível atribuir um novo valor a uma constante estrita

Neste exemplo, a classe Constantes redefine o método especial .__setattr__() para lançar um erro sempre que uma tentativa de atribuição for feita.

Conclusão

Neste tutorial, você aprendeu o conceito de constantes em Python e suas aplicações. Embora Python não tenha uma sintaxe dedicada para definir constantes, você pode usar convenções de nomenclatura e outras técnicas para criar constantes efetivas em seu código. O uso de constantes pode melhorar a legibilidade, reutilização e manutenibilidade do seu código, enquanto proporciona uma maneira conveniente de armazenar valores fixos que não devem ser alterados durante a execução do programa.

Lembre-se de que as constantes são apenas convenções de nomenclatura e não são estritamente aplicadas pelo interpretador Python. No entanto, seguir as convenções de nomenclatura geralmente é uma boa prática para tornar seu código mais compreensível para você e outros programadores.