✅ Python Nivel 3 – Parte 2: Programación Orientada a Objetos Avanzada

 🔒 1. Encapsulamiento

Es un principio de la programación orientada a objetos que protege los datos internos de una clase, restringiendo el acceso directo a ellos.

🧪 Ejemplo:

class Usuario:
    def __init__(self, nombre):
        self.__nombre = nombre  # atributo privado (doble guión bajo)

    def obtener_nombre(self):
        return self.__nombre

¿Qué significa __nombre?
El doble guión bajo convierte el atributo en privado, es decir, no se puede acceder directamente desde fuera de la clase (usuario.__nombre dará error).

👉 Se accede mediante métodos públicos, como obtener_nombre().

---

🏷️ 2. Uso de @property y @setter

Permite controlar cómo se accede y modifica un atributo, manteniendo la sintaxis simple como si fuera público.

🧪 Ejemplo:

class Producto:
    def __init__(self, precio):
        self._precio = precio  # protegido

    @property
    def precio(self):
        return self._precio

    @precio.setter
    def precio(self, nuevo_precio):
        if nuevo_precio >= 0:
            self._precio = nuevo_precio

Ventaja:
Permite hacer validaciones al asignar o leer atributos, manteniendo una interfaz clara:

p = Producto(100)
p.precio = 150   # Usa el setter
print(p.precio)  # Usa el getter

---

🔁 3. Métodos Especiales (Magic Methods)

Son métodos que comienzan y terminan con __. Python los usa para sobrecargar operadores y personalizar comportamientos.

✅ Ejemplos útiles:

Método	¿Qué hace?
__str__	Representación en print()
__len__	Permite usar len(obj)
__eq__	Permite usar obj1 == obj2
__add__	Permite usar obj1 + obj2

🧪 Ejemplo de __str__:

class Punto:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"Punto({self.x}, {self.y})"

p = Punto(1, 2)
print(p)  # Imprime: Punto(1, 2)

---

🧱 4. Principios SOLID aplicados a Python

Estos principios ayudan a diseñar código mantenible, limpio y escalable.

🧩 Explicación de cada uno:

• S – Single Responsibility
  Cada clase debe tener una única responsabilidad. No mezcles lógica de base de datos con lógica de interfaz, por ejemplo.

• O – Open/Closed
  Las clases deben estar abiertas a extensión pero cerradas a modificación. Usa herencia o composición en lugar de cambiar código existente.

• L – Liskov Substitution
  Una subclase debe poder reemplazar a su clase padre sin alterar el comportamiento del programa.

• I – Interface Segregation
  No fuerces a una clase a implementar métodos que no necesita. Divide interfaces en bloques más pequeños si hace falta.

• D – Dependency Inversion
  No dependas de clases concretas, sino de abstracciones. Usa interfaces o clases base cuando sea posible.

---

🏦 5. Ejemplo completo con todo lo aprendido

class CuentaBancaria:
    def __init__(self, titular, saldo=0):
        self.titular = titular
        self._saldo = saldo

    def depositar(self, cantidad):
        self._saldo += cantidad

    def retirar(self, cantidad):
        if cantidad <= self._saldo:
            self._saldo -= cantidad

    def __str__(self):
        return f"{self.titular} - Saldo: €{self._saldo}"

• Usa encapsulamiento (_saldo)

• Tiene métodos claros y separados

• Usa __str__ para mostrar el objeto de forma legible

• Cumple con el principio SRP (una clase → una tarea)