Neste tutorial, aprenderemos sobre os tipos constantes e como eles ajudam a melhorar a legibilidade do código. Se você não conhece, as constantes são os nomes que representam valores que não mudam durante a execução do programa. Eles são o conceito fundamental mais comum em programação. No entanto, Python não possui uma sintaxe dedicada para definir constantes. Em geral, as constantes do Python são variáveis ​​que nunca mudam. Teremos uma discussão detalhada sobre a constante Python na próxima seção.

O que são constantes?

Geralmente, um termo constante é usado em Matemática, um valor ou quantidade que nunca muda. Na programação, uma constante refere-se ao nome associado a um valor que nunca muda durante a execução da programação. A constante de programação é diferente de outras constantes e consiste em duas coisas – um nome e um valor associado. O nome descreverá do que se trata a constante, e o valor é a expressão concreta da própria constante.

Depois de definirmos a constante, só podemos acessar seu valor, mas não podemos alterá-lo ao longo do tempo. No entanto, podemos modificar o valor da variável. Um exemplo da vida real é: A velocidade da luz, o número de minutos em uma hora e o nome da pasta raiz de um projeto.

Por que usar constante?

Em linguagens de programação, as constantes nos permitem proteger contra alterações acidentais de seu valor, o que pode causar erros difíceis de depurar. Também é útil tornar o código mais legível e fácil de manter. Vamos ver algumas vantagens da constante.

Legibilidade aprimorada -Ajuda a melhorar a legibilidade do código. Por exemplo, é mais fácil ler e compreender uma constante chamada MAX_SPEED do que o próprio valor substancial da velocidade.Comunicação clara de intenções -A maioria dos desenvolvedores considera 3.14 como a constante pi. No entanto, o nome Pi, pi ou PI comunicará a intenção de forma mais clara. Esta prática permitirá que outro desenvolvedor entenda nosso código.Melhor manutenibilidade -As constantes nos permitem usar o mesmo valor em todo o seu código. Suponha que queiramos atualizar o valor da constante; não precisamos alterar todas as instâncias.Baixo risco de erros -Uma constante que representa um determinado valor ao longo de um programa é menos propensa a erros. Se quisermos alterar a precisão dos cálculos, substituir o valor pode ser arriscado. Em vez de substituí-lo, podemos criar constantes diferentes para diferentes níveis de precisão e alterar o código onde for necessário.Armazenamento de dados seguro para threads -Constantes são objetos thread-safe, o que significa que vários threads podem usar uma constante simultaneamente sem correr o risco de perder dados.

Constantes definidas pelo usuário

Precisamos usar a convenção de nomenclatura em Python para definir a constante em Python. Devemos escrever o nome em letras maiúsculas com sublinhados separando as palavras.

A seguir estão os exemplos das constantes Python definidas pelo usuário -

 PI = 3.14 MAX_SPEED = 300 DEFAULT_COLOR = '33[1;34m' WIDTH = 20 API_TOKEN = '567496396372' BASE_URL = 'https://api.example.com' DEFAULT_TIMEOUT = 5 BUILTINS_METHODS = ('sum', 'max', 'min', 'abs') INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', ... ] 

Usamos a mesma forma que criamos variáveis ​​em Python. Portanto, podemos assumir que as constantes do Python são apenas variáveis, e a única distinção é que a constante usa apenas letras maiúsculas.

Usar letras maiúsculas faz com que a constante se destaque de nossas variáveis ​​e é uma prática útil ou preferida.

Acima discutimos os usuários definidos pelo usuário; Python também fornece vários nomes internos que podem ser considerados e devem ser tratados como constantes.

Constantes importantes em Python

Nesta seção, aprenderemos sobre algumas constantes internas que são usadas para tornar o código Python mais legível. Vamos entender algumas constantes importantes.

Constantes integradas

Na documentação oficial, o Verdadeiro e Falso são listados como a primeira constante. Esses são valores booleanos do Python e são a instância do int. A Verdadeiro tem valor 1 e Falso tem um valor 0.

string java substituir

Exemplo -

 >>> True True >>> False False >>> isinstance(True, int) True >>> isinstance(False, int) True >>> int(True) 1 >>> int(False) 0 >>> True = 42 ... SyntaxError: cannot assign to True >>> True is True True >>> False is False True 

Lembre-se de que os nomes verdadeiros e falsos são constantes estritas. Em outras palavras, não podemos reatribuí-los e, se tentarmos reatribuí-los, obteremos um erro de sintaxe. Esses dois valores são objetos singleton em Python, o que significa que existe apenas uma instância.

Nomes internos de Dunder

Python também tem muitos recursos internos trovão nomes que podemos considerar constantes. Existem vários desses nomes exclusivos, aprenderemos sobre __name__ e __file__ nesta seção.

O atributo __name__ está relacionado a como executar um determinado trecho de código. Ao importar um módulo, o Python interno define __name__ como uma string contendo o nome do módulo.

novo_arquivo.py

 print(f'The type of __name__ is: {type(__name__)}') print(f'The value of __name__ is: {__name__}') 

Na linha de comando e digite o seguinte comando -

 python -c 'import new_file' 

O -c é usado para executar um pequeno trecho de código Python na linha de comando. No exemplo acima, importamos o novo arquivo módulo, que exibe algumas mensagens na tela.

Saída -

 The type of __name__ is: The value of __name__ is: timezone 

Como podemos ver que __name__ armazena a string __main__, indica que podemos executar os arquivos executáveis ​​​​diretamente como um programa Python.

Por outro lado, o atributo __file__ contém o arquivo que o Python está importando ou executando no momento. Se usarmos o atributo __file__ dentro do arquivo, obteremos o caminho para o próprio módulo.

Vejamos o seguinte exemplo -

Exemplo -

 print(f'The type of __file__ is: {type(__file__)}') print(f'The value of __file__ is: {__file__}') 

Saída:

 The type of __file__ is: The value of __file__ is: D:Python Project
ew_file.py 

Também podemos executar diretamente e obteremos o mesmo resultado.

Exemplo -

 print(f'The type of __file__ is: {type(__file__)}') print(f'The value of __file__ is: {__file__}') 

Saída:

 python new_file.py The type of __file__ is: The value of __file__ is: timezone.py 

Strings úteis e constantes matemáticas

Existem muitas constantes valiosas na biblioteca padrão. Alguns estão estritamente conectados a módulos, funções e classes específicas; muitos são genéricos e podemos usá-los em diversos cenários. No exemplo abaixo, usaremos os módulos matemáticos e relacionados a strings, math e string, respectivamente.

Vamos entender o seguinte exemplo -

Exemplo -

 >>> import math >>> math.pi 3.141592653589793 >>> math.tau 6.283185307179586 >>> math.nan nan >>> math.inf inf >>> math.sin(30) -0.9880316240928618 >>> math.cos(60) -0.9524129804151563 >>> math.pi 3.141592653589793 

Essas constantes desempenharão um papel vital quando escrevermos código relacionado à matemática ou realizarmos alguns cálculos específicos.

algoritmo de mesclagem

Vamos entender o seguinte exemplo -

Exemplo -

 import math class Sphere: def __init__(self, radius): self.radius = radius def area(self): return math.pi * self.radius**2 def perimeter(self): return 2 * math.pi * self.radius def projected_volume(self): return 4/3 * math.pi * self.radius**3 def __repr__(self): return f'{self.__class__.__name__}(radius={self.radius})' 

No código acima, usamos o matemática.pi em vez de personalizado PI constantes. A constante relacionada à matemática fornece mais contextos ao programa. A vantagem de usar a constante math.pi é que se estivermos usando uma versão mais antiga do Python, obteremos uma versão de 32 bits do Pi. Se usarmos o programa acima na versão moderna do Python, obteremos uma versão de pi de 64 bits. Portanto, nosso programa se auto-adaptará ao seu ambiente de execução concreto.

O módulo string também fornece algumas constantes de string integradas úteis. Abaixo está a tabela do nome e valor de cada constante.

Podemos usar essas constantes relacionadas a strings em expressões regulares, processando linguagem natural, com muito processamento de strings e muito mais.

Constantes de anotação de tipo

Desde o Python 3.8, o módulo de digitação inclui uma classe Final que nos permite anotar constantes. Se usarmos a classe Final para definir as constantes no programa, obteremos o erro de tipo estático que o verificador mypy verifica e mostrará que não podemos reatribuir ao nome Final. Vamos entender o exemplo a seguir.

Exemplo -

 from typing import Final MAX_Marks: Final[int] = 300 MAX_Students: Final[int] = 500 MAX_Marks = 450 # Cannot assign to final name 'MAX_SPEED' mypy(error) 

Especificamos a variável constante com a classe final que indicava o tipo de erro para relatar um erro se um nome declarado fosse reatribuído. No entanto, ele recebe um relatório de erro do verificador de tipo; Python altera o valor de MAX_SPEED. Portanto, Final não evita reatribuições acidentais constantes em tempo de execução.

Constantes de string

Conforme discutido na seção anterior, Python não oferece suporte a constantes estritas; apenas tem variáveis ​​que nunca mudam. Portanto, a comunidade Python segue a convenção de nomenclatura de usar letras maiúsculas para identificar as variáveis ​​constantes.

Pode ser um problema se trabalharmos em um grande projeto Python com muitos programadores em diferentes níveis. Portanto, seria uma boa prática ter um mecanismo que nos permitisse usar constantes estritas. Como sabemos, Python é uma linguagem dinâmica e existem várias maneiras de tornar as constantes imutáveis. Nesta seção, aprenderemos sobre algumas dessas maneiras.

Os atributos .__slots__

As classes Python fornecem a facilidade de usar os atributos __slots__. O slot possui mecanismo especial para reduzir o tamanho dos objetos. É um conceito de otimização de memória em objetos. Se usarmos o atributo __slots__ na classe, não poderemos adicionar a nova instância, pois ela não usa atributos __dict__. Além disso, não ter .__dict__ atributo implica uma otimização em termos de consumo de memória. Vamos entender o exemplo a seguir.

Exemplo - Sem usar atributos __slots__

 class NewClass(object): def __init__(self, *args, **kwargs): self.a = 1 self.b = 2 if __name__ == '__main__': instance = NewClass() print(instance.__dict__) 

Saída -

conversão de int para string

 {'a': 1, 'b': 2} 

Cada objeto em Python contém um dicionário dinâmico que permite adicionar atributos. Os dicionários consomem muita memória e o uso de __slots__ reduz o desperdício de espaço e memória. Vejamos outro exemplo.

Exemplo -

 class ConstantsName: __slots__ = () PI = 3.141592653589793 EULER_NUMBER = 2.718281828459045 constant = ConstantsName() print(constant.PI) print(constant.EULER_NUMBER) constant.PI = 3.14 print(constant.PI) 

Saída -

 3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 10, in AttributeError: 'ConstantsName' object attribute 'PI' is read-only 

No código acima, inicializamos os atributos de classe com os atributos de slots. A variável tem um valor constante, se tentarmos reatribuir a variável obteremos um erro.

O decorador @property

Também podemos usar @propriedade decorator para criar uma classe que funcione como namespace para constantes. Precisamos apenas definir a propriedade constantes sem fornecer a elas um método setter. Vamos entender o exemplo a seguir.

Exemplo -

 class ConstantsName: @property def PI(self): return 3.141592653589793 @property def EULER_NUMBER(self): return 2.718281828459045 constant = ConstantsName() print(constant.PI) print(constant.EULER_NUMBER) constant.PI = 3.14 print(constant.PI) 

Saída -

 3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 13, in AttributeError: can't set attribute 

São apenas propriedades somente leitura, se tentarmos reatribuir, obteremos um AtributoError.

A função de fábrica nomeadatuple()

O módulo de coleção do Python vem com a função de fábrica chamada NamedTuple(). Usando o nomeadatupla() função, podemos usar os campos nomeados e a notação de ponto para acessar seus itens. Sabemos que as tuplas são imutáveis, o que significa que não podemos modificar um objeto de tupla nomeado existente.

Vamos entender o exemplo a seguir.

Exemplo -

 from collections import namedtuple ConstantsName = namedtuple( 'ConstantsName', ['PI', 'EULER_NUMBER'] ) constant = ConstantsName(3.141592653589793, 2.718281828459045) print(constant.PI) print(constant.EULER_NUMBER) constant.PI = 3.14 print(constant.PI) 

Saída -

 3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 17, in AttributeError: can't set attribute 

O decorador @dataclass

Como o próprio nome sugere, a classe de dados contém dados, eles podem consistir em métodos, mas esse não é seu objetivo principal. Precisamos usar o decorador @dataclass para criar as classes de dados. Também podemos criar constantes estritas. O decorador @dataclass usa um argumento congelado que nos permite marcar nossa classe de dados como imutável. As vantagens de usar o decorador @dataclass, não podemos modificar seu atributo de instância.

Vamos entender o exemplo a seguir.

Exemplo -

 from dataclasses import dataclass @dataclass(frozen=True) class ConstantsName: PI = 3.141592653589793 EULER_NUMBER = 2.718281828459045 constant = ConstantsName() print(constant.PI) print(constant.EULER_NUMBER) constant.PI = 3.14 print(constant.PI) 

Saída -

char para string java

 3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 19, in File '', line 4, in __setattr__ dataclasses.FrozenInstanceError: cannot assign to field 'PI' 

Explicação -

No código acima, importamos o decorador @dataclass. Usamos esse decorador para ConstantsName para torná-lo uma classe de dados. Definimos o argumento frozen como True para tornar a classe de dados imutável. Criamos a instância da classe de dados e podemos acessar todas as constantes, mas não podemos modificá-las.

O método especial .__setattr__()

Python nos permite usar um método especial chamado .__setattr__(). Usando este método, podemos personalizar o processo de atribuição de atributos porque Python chama automaticamente o método em cada atribuição de atributos. Vamos entender o seguinte exemplo -

Exemplo -

 class ConstantsName: PI = 3.141592653589793 EULER_NUMBER = 2.718281828459045 def __setattr__(self, name, value): raise AttributeError(f'can't reassign constant '{name}'') constant = ConstantsName() print(constant.PI) print(constant.EULER_NUMBER) constant.PI = 3.14 print(constant.PI) 

Saída -

 3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 22, in File '', line 17, in __setattr__ AttributeError: can't reassign constant 'PI' 

O método __setattr__() não permite realizar nenhuma operação de atribuição nos atributos da classe. Se tentarmos reatribuir, isso apenas levantará um AtributoError.

Conclusão

Constantes são mais usadas conceitualmente em programação, especialmente em termos matemáticos. Neste tutorial, aprendemos sobre os conceitos importantes das constantes e seus sabores. A comunidade Python usa letras maiúsculas como convenção de nome para identificar as constantes. No entanto, discutimos algumas maneiras avançadas de usar constantes em Python. Discutimos como melhorar a legibilidade, reutilização e manutenção do código com constantes. Mencionamos como aplicar várias técnicas para tornar nossas constantes Python estritamente constantes.