Programación orientada a objetos} dek="Hasta ahora has organizado tu código con funciones. La POO te da una herramienta más poderosa: agrupar datos y comportamiento en un solo tipo nuevo que tú defines." />

Imagina que estás modelando una cuenta bancaria. Necesitas guardar el titular, el saldo, el número de cuenta. Y también necesitas operaciones: depositar, retirar, consultar. Con lo que sabes hasta ahora harías un diccionario para los datos y funciones separadas para las operaciones. Funciona, pero nada impide que alguien modifique el saldo directamente, o que llames a la función de retirar con el diccionario equivocado.

La programación orientada a objetos (POO) resuelve esto empaquetando datos y operaciones juntos en una clase: un nuevo tipo de dato que tú defines, con sus propias reglas.

Clases y objetos: el concepto

Una clase es el molde. Un objeto (o instancia) es algo concreto creado a partir de ese molde. La clase Perro describe qué es un perro — tiene nombre, raza, edad, puede ladrar. Cada perro concreto (Rex, Luna) es un objeto distinto creado a partir de ese mismo molde.

Tu primera clase

Definir una clase en Python:

{`Rex Golden retriever Rex dice: ¡Guau! Luna dice: ¡Guau!`}

Hay tres cosas nuevas que entender bien:

class Perro: — define la clase. Por convención, los nombres de clase usan CamelCase: primera letra de cada palabra en mayúscula.
__init__ — es el constructor: el método que Python llama automáticamente cuando creas una nueva instancia con Perro(...). Aquí es donde inicializas los datos del objeto.
self — es una referencia al propio objeto. Siempre es el primer parámetro de cualquier método, pero no lo pasas tú — Python lo pasa solo. self.nombre accede al atributo nombre de ese objeto concreto.

Si te olvidas de self como primer parámetro de un método, Python dará un error raro cuando lo llames. Y si te olvidas de escribir self.nombre y escribes solo nombre, estarás creando una variable local que desaparece al terminar __init__ — el objeto quedará sin ese atributo.

Atributos

Los atributos son las variables de un objeto. Se crean asignando con self.algo = valor dentro de los métodos (normalmente en __init__) y se accede a ellos con objeto.algo:

self.saldo: print("Saldo insuficiente.") return self.saldo -= cantidad self.movimientos.append(f"-{cantidad}") def ver_saldo(self): return f"{self.titular}: {self.saldo:.2f} €" cuenta = CuentaBancaria("Ana", 1000) cuenta.depositar(500) cuenta.retirar(200) cuenta.retirar(2000) # saldo insuficiente print(cuenta.ver_saldo()) print(cuenta.movimientos)`} /> {`Saldo insuficiente. Ana: 1300.00 € ['+500', '-200']`}

Atributos de clase vs atributos de instancia

Los atributos que defines dentro de __init__ con self son de instancia: cada objeto tiene los suyos. También puedes definir atributos de clase directamente en el cuerpo de la clase — son compartidos por todas las instancias:

{`60.5 36.3 55.0`}

Métodos

Los métodos son las funciones de un objeto. Se definen igual que funciones normales pero dentro de la clase, con self como primer parámetro. Ya los has visto — ladrar, depositar — pero hay unos especiales que vale la pena conocer bien.

Métodos especiales (dunder methods)

Python tiene métodos con nombre entre dobles guiones bajos (__nombre__) que se llaman automáticamente en ciertas situaciones. Se llaman dunder methods (de double underscore). Los más útiles:

{`Punto(1, 2) Punto(x=1, y=2) True False Punto(4, 6)`} Sin __str__, print(mi_objeto) muestra algo como <__main__.Punto object at 0x7f3a...> — inútil para depurar. Implementa siempre __str__ en tus clases. Con dos líneas conviertes tu objeto en algo legible.

Método	Se activa cuando…	Ejemplo

Herencia

La herencia permite crear una clase nueva basándose en una existente. La clase nueva (hija o subclase) hereda todos los atributos y métodos de la clase original (padre o superclase) y puede añadir los suyos o cambiar los que necesite.

{`Rex hace guau Misi hace miau ['sentarse'] Misi ronronea... True True`}

super() es la forma de referirse a la clase padre desde la hija. super().__init__(...) llama al constructor del padre sin tener que repetir su código.

isinstance(obj, Clase) devuelve True si el objeto es de esa clase o de cualquier subclase suya. type(obj) == Clase solo es True si es exactamente esa clase. En código real casi siempre quieres isinstance.

Sobreescribir métodos (override)

Si la subclase define un método con el mismo nombre que el padre, el suyo tiene prioridad. Eso se llama sobreescribir el método:

{`Soy una forma con área 78.54 Soy una forma con área 24.00`}

Fíjate en el detalle: describir() está definido solo en Forma, pero cuando lo llamas desde un Circulo, el self.area() llama al area() del Circulo, no al de Forma. Esto se llama polimorfismo: el mismo código funciona distinto según el tipo real del objeto.

Encapsulamiento: convenciones de privacidad

Python no tiene atributos "privados" de verdad, pero tiene una convención que todo el mundo respeta: un guión bajo delante significa "esto es interno, no lo toques desde fuera":

{`100 212.0 25 ValueError: Temperatura por debajo del cero absoluto.`} El decorador @property (que veremos más a fondo en el Libro 3) convierte un método en un atributo de solo lectura. Con @nombre.setter añades validación al asignar. Así el usuario escribe t.celsius = 25 (sencillo) y por detrás se ejecuta código de validación (seguro).

Un ejemplo completo: Biblioteca

Vamos a construir algo real: un sistema mínimo de biblioteca con libros y préstamos.

Ejercicios

Cinco ejercicios de complejidad creciente. El primero es una clase simple; el último incluye herencia y métodos especiales.

Tu primera clase completa con atributos, métodos y __str__.

Una estructura de datos clásica implementada como clase.

Herencia y polimorfismo en un ejemplo de negocio real.

Métodos especiales para hacer que tu clase funcione con los operadores de Python.

Un sistema real con dos clases que colaboran. Cierra el módulo con todo integrado.

Resumen del módulo

// lo importante en una página

Clase: molde que define estructura y comportamiento. Objeto: copia concreta de ese molde.
class Nombre: define la clase. Convención: CamelCase.
__init__(self, ...) es el constructor — se llama al crear el objeto.
self es la referencia al objeto actual. Siempre es el primer parámetro de los métodos.
Atributos de instancia: self.x = v. Cada objeto tiene los suyos.
Atributos de clase: fuera de métodos, compartidos por todos los objetos.
Dunder methods (__str__, __eq__, __add__…) definen cómo se comporta el objeto con operadores y funciones de Python.
Herencia: class Hija(Padre):. Usa super() para llamar al padre.
Polimorfismo: el mismo método se comporta distinto según la subclase. No necesitas saber el tipo exacto.
Convención _privado: guión bajo = "interno, no uses desde fuera".
@property convierte un método en un atributo con validación.
isinstance(obj, Clase) comprueba el tipo incluyendo herencia.

La POO no es una técnica — es una forma de pensar. Una vez que ves el mundo en términos de objetos con responsabilidades claras, escribir programas grandes se vuelve manejable en lugar de caótico.