Tous les objets partagent des variables de classe ou statiques. Une instance ou des variables non statiques sont différentes pour différents objets (chaque objet a une copie). Par exemple, laissez un étudiant en informatique être représenté par une classe Étudiant CSS . La classe peut avoir une variable statique dont la valeur est cse pour tous les objets. Et la classe peut également avoir des membres non statiques comme nom et rouler .
En C++ et Java, nous pouvons utiliser des mots-clés statiques pour faire d'une variable une variable de classe. Les variables qui n’ont pas de mot-clé statique précédent sont des variables d’instance. Voir ceci pour l'exemple Java et ceci pour l'exemple C++.
Explication:
En Python, une variable statique est une variable partagée entre toutes les instances d'une classe, plutôt que d'être unique à chaque instance. On l'appelle aussi parfois variable de classe, car elle appartient à la classe elle-même plutôt qu'à une instance particulière de la classe.
Les variables statiques sont définies dans la définition de classe, mais en dehors de toute définition de méthode. Ils sont généralement initialisés avec une valeur, tout comme une variable d'instance, mais ils sont accessibles et modifiables via la classe elle-même, plutôt que via une instance.
Caractéristiques des variables statiques
- Les variables statiques se voient allouer de la mémoire une fois lorsque l'objet de la classe est créé pour la première fois.
- Les variables statiques sont créées en dehors des méthodes mais à l'intérieur d'une classe
- Les variables statiques sont accessibles via une classe mais pas directement avec une instance.
- Le comportement des variables statiques ne change pas pour chaque objet.
L'approche Python est simple ; cela ne nécessite pas de mot-clé statique.
Note: Toutes les variables auxquelles est attribuée une valeur dans le la déclaration de classe sont des variables de classe. Et les variables que les valeurs attribuées à l'intérieur des méthodes sont des variables d'instance.
java sinon
Exemple:
Python
# Python program to show that the variables with a value> # assigned in class declaration, are class variables> # Class for Computer Science Student> class> CSStudent:> >stream>=> 'cse'> # Class Variable> >def> __init__(>self>,name,roll):> >self>.name>=> name># Instance Variable> >self>.roll>=> roll># Instance Variable> # Objects of CSStudent class> a>=> CSStudent(>'Geek'>,>1>)> b>=> CSStudent(>'Nerd'>,>2>)> print>(a.stream)># prints 'cse'> print>(b.stream)># prints 'cse'> print>(a.name)># prints 'Geek'> print>(b.name)># prints 'Nerd'> print>(a.roll)># prints '1'> print>(b.roll)># prints '2'> # Class variables can be accessed using class> # name also> print>(CSStudent.stream)># prints 'cse'> # Now if we change the stream for just a it won't be changed for b> a.stream>=> 'ece'> print>(a.stream)># prints 'ece'> print>(b.stream)># prints 'cse'> # To change the stream for all instances of the class we can change it> # directly from the class> CSStudent.stream>=> 'mech'> print>(a.stream)># prints 'ece'> print>(b.stream)># prints 'mech'> |
>
>Sortir
cse cse Geek Nerd 1 2 cse ece cse ece mech>
Sortir:
cse cse Geek Nerd 1 2 cse ece cse ece mech>
Exemple:
Python
class> MyClass:> >static_var>=> 0> >def> __init__(>self>):> >MyClass.static_var>+>=> 1> >self>.instance_var>=> MyClass.static_var> obj1>=> MyClass()> print>(obj1.instance_var)># Output: 1> obj2>=> MyClass()> print>(obj2.instance_var)># Output: 2> print>(MyClass.static_var)># Output: 2> |
>
>Sortir
1 2 2>
Explication:
dans cet exemple, nous définissons une classe MyClass qui a une variable statique static_var initialisée à 0. Nous définissons également une variable d'instance instance_var unique à chaque instance de la classe.
Lorsque nous créons une instance de la classe (obj1), nous incrémentons la valeur de la variable statique de 1 et l'attribuons à la variable d'instance. Lorsque nous créons une autre instance de la classe (obj2), nous incrémentons à nouveau la variable statique et attribuons la nouvelle valeur à la variable d'instance pour cette instance.
Enfin, nous imprimons la valeur de la variable statique en utilisant la classe elle-même, plutôt qu'une instance de la classe. Comme vous pouvez le constater, la valeur de la variable statique est partagée entre toutes les instances de la classe et elle est incrémentée à chaque fois qu'une nouvelle instance est créée.
Les variables statiques peuvent être utiles pour maintenir l'état sur toutes les instances d'une classe ou pour partager des données entre toutes les instances d'une classe. Cependant, il est important de les utiliser avec précaution et de s’assurer que leurs valeurs sont synchronisées avec l’état du programme, notamment dans un environnement multithread.
Avantages :
- Efficacité de la mémoire : étant donné que les variables statiques sont partagées entre toutes les instances d'une classe, elles peuvent économiser de la mémoire en évitant d'avoir à créer plusieurs copies des mêmes données. État partagé : les variables statiques peuvent fournir un moyen de maintenir un état partagé sur toutes les instances d'une classe, permettant à toutes les instances d'accéder et de modifier les mêmes données. Facile d'accès : les variables statiques sont accessibles en utilisant le nom de la classe lui-même, sans avoir besoin d'une instance de la classe. Cela peut rendre plus pratique l’accès et la modification des données stockées dans une variable statique. Initialisation : les variables statiques peuvent être initialisées lorsque la classe est définie, ce qui permet de garantir facilement que la variable a une valeur de départ valide. Lisibilité : les variables statiques peuvent améliorer la lisibilité du code, car elles indiquent clairement que les données stockées dans la variable sont partagées entre toutes les instances de la classe.
Désavantages:
- Inflexibilité : les variables statiques peuvent être inflexibles, car leurs valeurs sont partagées dans toutes les instances de la classe, ce qui rend difficile l'obtention de valeurs différentes pour différentes instances. Dépendances cachées : les variables statiques peuvent créer des dépendances cachées entre différentes parties du code, ce qui rend difficile la compréhension et la modification du code. Sécurité des threads : les variables statiques peuvent être problématiques dans un environnement multithread, car elles peuvent introduire des conditions de concurrence critique et des problèmes de synchronisation si elles ne sont pas correctement synchronisées. Pollution de l'espace de noms : des variables statiques peuvent s'ajouter à l'espace de noms de la classe, provoquant potentiellement des conflits de noms et rendant plus difficile la maintenance du code. Tests : les variables statiques peuvent rendre plus difficile l'écriture de tests unitaires efficaces, car l'état de la variable statique peut affecter le comportement de la classe et de ses méthodes.
Dans l'ensemble, les variables statiques peuvent être un outil utile dans la programmation Python, mais elles doivent être utilisées avec soin et attention aux inconvénients potentiels, tels que le manque de flexibilité, les dépendances cachées et les problèmes de sécurité des threads.