TOC

Compréhension des variables de classe et d’instance dans Python 3

introduction

Object-oriented programming permet d'utiliservariables au niveau de la classe ou au niveau de l'instance. LesVariables sont essentiellement des symboles qui représentent une valeur que vous utilisez dans un programme.

Au niveau de la classe, les variables sont appeléesclass variables, tandis que les variables au niveau de l'instance sont appeléesinstance variables.

Lorsque nous nous attendons à ce que les variables soient cohérentes d'une instance à l'autre ou lorsque nous souhaitons initialiser une variable, nous pouvons définir cette variable au niveau de la classe. Lorsque nous prévoyons que les variables changeront de manière significative d’une instance à l’autre, nous pouvons les définir au niveau de chaque instance.

L'un des principes du développement logiciel est le principeDRY, qui signifiedon’t repeat yourself. Ce principe vise à limiter la répétition dans le code, et la programmation orientée objet adhère au principe DRY car elle réduit la redondance.

Ce tutoriel présentera l'utilisation de variables de classe et d'instance dans la programmation orientée objet dans Python.

Variables de classe

Les variables de classe sont définies dans lesclass construction. Comme elles appartiennent à la classe elle-même, les variables de classe sont partagées par toutes les instances de la classe. Ils auront donc généralement la même valeur pour chaque instance, sauf si vous utilisez la variable de classe pour initialiser une variable.

Définies en dehors de toutes les méthodes, les variables de classe sont, par convention, généralement placées juste en dessous de l'en-tête de classe et avant lesconstructor method et les autres méthodes.

Une seule variable de classe ressemble à ceci: 

class Shark:
    animal_type = "fish"

Ici, la variableanimal_type reçoit la valeur"fish".

Nous pouvons créer une instance de la classeShark (nous l'appelleronsnew_shark) et imprimer la variable en utilisant la notation par points:

shark.py

class Shark:
    animal_type = "fish"

new_shark = Shark()
print(new_shark.animal_type)

Lançons le programme: 

python shark.py
Outputfish

Notre programme renvoie la valeur de la variable.

Ajoutons encore quelques variables de classe et imprimons-les:

shark.py

class Shark:
    animal_type = "fish"
    location = "ocean"
    followers = 5

new_shark = Shark()
print(new_shark.animal_type)
print(new_shark.location)
print(new_shark.followers)

Comme pour toute autre variable, les variables de classe peuvent être constituées de n'importe queldata type disponible en Python. Dans ce programme, nous avons des chaînes et un entier. Exécutons à nouveau le programme avec la commandepython shark.py et voyons le résultat: 

Outputfish
ocean
5

L'instance denew_shark est capable d'accéder à toutes les variables de classe et de les imprimer lorsque nous exécutons le programme.

Les variables de classe nous permettent de définir des variables lors de la construction de la classe. Ces variables et leurs valeurs associées sont alors accessibles à chaque instance de la classe.

Variables d'instance

Les variables d'instance appartiennent aux instances de la classe. Cela signifie que pour chaque objet ou instance d'une classe, les variables d'instance sont différentes.

Contrairement aux variables de classe, les variables d'instance sont définies dans les méthodes.

Dans l'exemple de classeShark ci-dessous,name etage sont des variables d'instance: 

class Shark:
    def __init__(self, name, age):
        self.name = name
        self.age = age

Lorsque nous créons un objetShark, nous devrons définir ces variables, qui sont passées en paramètres dans la méthode constructeur ou dans une autre méthode. 

class Shark:
    def __init__(self, name, age):
        self.name = name
        self.age = age

new_shark = Shark("Sammy", 5)

Comme pour les variables de classe, nous pouvons également appeler pour imprimer des variables d'instance:

shark.py

class Shark:
    def __init__(self, name, age):
        self.name = name
        self.age = age

new_shark = Shark("Sammy", 5)
print(new_shark.name)
print(new_shark.age)

Lorsque nous exécutons le programme ci-dessus avecpython shark.py, nous recevrons le résultat suivant: 

OutputSammy
5

La sortie que nous recevons est constituée des valeurs des variables que nous avons initialisées pour l'instance d'objet denew_shark.

Créons un autre objet de la classeShark appeléstevie:

shark.py

class Shark:
    def __init__(self, name, age):
        self.name = name
        self.age = age

new_shark = Shark("Sammy", 5)
print(new_shark.name)
print(new_shark.age)

stevie = Shark("Stevie", 8)
print(stevie.name)
print(stevie.age)

L'objetstevie, comme l'objetnew_shark, transmet les paramètres spécifiques à cette instance de la classeShark pour affecter des valeurs aux variables d'instance.

Les variables d'instance, appartenant aux objets de la classe, permettent à chaque objet ou instance d'avoir différentes valeurs attribuées à ces variables.

Utilisation simultanée de variables de classe et d'instance

Les variables de classe et les variables d'instance seront souvent utilisées en même temps, alors regardons un exemple de cela en utilisant la classeShark que nous avons créée. Les commentaires dans le programme décrivent chaque étape du processus.

shark.py

class Shark:

    # Class variables
    animal_type = "fish"
    location = "ocean"

    # Constructor method with instance variables name and age
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # Method with instance variable followers
    def set_followers(self, followers):
        print("This user has " + str(followers) + " followers")


def main():
    # First object, set up instance variables of constructor method
    sammy = Shark("Sammy", 5)

    # Print out instance variable name
    print(sammy.name)

    # Print out class variable location
    print(sammy.location)

    # Second object
    stevie = Shark("Stevie", 8)

    # Print out instance variable name
    print(stevie.name)

    # Use set_followers method and pass followers instance variable
    stevie.set_followers(77)

    # Print out class variable animal_type
    print(stevie.animal_type)

if __name__ == "__main__":
    main()

Lorsque nous exécutons le programme avecpython shark.py, nous recevrons le résultat suivant: 

OutputSammy
ocean
Stevie
This user has 77 followers
fish

Ici, nous avons utilisé à la fois des variables de classe et d'instance dans deux objets de la classeShark,sammy etstevie.

Conclusion

Dans la programmation orientée objet, les variables au niveau de la classe sont appelées variables de classe, tandis que les variables au niveau de l'objet sont appelées variables d'instance.

Cette différenciation nous permet d'utiliser des variables de classe pour initialiser des objets avec une valeur spécifique assignée à des variables et d'utiliser des variables différentes pour chaque objet avec des variables d'instance.

L'utilisation de variables spécifiques à une classe et à une instance peut garantir que notre code adhère au principe DRY afin de réduire la répétition dans le code.

Related