Encapsulación en Python: Guía completa

La encapsulación es un principio fundamental de la orientación a objetos en Python. Protege tus clases de cambios o eliminaciones accidentales y favorece la reutilización y mantenimiento del código. Considera esta sencilla definición de clase:

class Smartphone:
   def __init__(self, brand, os):
       self.brand = brand
       self.os = os

iphone = Smartphone("Apple", "iOS 17")

Muchos programadores de Python definen clases como ésta. Sin embargo, está lejos de las mejores prácticas que siguen los Pythonistas profesionales. El problema de esta clase se hace evidente cuando intentas modificar sus datos:

iphone.os = "Android"
print(iphone.os)

Android

Imagínate un iPhone funcionando con Android, ¡qué barbaridad! Evidentemente, tenemos que establecer algunos límites dentro de nuestra clase para que los usuarios no puedan cambiar sus atributos a lo que quieran.

Si deciden cambiarlas, los cambios deben ser bajo nuestras condiciones, siguiendo nuestras normas. Pero seguimos queriendo que los atributos .os o .brand sigan siendo los mismos en la superficie.

Todas estas cosas pueden promoverse utilizando la encapsulación y en este tutorial aprenderemos todo sobre ella. ¡Empecemos!

¿Cómo se consigue la encapsulación en Python?

Python apoya la encapsulación mediante convenciones y prácticas de programación, en lugar de modificadores de acceso forzados. Verás, el principio fundamental que subyace en gran parte del diseño del código Python es "Aquí todos somos adultos". Sólo podemos implementar la encapsulación como una mera convención y esperar que otros desarrolladores de Python confíen en nuestro código y lo respeten.

En otros lenguajes de programación orientada a objetos, como Java y C++, la encapsulación se aplica estrictamente con modificadores de acceso como public, private o protected, pero Python no los tiene:

Así pues, la mayoría, si no todas, las técnicas de encapsulación que voy a mostrarte son convenciones de Python. Pueden romperse fácilmente si así lo decides. Pero confío en que las respetes y las sigas en tus propios proyectos de desarrollo.

Modificadores de acceso en Python

Supongamos que tenemos esta sencilla clase:

class Tree:
   def __init__(self, height):
       self.height = height

pine = Tree(20)
print(pine.height)

20

Tiene un único atributo de altura que podemos imprimir. El problema es que también podemos cambiarlo por lo que queramos:

pine.height = 50
pine.height

50

pine.height = "Grandma"
pine.height

'Grandma'

Entonces, ¿cómo decimos a los usuarios que está prohibido cambiar la altura? Pues bien, podríamos convertirlo en un miembro protegido añadiendo un único guión bajo precedente:

class Tree:
   def __init__(self, height):
       self._height = height

pine = Tree(20)
pine._height

20

Ahora bien, las personas que conozcan esta convención sabrán que sólo pueden acceder al atributo y que les desaconsejamos encarecidamente que lo utilicen y lo modifiquen. Pero si quieren, pueden modificarlo, oh sí.

Entonces, ¿cómo podemos evitarlo también? Utilizando otra convención: convierte el atributo en un miembro privado añadiendo dos guiones bajos precedentes:

class Tree:
   def __init__(self, height):
       self.__height = height


pine = Tree(20)
pine.__height

AttributeError: 'Tree' object has no attribute '__height'

Ahora, Python lanzará un error si alguien intenta acceder al atributo, y mucho menos modificarlo.

Pero, ¿te has dado cuenta de lo que acabamos de hacer? Sólo ocultamos a los usuarios la información relacionada con nuestros objetos. Nuestra clase acaba de volverse inútil porque no tiene atributos públicos.

Entonces, ¿cómo exponemos la altura de los árboles a los usuarios, pero controlando cómo se accede a ellos y cómo se modifican? Por ejemplo, queremos que las alturas de los árboles estén dentro de un rango concreto y sólo tengan valores enteros. ¿Cómo lo hacemos cumplir?

Llegados a este punto, puede que tu amigo que utiliza Java intervenga y te sugiera utilizar métodos getter y setter. Así que, probemos eso primero:

class Tree:
   def __init__(self, height):
       self.__height = height

   def get_height(self):
       return self.__height

   def set_height(self, new_height):
       if not isinstance(new_height, int):
           raise TypeError("Tree height must be an integer")
       if 0 < new_height <= 40:
           self.__height = new_height
       else:
           raise ValueError("Invalid height for a pine tree")


pine = Tree(20)
pine.get_height()

20

De este modo, creas un atributo privado __height pero permites que los usuarios accedan a él y lo modifiquen de forma controlada mediante los métodos get_height y set_height.

pine.set_height(25)

pine.get_height()

25

Antes de fijar un nuevo valor, set_height se asegura de que la nueva altura está dentro de un rango determinado y numérico.

pine.set_height("Password")

TypeError: Tree height must be an integer

Pero estos métodos parecen exagerados para una operación sencilla. Además, es feo escribir código así:

# Increase height by 5
pine.set_height(pine.get_height() + 5)

¿No sería más bonito y legible si pudiéramos escribir este código?

pine.height += 5

y seguir aplicando el tipo de datos y el rango correctos para la altura? La respuesta es sí y aprenderemos a hacerlo en la siguiente sección.

Uso del decorador @propiedad en clases Python

Introducimos una nueva técnica: crear propiedades para los atributos:

class Tree:
   def __init__(self, height):
       # First, create a private or protected attribute
       self.__height = height

   @property
   def height(self):
       return self.__height

pine = Tree(17)
pine.height

17

Queremos que los usuarios accedan a un atributo oculto llamado __height como si fuera un atributo normal llamado height. Para conseguirlo, definimos un método llamado height que devuelve self.__height y lo decoramos con @property.

Ahora podemos llamar a height y acceder al atributo privado:

pine.height

17

Pero lo mejor es que los usuarios no pueden modificarlo:

pine.height = 15

AttributeError: can't set attribute 'height'

Así que añadimos otro método llamado height(self, new_height) que está envuelto por un decorador height.setter. Dentro de este método, implementamos la lógica que impone el tipo de datos y el rango deseados para la altura:

class Tree:
   def __init__(self, height):
       self.__height = height

   @property
   def height(self):
       return self.__height

   @height.setter
   def height(self, new_height):
       if not isinstance(new_height, int):
           raise TypeError("Tree height must be an integer")
       if 0 < new_height <= 40:
           self.__height = new_height
       else:
           raise ValueError("Invalid height for a pine tree")

Ahora, cuando un usuario intenta modificar el atributo height, se llama a @height.setter, asegurándose así de que se pasa el valor correcto:

pine = Tree(10)

pine.height = 33  # Calling @height.setter
pine.height = 45  # An error is raised

ValueError: Invalid height for a pine tree

También podemos personalizar cómo se accede al atributo height mediante la anotación por puntos con @height.getter:

class Tree:
   def __init__(self, height):
       self.__height = height

   @property
   def height(self):
       return self.__height

   @height.getter
   def height(self):
       # You can return a custom version of height
       return f"This tree is {self.__height} meters"


pine = Tree(33)

pine.height

'This tree is 33 meters'

Aunque creamos pine con una altura entera, podríamos modificar su valor con @height.getter.

Estos eran ejemplos de cómo podíamos promover la encapsulación en una clase Python. Recuerda que la encapsulación sigue siendo una convención, porque aún podemos romper el miembro privado interno de __height:

pine._Tree__height = "Gotcha!"

pine.height

'This tree is Gotcha! meters'

Todo en las clases Python es público, y también lo son los métodos privados. No se trata de un fallo de diseño, sino de un ejemplo del planteamiento "Aquí todos somos adultos".

Aquí tienes un resumen de los modificadores de acceso de Python que acabamos de revisar:

Buenas prácticas al implementar la encapsulación

Hay una serie de buenas prácticas que puedes seguir para asegurarte de que tu código se alinea bien con el código escrito por otros OOPistas experimentados:

1. Crea atributos o métodos protegidos o privados si sólo los utilizas tú. Los miembros protegidos o privados quedan excluidos de la documentación y señalan a los demás que pueden ser modificados por ti, el desarrollador, sin previo aviso, lo que les disuade de utilizarlos.
2. No siempre tienes que crear propiedades para cada atributo de la clase. Para clases grandes con muchos atributos, escribir los métodos attr.getter y attr.setter puede convertirse en un quebradero de cabeza.
3. Considera la posibilidad de lanzar un aviso cada vez que un usuario acceda a un miembro protegido (_).
4. Utiliza los miembros privados con moderación, ya que pueden hacer que el código resulte ilegible para quienes no estén familiarizados con la convención.
5. Prioriza la claridad sobre la oscuridad. Como la encapsulación pretende mejorar la mantenibilidad del código y la protección de los datos, no ocultes completamente los detalles importantes de implementación de tu clase.
6. Si quieres crear propiedades de sólo lectura, no implementes el método @attr.setter. Los usuarios podrán acceder a la propiedad, pero no modificarla.
7. Recuerda siempre que la encapsulación es una convención, no un aspecto obligatorio de la sintaxis de Python.
8. Para clases sencillas, considera el uso de clases de datos, que te permiten activar la encapsulación de clases con una sola línea de código. Sin embargo, las clases de datos son para clases más sencillas con atributos y métodos predecibles. Consulta este tutorial sobre clases de datos para saber más.

Conclusión y otros recursos

En este tutorial, hemos aprendido uno de los pilares básicos de la programación orientada a objetos en Python: la encapsulación.

La encapsulación te permite definir el acceso controlado a los datos almacenados dentro de los objetos de tu clase. Esto te permite escribir un código limpio, legible y eficaz, y evitar cambios o borrados accidentales de los datos de tus clases.

Aquí tienes más recursos relacionados para mejorar tus conocimientos de programación orientada a objetos:

• Tutorial de POO en Python
• Programación orientada a objetos en Python
• Cómo dominar Python - una guía para expertos