Python: Programación Orientada a Objetos

La programación orientada a objetos (POO) es un paradigma de programación que se basa en el concepto de "objetos", los cuales pueden contener datos y código. En Python, este paradigma se implementa de manera eficiente y flexible, permitiendo a los desarrolladores crear estructuras de código robustas y reutilizables.

Clases y objetos

En POO, una clase es una plantilla para crear objetos. Define un conjunto de atributos y métodos que los objetos creados a partir de la clase tendrán. Un objeto es una instancia de una clase.

class Coche:
    def __init__(self, marca, modelo):
        self.marca = marca
        self.modelo = modelo

    def mostrar_info(self):
        print(f'Marca: {self.marca}, Modelo: {self.modelo}')

# Crear una instancia de la clase Coche
mi_coche = Coche('Toyota', 'Corolla')
mi_coche.mostrar_info()

En este ejemplo, Coche es una clase con un constructor __init__ que inicializa los atributos marca y modelo. El método mostrar_info imprime información sobre el coche.

Herencia

La herencia permite crear una nueva clase basada en una clase existente. La clase nueva (subclase) hereda los atributos y métodos de la clase existente (superclase).

class Vehiculo:
    def __init__(self, tipo):
        self.tipo = tipo

    def mostrar_tipo(self):
        print(f'Tipo de vehículo: {self.tipo}')

class Coche(Vehiculo):
    def __init__(self, marca, modelo):
        super().__init__('Coche')
        self.marca = marca
        self.modelo = modelo

    def mostrar_info(self):
        print(f'Marca: {self.marca}, Modelo: {self.modelo}')

# Crear una instancia de la subclase Coche
mi_coche = Coche('Toyota', 'Corolla')
mi_coche.mostrar_tipo()
mi_coche.mostrar_info()

La clase Coche hereda de Vehiculo, utilizando super() para llamar al constructor de la superclase.

Encapsulamiento

El encapsulamiento es la práctica de restringir el acceso a ciertos componentes de un objeto, generalmente mediante la definición de atributos y métodos privados.

class Coche:
    def __init__(self, marca, modelo):
        self.__marca = marca
        self.__modelo = modelo

    def mostrar_info(self):
        print(f'Marca: {self.__marca}, Modelo: {self.__modelo}')

# Crear una instancia de la clase Coche
mi_coche = Coche('Toyota', 'Corolla')
mi_coche.mostrar_info()

En este ejemplo, los atributos __marca y __modelo son privados y no pueden ser accedidos directamente desde fuera de la clase.

Polimorfismo

El polimorfismo permite que diferentes clases puedan ser tratadas como instancias de una misma clase a través de una interfaz común.

class Vehiculo:
    def mostrar_tipo(self):
        pass

class Coche(Vehiculo):
    def mostrar_tipo(self):
        print('Este es un coche')

class Moto(Vehiculo):
    def mostrar_tipo(self):
        print('Esta es una moto')

def mostrar_tipo_vehiculo(vehiculo):
    vehiculo.mostrar_tipo()

mi_coche = Coche()
mi_moto = Moto()

mostrar_tipo_vehiculo(mi_coche)
mostrar_tipo_vehiculo(mi_moto)

En este ejemplo, tanto Coche como Moto implementan el método mostrar_tipo, permitiendo que mostrar_tipo_vehiculo pueda trabajar con cualquier instancia de Vehiculo.

Métodos y atributos estáticos

Los métodos estáticos son aquellos que no dependen de una instancia de la clase. Se definen usando el decorador @staticmethod.

class Utilidad:
    @staticmethod
    def sumar(a, b):
        return a + b

resultado = Utilidad.sumar(5, 3)
print(resultado)

En este ejemplo, sumar es un método estático que puede ser llamado sin crear una instancia de Utilidad.

Métodos y atributos de clase

Los métodos de clase trabajan con la clase misma y no con instancias individuales. Se definen usando el decorador @classmethod.

class Coche:
    total_coches = 0

    def __init__(self, marca, modelo):
        self.marca = marca
        self.modelo = modelo
        Coche.total_coches += 1

    @classmethod
    def mostrar_total(cls):
        print(f'Total de coches: {cls.total_coches}')

# Crear instancias de la clase Coche
coche1 = Coche('Toyota', 'Corolla')
coche2 = Coche('Honda', 'Civic')

Coche.mostrar_total()

En este ejemplo, mostrar_total es un método de clase que accede al atributo de clase total_coches.