Curso
Programación orientada a objetos en Python
4 h
105.2K
Probablemente hayas oído hablar de las funciones anidadas en Python. Si sabes qué son, entender las clases internas/anidadas no tiene misterio. Aquí exploraremos algunos aspectos nuevos de las clases internas o anidadas.
1. Clases internas o anidadas
Una clase interna o anidada se define dentro de otra clase. Observa la estructura de las clases internas o anidadas.
## clase externa
class Outer:
## clase interna
class Inner:
pass
## clase interna multinivel
class InnerInner:
pass
## otra clase interna
class _Inner:
pass
## ...
passEjecuta y edita el código de este tutorial en línea
Ejecutar código2. ¿Por qué usar clases internas?
-
Agrupar dos o más clases. Supongamos que tienes dos clases: Car y Engine. Todo Car necesita un Engine. Pero un Engine no se usará sin un Car. Así que conviertes Engine en una clase interna de Car. Ayuda a simplificar el código.
-
Ocultar implementación es otro uso de las clases anidadas. Puedes ocultarlas del mundo exterior.
-
Facilitan la comprensión. Las clases están estrechamente relacionadas y no tienes que buscarlas por el código: están juntas.
Las clases internas o anidadas no son de las características más habituales en Python, pero pueden ser muy útiles. El código resulta muy sencillo de organizar cuando usas clases internas o anidadas.
3. Programar clases internas
Implementar clases internas o anidadas no es complicado. Puedes ver la estructura del código aquí.
Puedes acceder a la clase interna desde la clase externa usando la palabra clave self. Así, puedes crear rápidamente una instancia de la clase interna y operar con ella en la clase externa según necesites. Sin embargo, no puedes acceder a la clase externa desde una clase interna. Veamos un ejemplo:
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)
Ahora crea una instancia de la clase Outer y llama a su método reveal() para ejecutar el método inner_display() de la clase Inner.
## creating an instance of the 'Outer' class
outer = Outer()
## calling the 'reveal()' method
outer.reveal()
Calling Inner class function from Outer class
Veamos otra forma de acceder a la clase interna. Este enfoque es algo menos eficiente.
Outer().Inner().inner_display("Calling the Inner class method directly")
Calling the Inner class method directly
¿Y si quieres crear una instancia de la clase interna fuera de la clase externa? ¿Se puede? Sí. Mira cómo crear una instancia de la clase interna fuera de la externa:
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. Varias clases internas
Es una clase que contiene más de una clase interna. Puedes tener varias clases internas dentro de una clase. Como ya comentamos, es sencillo implementarlas.
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)
## ...
El acceso a las clases se hace igual que antes. Mira el ejemplo para entenderlo mejor.
## 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. Clases internas multinivel
En las clases internas multinivel, la clase interna contiene otra clase que a su vez es interna respecto a la anterior. Puedes ver la estructura de esta jerarquía aquí:
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)
## ...Veamos cómo instanciar la clase interna multinivel.
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!
Conclusión
Espero que ahora tengas claro el concepto de clases internas. Es hora de que experimentes con clases anidadas. ¡Feliz programación! :)
Si quieres profundizar en clases, echa un vistazo al tutorial de programación orientada a objetos (OOP) en Python de DataCamp.
haz el curso Object-Oriented Programming in Python de DataCamp.
Temas
