Innerlijke classes in Python

2. Waarom innerlijke classes?

1. Groeperen van twee of meer classes. Stel, je hebt twee classes: Car en Engine. Elke Car heeft een Engine nodig. Maar een Engine wordt niet gebruikt zonder een Car. Dus maak je de Engine een innerlijke class van de Car. Dat helpt code te besparen.

2. Code verbergen is een andere toepassing van geneste classes. Je kunt de geneste classes verbergen voor de buitenwereld.

3. Het is eenvoudiger om de classes te begrijpen. De classes hangen hier nauw samen. Je hoeft niet in de code te zoeken naar de classes. Ze staan bij elkaar.

Innerlijke of geneste classes zijn niet de meest gebruikte feature in Python. Maar het kan een handige feature zijn om code mee te implementeren. De code is makkelijk te organiseren wanneer je innerlijke of geneste classes gebruikt.

3. Innerlijke classes coderen

Het implementeren van innerlijke of geneste classes is niet moeilijk. Je kunt de structuur van de code hier zien.

Je kunt de innerlijke class in de outer class benaderen met het keyword self. Zo kun je snel een instantie van de innerlijke class maken en in de outer class doen wat nodig is. Je kunt echter niet vanuit een innerlijke class de outer class benaderen. Laten we hieronder een voorbeeld bekijken.

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)
Mogelijk gemaakt door

Nu maak je een instantie van de Outer-class en roep je de methode reveal() aan om de methode inner_display() van de Inner-class uit te voeren.

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

Calling Inner class function from Outer class
Mogelijk gemaakt door

Laten we een andere manier bekijken om de inner-class te benaderen. Deze manier is iets minder efficiënt.

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

Calling the Inner class method directly
Mogelijk gemaakt door

Wat als je een instantie van de inner-class buiten de outer-class wilt maken? Kan dat? Ja, laten we zien hoe je een instantie van de inner-class buiten de outer-class maakt.

outer = Outer()

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

Just Print It!Mogelijk gemaakt door

3.1. Meerdere innerlijke classes

Dit is een class met meer dan één innerlijke class. Je kunt meer dan één innerlijke class in een class hebben. Zoals we eerder aangaven, is het eenvoudig om meerdere innerlijke classes te implementeren.

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)

    ## ...
Mogelijk gemaakt door

Het benaderen van de classes gaat hetzelfde als eerder. Zie het voorbeeld voor beter begrip.

## 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!")
Mogelijk gemaakt door

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!Mogelijk gemaakt door

3.2. Innerlijke classes op meerdere niveaus

Bij innerlijke classes op meerdere niveaus bevat de inner-class een andere class die weer inner is ten opzichte van de vorige. Je kunt de structuur van deze hiërarchie hier zien:

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)

    ## ...Mogelijk gemaakt door

Laten we bekijken hoe je de innerlijke class op meerdere niveaus instantieert.

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!")
Mogelijk gemaakt door

This is multilevel InnerInner class
Just Print It!
Mogelijk gemaakt door

Conclusie

Ik hoop dat je het concept van inner-classes nu begrijpt. Het is nu tijd om te experimenteren met geneste classes. Veel codeerplezier :)

Wil je meer leren over classes? Bekijk dan DataCamp's Python Object-Oriented Programming (OOP): Tutorial.

volg de cursus Object-Oriented Programming in Python van DataCamp.