Classes internes en Python

2. Pourquoi utiliser des classes internes ?

1. Regrouper deux classes ou plus. Supposons que vous ayez deux classes, Car et Engine. Chaque Car a besoin d’un Engine. Mais un Engine n’a pas vocation à être utilisé sans Car. Vous pouvez donc faire de Engine une classe interne de Car. Cela permet d’alléger le code.

2. Masquer du code est un autre usage des classes imbriquées. Vous pouvez cacher les classes imbriquées au monde extérieur.

3. Les classes sont plus faciles à appréhender. Elles sont étroitement liées ici. Plus besoin de chercher partout dans le code : elles sont regroupées.

Les classes internes ou imbriquées ne sont pas la fonctionnalité la plus courante en Python. Mais elles peuvent être très utiles pour structurer votre code. Avec des classes internes ou imbriquées, organiser le code devient très simple.

3. Coder des classes internes

Mettre en place des classes internes ou imbriquées n’a rien de compliqué. Vous pouvez en voir la structure ici.

Vous pouvez accéder à la classe interne depuis la classe englobante à l’aide du mot-clé self. Vous créez ainsi facilement une instance de la classe interne et lancez des opérations dans la classe englobante selon vos besoins. En revanche, vous ne pouvez pas accéder à la classe englobante depuis une classe interne. Voyons un exemple.

class Outer:
    """Outer Class"""

    def __init__(self):
        ## instantiating the 'Inner' class
        self.inner = self.Inner()

    def reveal(self):
        ## calling the 'Inner' class function display
        self.inner.inner_display("Calling Inner class function from Outer class")

    class Inner:
        """Inner Class"""

        def inner_display(self, msg):
            print(msg)

Vous allez maintenant instancier la classe Outer et appeler sa méthode reveal() pour exécuter la méthode inner_display() de la classe Inner.

## creating an instance of the 'Outer' class
outer = Outer()
## calling the 'reveal()' method
outer.reveal()

Calling Inner class function from Outer class

Voyons une autre manière d’accéder à la classe interne. Elle est un peu moins efficace.

Outer().Inner().inner_display("Calling the Inner class method directly")

Calling the Inner class method directly

Et si vous vouliez créer une instance de la classe interne en dehors de la classe englobante ? Est-ce possible ? Oui. Voici comment instancier la classe interne en dehors de la classe englobante.

outer = Outer()

## instantiating the inner class
inner = outer.Inner() ## inner = Outer().Inner() or inner = outer.inner
inner.inner_display("Just Print It!")

Just Print It!

3.1. Classes internes multiples

Il s’agit d’une classe qui contient plus d’une classe interne. Vous pouvez en avoir plusieurs dans une même classe. Comme indiqué plus haut, les implémenter est simple.

class Outer:
    """Outer Class"""

    def __init__(self):
        ## Instantiating the 'Inner' class
        self.inner = self.Inner()
        ## Instantiating the '_Inner' class
        self._inner = self._Inner()

    def show_classes(self):
        print("This is Outer class")
        print(inner)
        print(_inner)

    class Inner:
        """First Inner Class"""

        def inner_display(self, msg):
            print("This is Inner class")
            print(msg)

    class _Inner:
        """Second Inner Class"""

        def inner_display(self, msg):
            print("This is _Inner class")
            print(msg)

    ## ...

L’accès aux classes se fait comme précédemment. Voici un exemple pour mieux visualiser.

## instantiating the classes

## 'Outer' class
outer = Outer()
## 'Inner' class
inner = outer.Inner() ## inner = outer.inner or inner = Outer().Inner()
## '_Inner' class
_inner = outer._Inner() ## _inner = outer._outer or _inner = Outer()._Inner()

## calling the methods
outer.show_classes()

print()

## 'Inner' class
inner.inner_display("Just Print It!")

print()

## '_Inner' class
_inner.inner_display("Just Show It!")

This is Outer class
<__main__.Outer.Inner object at 0x0000021B37962048>
<__main__.Outer._Inner object at 0x0000021B37962160>

This is Inner class
Just Print It!

This is _Inner class
Just Show It!

3.2. Classes internes à plusieurs niveaux

Dans les classes internes à plusieurs niveaux, la classe interne contient une autre classe, elle-même interne à la précédente. Vous pouvez voir la structure de cette hiérarchie ici :

class Outer:
    """Outer Class"""

    def __init__(self):
        ## instantiating the 'Inner' class
        self.inner = self.Inner()
        ## instantiating the multilevel 'InnerInner' class
        self.innerinner = self.inner.InnerInner()

    def show_classes(self):
        print("This is Outer class")
        print(inner)

    ## inner class
    class Inner:
        """First Inner Class"""

        def __init__(self):
            ## instantiating the 'InnerInner' class
            self.innerinner = self.InnerInner()

        def show_classes(self):
            print("This is Inner class")
            print(self.innerinner)

        ## multilevel inner class
        class InnerInner:

            def inner_display(self, msg):
                print("This is multilevel InnerInner class")
                print(msg)

        def inner_display(self, msg):
            print("This is Inner class")
            print(msg)

    ## ...

Voyons comment instancier une classe interne à plusieurs niveaux.

outer = Outer()

inner = outer.Inner()

## this is 'InnerInner' class instance
innerinner = inner.InnerInner() ## innerinner = Outer().Inner().InnerInner()

## let's call its method inner_display
innerinner.inner_display("Just Print It!")

This is multilevel InnerInner class
Just Print It!

Conclusion

Vous comprenez désormais le concept des classes internes. À vous d’expérimenter avec les classes imbriquées. Bon code !

Pour aller plus loin sur les classes, consultez le tutoriel de DataCamp : Python Object-Oriented Programming (OOP): Tutorial.

suivez le cours de DataCamp : Object-Oriented Programming in Python.