1.8. Encapsulamiento

El encapsulamiento en Python es un principio de la programación orientada a objetos que consiste en ocultar los detalles de implementación de una clase y exponer solo una interfaz pública para interactuar con los objetos de esa clase. Esto se logra definiendo atributos y métodos como públicos, privados o protegidos.

1.8.1. Niveles de Encapsulamiento:

Atributos y Métodos Públicos: Son accesibles desde cualquier parte del programa. Se definen sin ningún prefijo especial.

class Persona:
    def __init__(self, nombre):
        self.nombre = nombre
    
    def saludar(self):
        return f"Hola, soy {self.nombre}."

Atributos y Métodos Privados: Son accesibles solo desde dentro de la clase que los define. Se definen con un prefijo de doble guion bajo (__).

class Persona:
    def __init__(self, nombre):
        self.__nombre = nombre
    
    def __saludar(self):
        return f"Hola, soy {self.__nombre}."

Atributos y Métodos Protegidos: Son accesibles desde dentro de la clase que los define y desde las clases que heredan de ella. Se definen con un prefijo de un solo guion bajo (_).

class Persona:
    def __init__(self, nombre):
        self._nombre = nombre
    
    def _saludar(self):
        return f"Hola, soy {self._nombre}."

1.8.2. Uso de Encapsulamiento

El encapsulamiento permite ocultar la implementación interna de una clase y proporcionar una interfaz clara y bien definida para interactuar con los objetos de esa clase. Esto promueve la modularidad, la seguridad y el mantenimiento del código.

class Persona:
    def __init__(self, nombre):
        self.__nombre = nombre
    
    def saludar(self):
        return f"Hola, soy {self.__nombre}."

# Crear un objeto de la clase Persona
persona = Persona("Juan")

# Acceder a un atributo público
print(persona.nombre)  # Error: AttributeError: 'Persona' object has no attribute 'nombre'

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[5], line 2
      1 # Acceder a un atributo público
----> 2 print(persona.nombre)  # Error: AttributeError: 'Persona' object has no attribute 'nombre'

AttributeError: 'Persona' object has no attribute 'nombre'

# Acceder a un atributo privado
print(persona.__nombre)  # Error: AttributeError: 'Persona' object has no attribute '__nombre'

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[6], line 2
      1 # Acceder a un atributo privado
----> 2 print(persona.__nombre)  # Error: AttributeError: 'Persona' object has no attribute '__nombre'

AttributeError: 'Persona' object has no attribute '__nombre'

# Acceder a un método público
print(persona.saludar())  # Salida: Hola, soy Juan

Hola, soy Juan.

En este ejemplo, el atributo nombre es privado y solo se puede acceder a él desde dentro de la clase Persona. El método saludar() es público y proporciona una forma segura de interactuar con el objeto persona sin exponer su implementación interna.

En resumen, el encapsulamiento en Python permite controlar el acceso a los atributos y métodos de una clase y promueve una interfaz clara y segura para interactuar con los objetos de esa clase. Esto ayuda a mejorar la modularidad, la seguridad y el mantenimiento del código.