Qu'est-ce que __init__ en Python ? [Avec exemples]

Vous cherchez à vous lancer dans la conception orientée objet en Python ? Faites les premiers pas dès aujourd'hui en découvrant la méthode __init__ de Python.

Dans ce didacticiel, nous allons passer en revue les bases des classes et des objets Python, puis continuer à en apprendre davantage sur le __init__ méthode.

À la fin de ce didacticiel, vous serez en mesure de répondre aux questions suivantes :

• Que sont les variables d'instance ou les attributs d'instance ?
• Comment la méthode init aide-t-elle à initialiser les attributs d'instance ?
• Comment pouvons-nous définir des valeurs par défaut pour les attributs ?
• Comment pouvons-nous utiliser des méthodes de classe comme constructeurs pour créer des objets ?

Commençons.

Python Classes and Objects

Les classes sont fondamentales pour la programmation orientée objet en Python. Nous pouvons créer une classe et définir attributs , méthodes- se lier ensemble données et associé .

Une fois que nous avons créé une classe, nous pouvons l'utiliser comme modèle (ou modèle) pour créer des objets (instances).

👩‍🏫Temps d'exemple ! Créons un Employee classe où chaque objet de cette classe a les attributs suivants :

• full_name: le nom complet de l'employé dans le firstName lastName le format
• emp_id: l'identifiant de l'employé
• department: le département auquel ils appartiennent
• experience: le nombre d'années d'expérience qu'ils ont

Qu'est-ce que cela signifie? 🤔

Chaque employé individuel sera une instance ou un objet de la Employee classe. Et chaque objet aura sa propre valeur pour le full_name, emp_id, departmentet au experience.

Ces attributs sont également appelés variables d'instance, et nous utiliserons indifféremment les termes attributs et variables d'instance.

Nous reviendrons sur l'ajout d'attributs dans un instant. Pour l'instant, nous créons un Employee classe comme ça:

class Employee:
    pass

En utilisant pass (en tant qu'espace réservé) nous aide à éviter les erreurs lorsque nous exécutons le script.

Bien que la version actuelle du Employee la classe n'est pas très utile, c'est quand même un Info de contact. classe. Ainsi, nous pouvons créer des objets de la Employee classe:

employee_1 = Employee()

print(employee_1)
#Output: <__main__.Employee object at 0x00FEE7F0>

Nous pouvons également ajouter des attributs et les initialiser avec des valeurs comme indiqué :

employee_1.full_name = 'Amy Bell'
employee_1.department = 'HR'

Mais cette approche d'ajout d'attributs d'instance est à la fois inefficace et sujette aux erreurs. De plus, cela ne permet pas l'utilisation de la classe comme modèle pour créer des objets. Voici où le __init__ méthode aide.

Understanding the Role of __init__ Method in a Python Class

Nous devrions pouvoir initialiser les variables d'instance lors de l'instanciation d'un objet et le __init__ méthode nous aide à le faire. Le __init__ La méthode est appelée chaque fois qu'un nouvel objet de la classe est créé pour initialiser les valeurs des variables d'instance.

Si vous avez programmé dans un langage comme C++, vous verrez que le __init__  La méthode fonctionne de la même manière que les constructeurs.

Définition de la méthode __init__

Ajoutons le __init__ méthode à la Employee classe:

class Employee:
    def __init__(self, full_name,emp_id,department,experience):
        self.full_name = full_name
        self.emp_id = emp_id
        self.department = department
        self.experience = experience

Les self paramètre fait référence à l'instance de la classe, et le self.attribute initialise l'instance attribute à la valeur sur le côté droit.

Nous pouvons maintenant créer des objets comme ceci :

employee_2 = Employee('Bella Joy','M007','Marketing',3)
print(employee_2)
# Output: <__main__.Employee object at 0x017F88B0>

Lorsque nous imprimons les objets employés, nous n'obtenons aucune information utile, à l'exception de la classe à laquelle ils appartiennent. Ajoutons un __repr__ méthode qui définit une chaîne de représentation pour la classe :

 def __repr__(self):
        return f"{self.full_name},{self.emp_id} from {self.department} with {self.experience} years of experience."

Ajout du __repr__ à la Employee classe, nous avons :

class Employee:
    def __init__(self, full_name,emp_id,department,experience):
        self.full_name = full_name
        self.emp_id = emp_id
        self.department = department
        self.experience = experience
    
     def __repr__(self):
        return f"{self.full_name},{self.emp_id} from {self.department} with {self.experience} years of experience."

Désormais, les objets employés ont une chaîne de représentation utile :

print(employee_2)
# Output: Bella Joy,M007 from Marketing with 3 years of experience.

Quelques Conventions

Avant d'aller plus loin, voici quelques remarques :

• Nous avons utilisé self comme premier paramètre dans __init__ méthode pour faire référence à l'instance de classe elle-même et utilisée self.attribute_name pour initialiser les différents attributs. En utilisant self est la convention préférée (vous pouvez cependant utiliser n'importe quel autre nom).
• Lors de la définition du __init__ méthode, nous définissons les noms des paramètres dans la __init__ définitions pour correspondre aux noms des attributs. Cela améliore la lisibilité.

How to Add Default Values for Attributes

Dans l'exemple que nous avons codé jusqu'ici, tous les attributs sont conditions. Cela signifie que la création d'un objet ne réussit que si nous transmettons les valeurs de tous les champs au constructeur.

Essayez d'instancier un objet de la classe Employee sans passer la valeur de l'attribut experience :

employee_3 = Employee('Jake Lee','E001','Engineering')

Vous obtiendrez l'erreur suivante :

Traceback (most recent call last):
  File "main.py", line 22, in <module>
    employee_3 = Employee('Jake Lee','E001','Engineering')
TypeError: __init__() missing 1 required positional argument: 'experience'

Mais si vous voulez rendre certains attributs optionnel, vous pouvez le faire en fournissant des valeurs par défaut pour ces attributs lors de la définition du __init__ méthode.

Ici, nous fournissons une valeur par défaut de 0 pour le experience attribut:

class Employee:
    def __init__(self, full_name,emp_id,department,experience=0):
        self.full_name = full_name
        self.emp_id = emp_id
        self.department = department
        self.experience = experience
    
     def __repr__(self):
        return f"{self.full_name},{self.emp_id} from {self.department} with {self.experience} years of experience."

Les employee_3 objet est créé sans valeur pour le experience attribut; la valeur par défaut de 0 est utilisée pour experience.

employee_3 = Employee('Jake Lee','E001','Engineering')
print(employee_3.experience)
# Output: 0

Alternative Class Constructors Using Class Methods

Jusqu'à présent, nous avons seulement vu comment définir le __init__ méthode et définissez des valeurs par défaut pour les attributs si nécessaire. Nous savons également que nous devons transmettre les valeurs de conditions attributs dans le constructeur.

Parfois, cependant, les valeurs de ces variables d'instance (ou attributs) peuvent être disponibles dans une structure de données différente, comme un tuple, un dictionnaire ou une chaîne JSON.

Alors, que faisons-nous?

Prenons un exemple. Supposons que nous ayons les valeurs de la variable d'instance dans un dictionnaire Python :

dict_fanny = {'name':'Fanny Walker','id':'H203','dept':'HR','exp':2}

Nous pouvons puiser dans le dictionnaire et obtenir tous les attributs comme ceci :

name = dict_fanny['name']
id = dict_fanny['id']
dept = dict_fanny['dept']
exp = dict_fanny['exp']

Après cela, vous pouvez créer un objet en transmettant ces valeurs au constructeur de classe :

employee_4 = Employee(name, id, dept, exp)
print(employee_4)
# Output: Fanny Walker,H203 from HR with 2 years of experience.

N'oubliez pas : vous devez le faire pour chaque nouvel objet que vous créez. Cette approche est inefficace et nous pouvons certainement faire mieux. Mais comment?

En Python, nous pouvons utiliser méthodes de classe as constructeurs pour créer des objets de la classe. Pour créer une méthode de classe, nous utilisons la @classmethod décorateur.

Définissons une méthode qui analyse le dictionnaire, obtient les valeurs des variables d'instance et les utilise pour construire Employee objets.

    @classmethod
    def from_dict(cls,data_dict):
        full_name = data_dict['name']
        emp_id = data_dict['id']
        department = data_dict['dept']
        experience = data_dict['exp']
        return cls(full_name, emp_id, department, experience)

Lorsque nous devons créer des objets à l'aide des données du dictionnaire, nous pouvons utiliser le from_dict() méthode de classe.

💡 Remarquez l'utilisation de cls dans la méthode de classe au lieu de self. Juste la façon dont nous utilisons self pour nous référer à l'instance, cls est utilisé pour désigner la classe. De plus, les méthodes de classe sont liées à la classe et non aux objets.

Ainsi, lorsque nous appelons la méthode de classe from_dict() pour créer des objets, on l'appelle sur le Employee classe:

emp_dict = {'name':'Tia Bell','id':'S270','dept':'Sales','exp':3}
employee_5 = Employee.from_dict(emp_dict)
print(employee_5)
# Output: Tia Bell,S270 from Sales with 3 years of experience.

Maintenant, si nous avons un dictionnaire pour chacun des n employés, nous pouvons utiliser le from_dict() méthode de classe en tant que constructeur à instancier dans des objets, sans avoir à récupérer les valeurs de variables instantanées à partir du dictionnaire.

????Remarque sur les variables de classe

Ici, nous avons défini la méthode de classe qui est liée à la classe et non aux instances individuelles. Comme pour les méthodes de classe, nous pouvons également avoir des variables de classe.

Comme les méthodes de classe, variables de classe sont liés à la classe et non à une instance. Lorsqu'un attribut prend une valeur fixe pour toutes les instances de la classe, on peut envisager de les définir comme des variables de classe.

FAQs

Conclusion

Dans ce tutoriel, nous avons appris à utiliser le __init__ méthode pour initialiser les valeurs des variables d'instance. Bien que cela soit simple, cela peut être répétitif, surtout lorsque vous avez beaucoup d'attributs. 

Si vous êtes intéressé, vous pouvez explorer le module de classes de données. Dans Python 3.7 et versions ultérieures, vous pouvez utiliser le module de classes de données intégré pour créer des classes de données qui stockent des données. En plus des implémentations par défaut du  __init__ et d'autres méthodes couramment utilisées ; ils sont livrés avec de nombreuses fonctionnalités intéressantes pour les conseils de type, les valeurs par défaut complexes et l'optimisation.

Ensuite, apprenez-en plus sur si __name__=='__main__' en Python.