Programación Orientada a Objetos en Python

La programación orientada a objetos (POO) representa un paradigma fundamental que organiza el código alrededor de objetos y clases, permitiendo crear aplicaciones más estructuradas y mantenibles. En Python, este enfoque se integra de forma natural con la sintaxis del lenguaje, proporcionando herramientas elegantes para modelar problemas del mundo real.

Fundamentos conceptuales

La POO se basa en cuatro pilares fundamentales que transforman la manera de estructurar el código. La encapsulación permite agrupar datos y métodos relacionados dentro de una misma unidad, protegiendo el estado interno de los objetos. La herencia facilita la creación de nuevas clases basadas en clases existentes, promoviendo la reutilización de código.

El polimorfismo permite que objetos de diferentes clases respondan a la misma interfaz de manera específica, mientras que la abstracción oculta la complejidad interna exponiendo solo las funcionalidades esenciales.

Clases y objetos en Python

Una clase actúa como un molde o plantilla que define las características y comportamientos que tendrán los objetos creados a partir de ella. Los objetos son instancias específicas de una clase, cada uno con su propio estado y capacidad de ejecutar los métodos definidos.

class Vehiculo:
    def __init__(self, marca, modelo):
        self.marca = marca
        self.modelo = modelo
        self.velocidad = 0
    
    def acelerar(self, incremento):
        self.velocidad += incremento
        return f"{self.marca} {self.modelo} acelera a {self.velocidad} km/h"

# Creación de objetos
coche = Vehiculo("Toyota", "Corolla")
moto = Vehiculo("Honda", "CBR")

El método especial __init__ actúa como constructor, inicializando los atributos del objeto cuando se crea una nueva instancia. Los atributos de instancia (como self.marca) almacenan el estado específico de cada objeto.

Atributos y métodos

Los atributos representan las características o propiedades de los objetos, mientras que los métodos definen las acciones que pueden realizar. Python distingue entre atributos de instancia, únicos para cada objeto, y atributos de clase, compartidos por todas las instancias.

class Contador:
    total_contadores = 0  # Atributo de clase
    
    def __init__(self, valor_inicial=0):
        self.valor = valor_inicial  # Atributo de instancia
        Contador.total_contadores += 1
    
    def incrementar(self):
        self.valor += 1
    
    @classmethod
    def obtener_total(cls):
        return cls.total_contadores

Los métodos de clase utilizan el decorador @classmethod y reciben la clase como primer parámetro, permitiendo acceder a atributos de clase sin necesidad de crear una instancia.

Encapsulación y visibilidad

Python implementa la encapsulación mediante convenciones de nomenclatura que indican el nivel de acceso a los atributos y métodos. Los nombres que comienzan con un guión bajo sugieren uso interno, mientras que los que comienzan con doble guión bajo activan el name mangling.

class CuentaBancaria:
    def __init__(self, titular, saldo_inicial):
        self.titular = titular
        self._saldo = saldo_inicial  # Atributo protegido
        self.__numero_cuenta = self._generar_numero()  # Atributo privado
    
    def depositar(self, cantidad):
        if cantidad > 0:
            self._saldo += cantidad
            return True
        return False
    
    def _generar_numero(self):
        import random
        return random.randint(100000, 999999)
    
    @property
    def saldo(self):
        return self._saldo

Las propiedades (@property) proporcionan una interfaz controlada para acceder a atributos internos, permitiendo validaciones y cálculos sin exponer la implementación interna.

Herencia y jerarquías

La herencia permite crear nuevas clases basadas en clases existentes, heredando sus atributos y métodos. La clase base o padre proporciona funcionalidad común, mientras que las clases derivadas o hijas pueden especializarse añadiendo o modificando comportamientos.

class Animal:
    def __init__(self, nombre, especie):
        self.nombre = nombre
        self.especie = especie
    
    def hacer_sonido(self):
        return "El animal hace un sonido"

class Perro(Animal):
    def __init__(self, nombre, raza):
        super().__init__(nombre, "Canino")
        self.raza = raza
    
    def hacer_sonido(self):
        return f"{self.nombre} ladra: ¡Guau!"
    
    def buscar_pelota(self):
        return f"{self.nombre} busca la pelota"

La función super() permite acceder a métodos de la clase padre, facilitando la extensión de funcionalidad sin duplicar código. El polimorfismo se manifiesta cuando objetos de diferentes clases responden al mismo método de manera específica.

Métodos especiales

Python define métodos especiales (dunder methods) que permiten personalizar el comportamiento de los objetos con operadores y funciones integradas. Estos métodos proporcionan una integración natural con el lenguaje.

class Punto:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __str__(self):
        return f"Punto({self.x}, {self.y})"
    
    def __add__(self, otro):
        return Punto(self.x + otro.x, self.y + otro.y)
    
    def __eq__(self, otro):
        return self.x == otro.x and self.y == otro.y

# Uso natural de operadores
p1 = Punto(2, 3)
p2 = Punto(1, 4)
p3 = p1 + p2  # Utiliza __add__
print(p3)     # Utiliza __str__

Estos métodos especiales hacen que los objetos personalizados se comporten como tipos integrados, mejorando la legibilidad y naturalidad del código.