Corso
Programmazione orientata agli oggetti in Python
4 ore
105.4K
Probabilmente hai sentito parlare delle funzioni annidate in Python. Se sai cosa significa, allora capire le classi interne/annidate è un gioco da ragazzi. Qui esploreremo alcune novità sulle classi interne o annidate.
1. Classi interne o annidate
Una classe interna o annidata è definita all'interno di un'altra classe. Guarda la struttura delle classi interne o annidate.
## outer class
class Outer:
## inner class
class Inner:
pass
## multilevel inner class
class InnerInner:
pass
## another inner class
class _Inner:
pass
## ...
passEsegui e modifica il codice da questo tutorial online
Esegui codice2. Perché usare le classi interne?
-
Raggruppare due o più classi. Supponiamo che tu abbia due classi, Car ed Engine. Ogni Car ha bisogno di un Engine. Ma un Engine non verrà usato senza una Car. Quindi rendi Engine una classe interna di Car. Aiuta a risparmiare codice.
-
Nascondere il codice è un altro uso delle classi annidate. Puoi nascondere le classi annidate al mondo esterno.
-
Le classi sono più facili da comprendere. Qui le classi sono strettamente correlate. Non devi cercarle nel codice: sono tutte insieme.
Le classi interne o annidate non sono tra le funzionalità più comuni in Python. Ma possono essere una buona soluzione per implementare il codice. Quando usi le classi interne o annidate, il codice è semplice da organizzare.
3. Scrivere classi interne
Implementare le classi interne o annidate non è difficile. Puoi vedere la struttura del codice qui.
Puoi accedere alla classe interna nella classe esterna usando la parola chiave self. Così puoi creare rapidamente un'istanza della classe interna ed eseguire operazioni nella classe esterna come preferisci. Non puoi però accedere alla classe esterna da una classe interna. Vediamo un esempio qui sotto.
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)
Ora creerai l'istanza della classe Outer e chiamerai il suo metodo reveal() per eseguire il metodo inner_display() della classe Inner.
## creating an instance of the 'Outer' class
outer = Outer()
## calling the 'reveal()' method
outer.reveal()
Calling Inner class function from Outer class
Vediamo un altro modo per accedere alla classe interna. Questo modo è un po' meno efficiente.
Outer().Inner().inner_display("Calling the Inner class method directly")
Calling the Inner class method directly
E se volessi creare un'istanza della classe interna all'esterno della classe esterna? Puoi farlo? Sì, vediamo come creare un'istanza della classe interna al di fuori della classe esterna.
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. Più classi interne
È una classe che contiene più di una classe interna. Puoi avere più di una classe interna in una classe. Come abbiamo già definito, è facile implementare più classi interne.
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)
## ...
Accedere alle classi è lo stesso di quanto fatto in precedenza. Guarda l'esempio per capire meglio.
## 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. Classi interne multilivello
Nelle classi interne multilivello, la classe interna contiene un'altra classe che è interna alla precedente. Puoi vedere la struttura di questa gerarchia qui:
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)
## ...Vediamo come istanziare la classe interna multilivello.
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!
Conclusione
Spero che ora tu abbia capito il concetto di classi interne. È il momento di sperimentare con le classi annidate. Buon coding :)
Se vuoi saperne di più sulle classi, dai un'occhiata al tutorial di DataCamp Python Object-Oriented Programming (OOP): Tutorial.
segui il corso di DataCamp Object-Oriented Programming in Python.
Argomenti
