Dans ce didacticiel, nous découvrirons les types de constantes et comment ils contribuent à améliorer la lisibilité du code. Si vous n'êtes pas familier, les constantes sont les noms représentant des valeurs qui ne changent pas pendant l'exécution du programme. Il s’agit du concept fondamental le plus courant en programmation. Cependant, Python ne dispose pas de syntaxe dédiée pour définir les constantes. En général, les constantes Python sont des variables qui ne changent jamais. Nous aurons une discussion détaillée sur la constante Python dans la section à venir.
tableaux java
Que sont les constantes ?
Généralement, un terme constant est utilisé en mathématiques, une valeur ou une quantité qui ne change jamais. En programmation, une constante fait référence au nom associé à une valeur qui ne change jamais lors de l'exécution de la programmation. La constante de programmation est différente des autres constantes et se compose de deux éléments : un nom et une valeur associée. Le nom décrira en quoi consiste la constante et la valeur est l’expression concrète de la constante elle-même.
Une fois que nous avons défini la constante, nous ne pouvons accéder qu'à sa valeur mais ne pouvons pas la modifier au fil du temps. Cependant, on peut modifier la valeur de la variable. Un exemple concret est : la vitesse de la lumière, le nombre de minutes dans une heure et le nom du dossier racine d'un projet.
Pourquoi utiliser Constant ?
Dans les langages de programmation, les constantes nous permettent de nous protéger contre une modification accidentelle de leur valeur, ce qui pourrait provoquer des erreurs difficiles à déboguer. Il est également utile de rendre le code plus lisible et maintenable. Voyons quelques avantages de constant.
Constantes définies par l'utilisateur
Nous devons utiliser la convention de dénomination en Python pour définir la constante en Python. Nous devons écrire le nom en majuscules avec des traits de soulignement séparant les mots.
Voici l'exemple des constantes Python définies par l'utilisateur -
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', ... ]
Nous avons utilisé la même manière que nous créons des variables en Python. Nous pouvons donc supposer que les constantes Python ne sont que des variables, et la seule distinction est que la constante utilise uniquement des lettres majuscules.
L'utilisation de lettres majuscules permet à la constante de se démarquer de nos variables et constitue une pratique utile ou privilégiée.
Ci-dessus, nous avons discuté des utilisateurs définis par l'utilisateur ; Python fournit également plusieurs noms internes qui peuvent être considérés et doivent être traités comme des constantes.
Constantes importantes en Python
Dans cette section, nous découvrirons certaines constantes internes utilisées pour rendre le code Python plus lisible. Comprenons quelques constantes importantes.
Constantes intégrées
Dans la documentation officielle, le Vrai et FAUX sont répertoriés comme première constante. Ce sont des valeurs booléennes Python et sont l'instance de l'int. UN Vrai a une valeur de 1, et FAUX a une valeur 0.
Exemple -
>>> 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
N'oubliez pas que les noms True et False sont des constantes strictes. En d’autres termes, nous ne pouvons pas les réaffecter, et si nous essayons de les réaffecter, nous obtiendrons une erreur de syntaxe. Ces deux valeurs sont des objets singleton en Python, ce qui signifie qu'une seule instance existe.
Noms Dunder internes
Python possède également de nombreux tonnerre noms que nous pouvons considérer comme des constantes. Il existe plusieurs de ces noms uniques, nous en apprendrons davantage sur __name__ et __file__ dans cette section.
L'attribut __name__ est lié à la façon d'exécuter un morceau de code donné. Lors de l'importation d'un module, Python interne définit le __name__ sur une chaîne contenant le nom du module.
nouveau_file.py
print(f'The type of __name__ is: {type(__name__)}') print(f'The value of __name__ is: {__name__}') Dans la ligne de commande et tapez la commande suivante -
python -c 'import new_file'
Le -c est utilisé pour exécuter un petit morceau de code de Python sur la ligne de commande. Dans l'exemple ci-dessus, nous avons importé le nouveau fichier module, qui affiche des messages à l'écran.
Sortir -
The type of __name__ is: The value of __name__ is: timezone
Comme nous pouvons voir que le __name__ stocke la chaîne __main__, indique que nous pouvons exécuter les fichiers exécutables directement en tant que programme Python.
D'un autre côté, l'attribut __file__ contient le fichier que Python est en train d'importer ou d'exécuter. Si nous utilisons l'attribut __file__ à l'intérieur du fichier, nous obtiendrons le chemin d'accès au module lui-même.
Voyons l'exemple suivant -
Exemple -
1 à 100 romains non
print(f'The type of __file__ is: {type(__file__)}') print(f'The value of __file__ is: {__file__}') Sortir:
The type of __file__ is: The value of __file__ is: D:Python Project ew_file.py
Nous pouvons également exécuter directement et obtiendrons le même résultat.
Exemple -
print(f'The type of __file__ is: {type(__file__)}') print(f'The value of __file__ is: {__file__}') Sortir:
python new_file.py The type of __file__ is: The value of __file__ is: timezone.py
Constantes de chaîne et mathématiques utiles
Il existe de nombreuses constantes précieuses dans la bibliothèque standard. Certains sont strictement liés à des modules, fonctions et classes spécifiques ; beaucoup sont génériques et nous pouvons les utiliser dans plusieurs scénarios. Dans l'exemple ci-dessous, nous utiliserons respectivement les modules math et string liés aux mathématiques.
Comprenons l'exemple suivant -
Exemple -
>>> 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
Ces constantes joueront un rôle essentiel lorsque nous écrirons du code mathématique ou effectuerons des calculs spécifiques.
Comprenons l'exemple suivant -
convertir une chaîne en jsonobject java
Exemple -
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})' Dans le code ci-dessus, nous avons utilisé le math.pi au lieu de personnalisé PI constantes. La constante liée aux mathématiques fournit plus de contextes au programme. L'avantage d'utiliser la constante math.pi est que si nous utilisons une ancienne version de Python, nous obtiendrons une version 32 bits de Pi. Si nous utilisons le programme ci-dessus dans la version moderne de Python, nous obtiendrons une version 64 bits de pi. Notre programme s’auto-adaptera donc à son environnement d’exécution concret.
Le module string fournit également des constantes de chaîne intégrées utiles. Vous trouverez ci-dessous le tableau du nom et de la valeur de chaque constante.
| Nom | Valeur |
|---|---|
| ascii_minuscule | Abcdefghijklmnopqrstuvwxyz |
| ascii_majuscule | ABCDEFGHIJKLMNOPQRSTUVWXYZ |
| ascii_letters | ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz |
| chiffres | 0123456789 |
| chiffres hexadécimaux | 0123456789abcdefABCDEF |
| octchiffres | 01234567 |
Nous pouvons utiliser ces constantes liées aux chaînes dans les expressions régulières, le traitement du langage naturel, avec de nombreux traitements de chaînes, et bien plus encore.
Constantes d'annotation de type
Depuis Python 3.8, le module de typage inclut une classe Final qui nous permet d'annoter des constantes. Si nous utilisons la classe Final pour définir les constantes dans le programme, nous obtiendrons l'erreur de type statique que le vérificateur mypy vérifie et il montrera que nous ne pouvons pas réattribuer le nom Final. Comprenons l'exemple suivant.
Exemple -
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)
Nous avons spécifié la variable constante avec la classe finale qui indiquait l'erreur de type pour signaler une erreur si un nom déclaré est réaffecté. Cependant, il reçoit un rapport d'erreur d'un vérificateur de type ; Python modifie la valeur de MAX_SPEED. Ainsi, Final n'empêche pas une réaffectation accidentelle constante au moment de l'exécution.
Constantes de chaîne
Comme indiqué dans la section précédente, Python ne prend pas en charge les constantes strictes ; il a juste des variables qui ne changent jamais. Par conséquent, la communauté Python suit la convention de dénomination consistant à utiliser la lettre majuscule pour identifier les variables constantes.
Cela peut être un problème si nous travaillons sur un grand projet Python avec de nombreux programmeurs à différents niveaux. Ce serait donc une bonne pratique d’avoir un mécanisme qui nous permette d’utiliser des constantes strictes. Comme nous le savons, Python est un langage dynamique et il existe plusieurs façons de rendre les constantes immuables. Dans cette section, nous découvrirons certaines de ces méthodes.
Les attributs .__slots__
Les classes Python offrent la possibilité d'utiliser les attributs __slots__. La fente dispose d'un mécanisme spécial pour réduire la taille des objets. C'est un concept d'optimisation de la mémoire sur les objets. Si nous utilisons l'attribut __slots__ dans la classe, nous ne pourrons pas ajouter la nouvelle instance, car elle n'utilise pas les attributs __dict__. De plus, ne pas avoir de .__dict__ L'attribut implique une optimisation en termes de consommation mémoire. Comprenons l'exemple suivant.
Exemple - Sans utiliser les attributs __slots__
class NewClass(object): def __init__(self, *args, **kwargs): self.a = 1 self.b = 2 if __name__ == '__main__': instance = NewClass() print(instance.__dict__)
Sortir -
préparer le test mockito
{'a': 1, 'b': 2} Chaque objet en Python contient un dictionnaire dynamique qui permet d'ajouter des attributs. Les dictionnaires consomment beaucoup de mémoire et l'utilisation de __slots__ réduit le gaspillage d'espace et de mémoire. Voyons un autre exemple.
Exemple -
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)
Sortir -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 10, in AttributeError: 'ConstantsName' object attribute 'PI' is read-only
Dans le code ci-dessus, nous avons initialisé les attributs de classe avec les attributs slots. La variable a une valeur constante, si nous essayons de réaffecter la variable, nous obtiendrons une erreur.
Le décorateur @property
Nous pouvons également utiliser @propriété décorateur pour créer une classe qui fonctionne comme un espace de noms pour les constantes. Nous avons juste besoin de définir la propriété constants sans leur fournir de méthode setter. Comprenons l'exemple suivant.
Exemple -
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)
Sortir -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 13, in AttributeError: can't set attribute
Ce sont juste des propriétés en lecture seule, si nous essayons de réaffecter, nous obtiendrons un Erreur d'attribut.
La fonction d'usine nomméetuple()
Le module de collection de Python est livré avec la fonction d'usine appelée approvedtuple(). En utilisant le tuple nommé() fonction, nous pouvons utiliser les champs nommés et la notation par points pour accéder à leurs éléments. Nous savons que les tuples sont immuables, ce qui signifie que nous ne pouvons pas modifier un objet tuple nommé existant sur place.
Comprenons l'exemple suivant.
Exemple -
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)
Sortir -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 17, in AttributeError: can't set attribute
Le décorateur @dataclass
Comme son nom l’indique, la classe data contient des données, elles peuvent être constituées de méthodes, mais ce n’est pas leur objectif premier. Nous devons utiliser le décorateur @dataclass pour créer les classes de données. Nous pouvons également créer les constantes strictes. Le décorateur @dataclass prend un argument figé qui nous permet de marquer notre classe de données comme immuable. Les avantages de l'utilisation du décorateur @dataclass, nous ne pouvons pas modifier son attribut d'instance.
Comprenons l'exemple suivant.
arbre b+
Exemple -
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)
Sortir -
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'
Explication -
Dans le code ci-dessus, nous avons importé le décorateur @dataclass. Nous avons utilisé ce décorateur pour ConstantsName pour en faire une classe de données. Nous définissons l'argument gelé sur True pour rendre la classe de données immuable. Nous avons créé l'instance de la classe de données, et nous pouvons accéder à toutes les constantes mais ne pouvons pas les modifier.
La méthode spéciale .__setattr__()
Python nous permet d'utiliser une méthode spéciale appelée .__setattr__(). En utilisant cette méthode, nous pouvons personnaliser le processus d'attribution d'attributs car Python appelle automatiquement la méthode à chaque attribution d'attribut. Comprenons l'exemple suivant -
Exemple -
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) Sortir -
3.141592653589793 2.718281828459045 Traceback (most recent call last): File '', line 22, in File '', line 17, in __setattr__ AttributeError: can't reassign constant 'PI'
La méthode __setattr__() ne permet d'effectuer aucune opération d'affectation sur les attributs de la classe. Si nous essayons de réaffecter, cela soulève simplement un Erreur d'attribut.
Conclusion
Les constantes sont les plus utilisées dans le concept de programmation, notamment en termes mathématiques. Dans ce didacticiel, nous avons découvert les concepts importants des constantes et de leurs saveurs. La communauté Python utilise la lettre majuscule comme convention de nom pour identifier les constantes. Cependant, nous avons discuté de certaines manières avancées d'utiliser les constantes en Python. Nous avons discuté de la manière d'améliorer la lisibilité, la réutilisabilité et la maintenabilité du code avec des constantes. Nous avons mentionné comment appliquer diverses techniques pour rendre nos constantes Python strictement constantes.