Qu'est-ce que __init__ en Python ?

Lors de la lecture du code Python d'autres personnes, de nombreux débutants sont intrigués par le __init__(self) méthode. Quel est son but ? Cet article répond à cette question une fois pour toutes.

Quel est le but de __init__(self) ? en Python ?

La méthode Python réservée __init__() est appelé le constructeur d'une classe. Vous pouvez appeler la méthode constructeur pour créer un objet (=instance) à partir d'une classe et initialiser ses attributs.

Bien que cela réponde à la question, si vous avez la moindre ambition de devenir un codeur Python professionnel, il ne suffit pas de savoir que le __init__ method est le constructeur d'une classe. Vous devez également savoir comment utiliser le constructeur dans vos propres projets et comment personnaliser ses arguments. Une compréhension approfondie du constructeur constitue une base solide pour des concepts plus avancés de programmation Python orientée objet. Lisez la suite pour découvrir l'autre moitié de l'équation.

Exemple interactif :Avant que je ne vous l'explique, ouvrons votre écart de connaissances. Prenons l'exemple suivant :

Exercice :Ajouter une couleur d'argument au __init__ et faites exécuter le code sans erreur !

Plongeons dans cet exemple simple en détail.

Comment utiliser la méthode __init__ en pratique ? Un exemple simple

Nous utiliserons quelques termes de programmation orientée objet en Python pour expliquer notre exemple. Assurez-vous d'étudier la feuille de triche suivante (vous pouvez également télécharger le PDF ici). Cliquez sur l'image pour obtenir la feuille de triche (s'ouvre dans un nouvel onglet). Si vous êtes déjà à l'aise avec les terminologies de base orientées objet comme les classes et les instances, lisez simplement la suite.

Vous avez appris que le __init__ method est la méthode constructeur d'une classe. Vous appelez la méthode constructeur pour créer de nouvelles instances (ou objets ). Mais comment cela se passe-t-il exactement dans la pratique ? Avant de plonger dans l'utilisation correcte, nous devons comprendre les arguments (ou paramètres ) de la méthode constructeur.

L'argument de soi

Le __init__ constructeur nécessite au moins un argument. Selon la norme PEP8, il est recommandé de désigner cet argument par self . Dans tous les cas, le self L'argument pointe vers l'instance nouvellement créée elle-même et vous permet de manipuler les attributs d'instance de la nouvelle instance. Dans l'exemple du chien, vous utiliseriez self.color = "blue" pour définir le color du chien nouvellement créé attribut à la chaîne "blue" .

Examinons l'exemple de code de base suivant :

class Dog:

    def __init__(self):
        self.color = "blue"


bello = Dog()
print(bello.color)
# blue

1. Nous créons une nouvelle classe Dog avec le constructeur __init__(self) .
2. Nous créons une nouvelle instance de la classe Dog nommé bello . Il y a deux observations intéressantes :premièrement, nous utilisons le nom de la classe plutôt que le nom du constructeur pour créer la nouvelle instance. Python appelle en interne la méthode __init__ pour nous. Deuxièmement, nous ne transmettons aucun argument lors de l'appel de Dog() . Encore une fois, Python passe implicitement une référence à l'instance nouvellement créée (bello ) au constructeur __init__ .
3. Nous imprimons l'attribut de couleur du nouveau bello exemple. Le résultat est la valeur de chaîne "blue" comme défini dans le constructeur.

Cependant, cet exemple minimal est irréaliste. Certains chiens sont bruns, d'autres sont noirs et seuls certains sont bleus.

Plusieurs arguments de constructeur

Alors, comment pouvons-nous créer des chiens différents avec des couleurs différentes ? Nous pouvons facilement y parvenir en utilisant plus d'arguments, en plus de self , lors de la définition de notre constructeur __init__ . Voici un autre exemple où nous créons deux chiens avec des couleurs différentes. Pouvez-vous repérer leurs couleurs ?

class Dog:

    def __init__(self, color):
        self.color = color
        

bello = Dog("blue")
print(bello.color)
# blue

alice = Dog("brown")
print(alice.color)
# brown

Contrairement au premier exemple, nous définissons maintenant le constructeur __init__(self, color) avec deux arguments au lieu d'un.

Le premier est le self argumentation comme précédemment. Le second est un argument personnalisé color qui est transmis par l'appelant du constructeur. Dans notre cas, nous créons deux instances Dog, bello et alice , en précisant le color argument pour les deux.

Notez que le self est géré implicitement par l'environnement de programmation Python :Python passe simplement une référence au Dog respectif instance au __init__ constructeur.

Quelle est la différence entre le constructeur et l'initialiseur ?

Eh bien, je n'ai pas utilisé une terminologie très précise dans les paragraphes précédents. J'ai utilisé le terme "constructeur" à la fois pour l'appel Dog() et l'appel __init__() . Mais seul le premier appel peut être désigné comme méthode constructeur car seul cet appel crée réellement une nouvelle instance. A l'époque, on appelle la méthode __init__ , l'instance a déjà été créée (Python nous la passe via le self dispute). C'est pourquoi un terme plus précis pour le __init__ la méthode est la méthode d'initialisation . C'est ainsi que je le noterai dans la suite pour compenser. 😉

Quelle est la signification des traits de soulignement dans le nom de la méthode __init__ ?

J'ai écrit un article entier sur la signification du trait de soulignement en Python. Vérifiez-le si ce sujet vous intéresse davantage. La clé à retenir, cependant, est la suivante :

Le double trait de soulignement "__" (appelé "dunder" ) est utilisé pour rendre un attribut ou une méthode d'instance privé (inaccessible depuis l'extérieur de la classe) - lorsqu'il est utilisé comme premier dunder. Lorsqu'il est utilisé comme dunder englobant (par exemple "__init__"), il indique qu'il s'agit d'une méthode spéciale en Python (appelée "méthode magique").

Comment utiliser __init__ dans une classe héritée ?

Une classe héritée est une classe qui hérite de tous les attributs et méthodes d'une classe parent. Voici un exemple :

class Dog:
    def __init__(self, color):
        self.color = color
        

class CuteDog(Dog):
    def __init__(self, color):
        Dog.__init__(self, color)
        self.hairs = True


bello = CuteDog('brown')
print(bello.hairs)
# True

print(bello.color)
# brown

L'héritage est très important en Python. Dans l'exemple, la classe parent est la classe Chien que vous connaissez déjà ci-dessus. La méthode d'initialisation __init__ définit la couleur de ce chien.

Maintenant, nous créons également une nouvelle classe CuteDog qui hérite de tous les attributs de la classe parente Dog . Vous pouvez définir l'héritage en spécifiant le nom de la classe parent entre parenthèses après la classe enfant :CuteDog(Dog) .

La chose intéressante est que la méthode __init__ de la classe enfant CuteDog appelle la méthode __init__ de la classe parent. Cela a du sens car la classe enfant a les mêmes attributs que la classe parent et ils doivent également être initialisés.

La manière la plus Pythonic, cependant, est d'utiliser le super() fonction qui vous facilite l'accès à la classe parent :

class Dog:
    def __init__(self, color):
        self.color = color
        

class CuteDog(Dog):
    def __init__(self, color):
        super().__init__(color)
        self.hairs = True


bello = CuteDog('brown')
print(bello.hairs)
# True

print(bello.color)
# brown

Avec l'aide du super() fonction, vous pouvez facilement réutiliser la méthode d'initialisation de la classe parent.

Examinons quelques questions connexes.

Est-ce que __ init __ est nécessaire en Python ?

Non. Vous pouvez simplement ignorer la méthode d'initialisation. Par conséquent, votre classe n'aura aucun attribut d'instance directement après sa création. Cependant, vous pouvez ajouter dynamiquement des attributs d'instance à tout moment ultérieur. Voici un exemple :

class Dog:
    None
        

bello = Dog()
bello.color = "blue"
print(bello.color)
# blue

Que c'est beau! Vous pouvez même créer des classes vides et "remplir" les méthodes et les attributs plus tard dans Python.

Que renvoie __ init __ ?

Le __init__ méthode elle-même ne renvoie rien. Techniquement, Python utilise d'abord la méthode constructeur Dog() avant d'utiliser __init__ pour initialiser tous les attributs. Par conséquent, seul le constructeur renvoie l'instance nouvellement créée.

Est-ce que __init__ peut renvoyer une valeur ?

Non. La seule valeur de retour qui ne provoque pas d'erreur d'exécution est None . Toutes les autres valeurs de retour provoquent une erreur. Voir l'exemple de code suivant :

class Dog:

    def __init__(self, color):
        self.color = color
        return 0
        

bello = Dog("blue")
# TypeError: __init__() should return None, not 'int'

Donc, n'utilisez jamais de valeur de retour dans la méthode __init__ et vous êtes prêt à partir.

Où aller à partir d'ici ?

Merci d'avoir lu tout l'article. Vous avez appris que le __init__ name est réservé à la méthode d'initialisation Python appelée dans le constructeur.

L'article nécessite une compréhension approfondie des bases de Python. Investir du temps pour les apprendre et les étudier est vital pour votre succès en tant que codeur professionnel.

Pour aider les gens à développer leurs compétences de manière automatisée et personnalisée, j'ai créé un cours gratuit par e-mail Python "Coffee Break Python" qui augmente votre niveau de compétence de manière transparente. Jour après jour après jour…

Rejoignez des dizaines de milliers de codeurs Python (100 % gratuits) !