En este tutorial, aprenderemos sobre los tipos de constantes y cómo ayudan a mejorar la legibilidad del código. Si no está familiarizado, las constantes son los nombres que representan valores que no cambian durante la ejecución del programa. Son el concepto fundamental más común en programación. Sin embargo, Python no tiene una sintaxis dedicada para definir constantes. En general, las constantes de Python son variables que nunca cambian. Tendremos una discusión detallada sobre la constante de Python en la próxima sección.
¿Qué son las constantes?
Generalmente, en Matemáticas se utiliza un término constante, un valor o cantidad que nunca cambia. En programación, una constante se refiere al nombre asociado con un valor que nunca cambia durante la ejecución de la programación. La constante de programación es diferente de otras constantes y consta de dos cosas: un nombre y un valor asociado. El nombre describirá de qué se trata la constante y el valor es la expresión concreta de la constante misma.
Una vez que definimos la constante, solo podemos acceder a su valor pero no podemos cambiarlo con el tiempo. Sin embargo, podemos modificar el valor de la variable. Un ejemplo de la vida real es: la velocidad de la luz, la cantidad de minutos en una hora y el nombre de la carpeta raíz de un proyecto.
¿Por qué utilizar constante?
En los lenguajes de programación, las constantes nos permiten protegernos contra cambios accidentales de su valor, lo que puede provocar errores difíciles de depurar. También es útil hacer que el código sea más legible y fácil de mantener. Veamos algunas ventajas de la constante.
Constantes definidas por el usuario
Necesitamos usar la convención de nomenclatura en Python para definir la constante en Python. Debemos escribir el nombre en mayúsculas con guiones bajos separando las palabras.
A continuación se muestran el ejemplo de las constantes de Python definidas por el usuario:
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', ... ]
Hemos utilizado la misma forma que creamos variables en Python. Entonces podemos asumir que las constantes de Python son solo variables, y la única distinción es que la constante usa solo letras mayúsculas.
El uso de letras mayúsculas hace que la constante se destaque de nuestras variables y es una práctica útil o preferida.
Arriba discutimos los usuarios definidos por el usuario; Python también proporciona varios nombres internos que pueden considerarse y deben tratarse como constantes.
java comparar cadenas
Constantes importantes en Python
En esta sección, aprenderemos sobre algunas constantes internas que se utilizan para hacer que el código Python sea más legible. Entendamos algunas constantes importantes.
Constantes incorporadas
En la documentación oficial, el Verdadero y FALSO se enumeran como la primera constante. Estos son valores booleanos de Python y son la instancia de int. A Verdadero tiene un valor de 1, y FALSO tiene un valor 0.
Ejemplo -
>>> 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
Recuerde que los nombres verdaderos y falsos son constantes estrictas. En otras palabras, no podemos reasignarlos y si intentamos reasignarlos obtendremos un error de sintaxis. Estos dos valores son objetos únicos en Python, lo que significa que solo existe una instancia.
Nombres internos de Dunder
Python también tiene muchas funciones internas. trueno nombres que podemos considerar constantes. Hay varios de estos nombres únicos; aprenderemos sobre __nombre__ y __archivo__ en esta sección.
El atributo __name__ está relacionado con cómo ejecutar un fragmento de código determinado. Al importar un módulo, Python establece internamente __name__ en una cadena que contiene el nombre del módulo.
new_file.py
print(f'The type of __name__ is: {type(__name__)}') print(f'The value of __name__ is: {__name__}') En la línea de comando y escriba el siguiente comando:
python -c 'import new_file'
-c se utiliza para ejecutar un pequeño fragmento de código de Python en la línea de comando. En el ejemplo anterior, importamos el archivo nuevo módulo, que muestra algunos mensajes en la pantalla.
Producción -
The type of __name__ is: The value of __name__ is: timezone
Como podemos ver, __name__ almacena la cadena __main__, indica que podemos ejecutar los archivos ejecutables directamente como un programa Python.
Por otro lado, el atributo __file__ tiene el archivo que Python está importando o ejecutando actualmente. Si usamos el atributo __file__ dentro del archivo, obtendremos la ruta al módulo en sí.
Veamos el siguiente ejemplo:
Ejemplo -
print(f'The type of __file__ is: {type(__file__)}') print(f'The value of __file__ is: {__file__}') Producción:
The type of __file__ is: The value of __file__ is: D:Python Project ew_file.py
También podemos ejecutarlo directamente y obtendremos el mismo resultado.
Ejemplo -
print(f'The type of __file__ is: {type(__file__)}') print(f'The value of __file__ is: {__file__}') Producción:
python new_file.py The type of __file__ is: The value of __file__ is: timezone.py
Constantes matemáticas y de cadenas útiles
Hay muchas constantes valiosas en la biblioteca estándar. Algunos están estrictamente relacionados con módulos, funciones y clases específicas; muchos son genéricos y podemos usarlos en varios escenarios. En el siguiente ejemplo, usaremos los módulos matemáticos y relacionados con cadenas math y string, respectivamente.
Entendamos el siguiente ejemplo:
código java de muestra
Ejemplo -
>>> 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
Estas constantes desempeñarán un papel vital cuando escribimos código relacionado con las matemáticas o realizamos algunos cálculos específicos.
Entendamos el siguiente ejemplo:
Ejemplo -
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})' En el código anterior, hemos utilizado el matemáticas.pi en lugar de costumbre Pi constantes. La constante relacionada con las matemáticas proporciona más contextos al programa. La ventaja de usar la constante math.pi es que si usamos una versión anterior de Python, obtendremos una versión de Pi de 32 bits. Si usamos el programa anterior en una versión moderna de Python, obtendremos una versión de pi de 64 bits. Entonces nuestro programa se autoadaptará a su entorno de ejecución concreto.
El módulo de cadena también proporciona algunas constantes de cadena integradas útiles. A continuación se muestra la tabla del nombre y valor de cada constante.
| Nombre | Valor |
|---|---|
| ascii_minúsculas | ABCDEFGHIJKLMNOPQRSTU VWXYZ |
| ascii_mayúsculas | ABCDEFGHIJKLMNOPQRSTU VWXYZ |
| letras_ascii | ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz |
| dígitos | 0123456789 |
| dígitos hexadecimales | 0123456789abcdefABCDEF |
| octdígitos | 01234567 |
Podemos usar estas constantes relacionadas con cadenas en expresiones regulares, procesando lenguaje natural, con mucho procesamiento de cadenas y más.
Constantes de anotación de tipo
Desde Python 3.8, el módulo de escritura incluye una clase Final que nos permite escribir y anotar constantes. Si usamos la clase Final para definir las constantes en el programa, obtendremos el error de tipo estático que verifica el verificador mypy y mostrará que no podemos reasignar al nombre Final. Entendamos el siguiente ejemplo.
Ejemplo -
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 la variable constante con la Clase Final que indicaba el tipo de error para informar un error si se reasigna un nombre declarado. Sin embargo, recibe un informe de un error del verificador de tipos; Python cambia el valor de MAX_SPEED. Por lo tanto, Final no evita la reasignación accidental constante en tiempo de ejecución.
Constantes de cadena
Como se analizó en la sección anterior, Python no admite constantes estrictas; simplemente tiene variables que nunca cambian. Por lo tanto, la comunidad Python sigue la convención de nomenclatura de utilizar letras mayúsculas para identificar las variables constantes.
Puede ser un problema si trabajamos en un gran proyecto Python con muchos programadores en diferentes niveles. Por tanto, sería una buena práctica tener un mecanismo que nos permita utilizar constantes estrictas. Como sabemos, Python es un lenguaje dinámico y hay varias formas de hacer que las constantes no se puedan modificar. En esta sección, aprenderemos sobre algunas de estas formas.
Los atributos .__slots__
Las clases de Python brindan la posibilidad de utilizar los atributos __slots__. La ranura tiene un mecanismo especial para reducir el tamaño de los objetos. Es un concepto de optimización de la memoria de los objetos. Si usamos el atributo __slots__ en la clase, no podremos agregar la nueva instancia porque no usa atributos __dict__. Además, no tener un .__dict__ El atributo implica una optimización en términos de consumo de memoria. Entendamos el siguiente ejemplo.
Ejemplo: sin utilizar atributos __slots__
class NewClass(object): def __init__(self, *args, **kwargs): self.a = 1 self.b = 2 if __name__ == '__main__': instance = NewClass() print(instance.__dict__)
Producción -
formatear fecha en cadena
{'a': 1, 'b': 2} Cada objeto en Python contiene un diccionario dinámico que permite agregar atributos. Los diccionarios consumen mucha memoria y el uso de __slots__ reduce el desperdicio de espacio y memoria. Veamos otro ejemplo.
Ejemplo -
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)
Producción -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 10, in AttributeError: 'ConstantsName' object attribute 'PI' is read-only
En el código anterior, inicializamos los atributos de clase con los atributos de ranuras. La variable tiene un valor constante, si intentamos reasignar la variable obtendremos un error.
El decorador de @property
También podemos usar @propiedad decorador para crear una clase que funcione como espacio de nombres para constantes. Solo necesitamos definir la propiedad de las constantes sin proporcionarles un método de establecimiento. Entendamos el siguiente ejemplo.
Ejemplo -
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)
Producción -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 13, in AttributeError: can't set attribute
Son sólo propiedades de sólo lectura, si intentamos reasignarlas, obtendremos un Error de atributo.
La función de fábrica nombradatuple()
El módulo de colección de Python viene con la función de fábrica llamada namedtuple(). Utilizando el tupla con nombre() función, podemos usar los campos nombrados y la notación de puntos para acceder a sus elementos. Sabemos que las tuplas son inmutables, lo que significa que no podemos modificar un objeto tupla con nombre existente en su lugar.
Entendamos el siguiente ejemplo.
tachado de rebajas
Ejemplo -
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)
Producción -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 17, in AttributeError: can't set attribute
El decorador @dataclass
Como sugiere su nombre, la clase de datos contiene datos, pueden consistir en métodos, pero no es su objetivo principal. Necesitamos usar el decorador @dataclass para crear las clases de datos. También podemos crear constantes estrictas. El decorador @dataclass toma un argumento congelado que nos permite marcar nuestra clase de datos como inmutable. Las ventajas de usar el decorador @dataclass es que no podemos modificar su atributo de instancia.
Entendamos el siguiente ejemplo.
Ejemplo -
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)
Producción -
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'
Explicación -
En el código anterior, hemos importado el decorador @dataclass. Usamos este decorador para ConstantsName para convertirlo en una clase de datos. Establecemos el argumento congelado en Verdadero para que la clase de datos sea inmutable. Creamos la instancia de la clase de datos y podemos acceder a todas las constantes pero no podemos modificarlas.
El método especial .__setattr__()
Python nos permite usar un método especial llamado .__setattr__(). Con este método, podemos personalizar el proceso de asignación de atributos porque Python llama automáticamente al método en cada asignación de atributos. Entendamos el siguiente ejemplo:
Ejemplo -
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) Producción -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 22, in File '', line 17, in __setattr__ AttributeError: can't reassign constant 'PI'
El método __setattr__() no permite realizar ninguna operación de asignación sobre los atributos de la clase. Si intentamos reasignar, simplemente generará un Error de atributo.
Conclusión
Las constantes se utilizan más en concepto de programación, especialmente en términos matemáticos. En este tutorial, hemos aprendido sobre los conceptos importantes de las constantes y sus sabores. La comunidad Python utiliza letras mayúsculas como convención de nombres para identificar las constantes. Sin embargo, hemos analizado algunas formas avanzadas de utilizar las constantes en Python. Hemos discutido cómo mejorar la legibilidad, reutilización y mantenibilidad del código con constantes. Mencionamos cómo aplicar varias técnicas para hacer que nuestras constantes de Python sean estrictamente constantes.