Programación Orientada a Objetos

POO en Python, explicada con ejemplos

Modela el mundo con clases y objetos. Domina los cuatro pilares —abstracción, encapsulamiento, herencia y polimorfismo— con código Python claro y directo.

Ver clases y objetos Los 4 pilares

Concepto

¿Qué es la POO?

Es una forma de organizar el código agrupando datos (atributos) y comportamiento (métodos) en unidades llamadas objetos. En vez de funciones sueltas que manipulan datos sueltos, modelas entidades del problema real: un usuario, un pedido, una cuenta bancaria.

Clase

El molde o plano. Define qué atributos y métodos tendrán los objetos de ese tipo. Ej.: la clase Perro.

Objeto

Una instancia concreta creada a partir de la clase, con sus propios valores. Ej.: mi_perro = Perro("Toby").

Lo básico

Clases y objetos

__init__ es el constructor: se ejecuta al crear el objeto. self es el propio objeto, y por él accedes a sus atributos y métodos.

class Perro:
    def __init__(self, nombre, edad):
        self.nombre = nombre      # atributo de instancia
        self.edad = edad

    def ladrar(self):          # método
        return f"{self.nombre} dice: ¡Guau!"

toby = Perro("Toby", 3)   # creamos un objeto (instancia)
print(toby.ladrar())        # Toby dice: ¡Guau!
print(toby.edad)             # 3

Fundamentos

Los 4 pilares de la POO

Todo lo demás se construye sobre estos cuatro principios.

Abstracción

Expones lo esencial y ocultas el detalle. Quien usa cafetera.preparar() no necesita saber cómo calienta el agua.

from abc import ABC, abstractmethod

class Figura(ABC):
    @abstractmethod
    def area(self): ...

Encapsulamiento

Proteges el estado interno y lo expones de forma controlada. En Python se usa _ por convención y @property.

class Cuenta:
    def __init__(self, saldo):
        self._saldo = saldo   # "privado"

    @property
    def saldo(self):
        return self._saldo

Herencia

Una clase reutiliza y extiende a otra. super() llama al comportamiento del padre.

class Animal:
    def __init__(self, nombre):
        self.nombre = nombre

class Gato(Animal):     # Gato hereda de Animal
    def hablar(self):
        return "Miau"

Polimorfismo

Objetos distintos responden al mismo método a su manera. El código que los usa no cambia.

def presentar(animal):
    print(animal.hablar())

for a in [Gato(), Perro()]:
    presentar(a)   # Miau / Guau

Referencia rápida

Chuleta de POO en Python

Lo que más vas a usar, en una tabla.

Concepto	Sintaxis	Para qué
Definir clase	`class Nombre:`	Crear el molde.
Constructor	`def __init__(self, ...):`	Inicializar el objeto.
Atributo de instancia	`self.x = valor`	Dato propio de cada objeto.
Atributo de clase	`x = valor` (fuera de __init__)	Compartido por todas las instancias.
Método	`def metodo(self, ...):`	Comportamiento del objeto.
Herencia	`class Hija(Padre):`	Reutilizar y extender.
Llamar al padre	`super().__init__(...)`	Reusar el constructor del padre.
Propiedad	`@property`	Getter controlado (encapsulamiento).
Método estático	`@staticmethod`	No usa `self`.
Método de clase	`@classmethod` → `cls`	Opera sobre la clase.
Representación	`def __repr__(self):`	Cómo se imprime el objeto.