Clases y objetos en Python con Claude Code

En el tutorial anterior conseguimos que la fórmula de la gravedad se escribiera una sola vez, en una función. Pero si os fijasteis, el nombre de cada cuerpo y su masa seguían siendo variables sueltas, cada una por su lado — y nada impedía, por error, mezclar la masa de un cuerpo con el nombre de otro. Hoy resolvemos eso con Programación Orientada a Objetos (POO), usando Claude Code y el mismo ejemplo de la Ley de Gravitación de Newton, para que veas el proceso completo y lo repitas tú mismo.

El problema que resuelve

Cuando varios datos describen la misma cosa —el nombre y la masa de un mismo planeta, la nota y el nombre de un mismo alumno— guardarlos en variables sueltas obliga a mantenerlas sincronizadas a mano, y nada impide pasar la pareja equivocada a una función por error. Cuantas más “cosas” maneja el programa, más frágil se vuelve. Una clase agrupa esos datos relacionados dentro de un único objeto, para que viajen siempre juntos.

Lo que necesitas antes de empezar

Haber visto el tutorial anterior de Claude Code sobre la gravitación (o al menos conocer la función fuerza_gravitatoria), y una base de programación en Python con variables, condicionales, bucles y funciones ya vistas en clase. El ejemplo sigue usando la Ley de Gravitación Universal de Newton (F = G × m₁ × m₂ / r²), pero el método sirve para cualquier conjunto de datos que describan la misma entidad: el nombre y la nota de un alumno, el nombre y la vida de un personaje de videojuego.

Paso 1 — Parte de un programa con datos sueltos que van juntos

Este es el punto de partida: el nombre y la masa de cada cuerpo viven en variables sueltas (nombre_tierra, masa_tierra…), y una función ya calcula la fuerza entre ellos:

python

nombre_tierra = "Tierra"
masa_tierra = 5.972e24

nombre_luna = "Luna"
masa_luna = 7.348e22

nombre_sol = "Sol"
masa_sol = 1.989e30

nombre_marte = "Marte"
masa_marte = 6.417e23

def fuerza_gravitatoria(masa1, masa2, distancia):
    G = 6.674e-11
    return G * masa1 * masa2 / distancia ** 2

fuerza_tierra_luna = fuerza_gravitatoria(masa_tierra, masa_luna, 3.844e8)
print(f"Fuerza entre {nombre_tierra} y {nombre_luna}:", fuerza_tierra_luna, "N")

fuerza_tierra_sol = fuerza_gravitatoria(masa_tierra, masa_sol, 1.496e11)
print(f"Fuerza entre {nombre_tierra} y {nombre_sol}:", fuerza_tierra_sol, "N")

fuerza_marte_sol = fuerza_gravitatoria(masa_marte, masa_sol, 2.279e11)
print(f"Fuerza entre {nombre_marte} y {nombre_sol}:", fuerza_marte_sol, "N")

Ejecútalo y guarda los resultados — los necesitarás en el paso 3:

Fuerza entre Tierra y Luna: 1.9820216361078954e+20 N
Fuerza entre Tierra y Sol: 3.542236855858046e+22 N
Fuerza entre Marte y Sol: 1.6400775141557086e+21 N

Paso 2 — Pide el paso a clases a Claude Code, pidiendo también que lo compruebe

Abre Claude Code en la carpeta del archivo y pega este prompt, probado antes de publicar este tutorial:

“Aquí tienes un programa que calcula la fuerza de gravedad entre varios cuerpos, pero el nombre y la masa de cada cuerpo están en variables sueltas (nombre_tierra, masa_tierra, nombre_luna, masa_luna…) que en teoría se podrían mezclar por error. Ayúdame a agrupar el nombre y la masa de cada cuerpo en una clase CuerpoCeleste, sin cambiar el resultado de los cálculos. Después de refactorizarlo, comprueba de verdad que los resultados son idénticos a los del programa original — no me expliques solo por qué deberían serlo, ejecútalo y compáralo — y explícame en un par de frases qué es el constructor de la clase y por qué cada objeto guarda su propio nombre y su propia masa.”

Fíjate en la misma estructura de tres partes que ya usamos con el refactor a funciones: qué se agrupa, que no cambie el resultado, y que lo compruebe ejecutando, no solo explicando.

Paso 3 — Revisa el resultado, no solo la explicación

Claude Code debería devolverte algo parecido a esto:

python

class CuerpoCeleste:
    def __init__(self, nombre, masa):
        self.nombre = nombre
        self.masa = masa

def fuerza_gravitatoria(cuerpo1, cuerpo2, distancia):
    G = 6.674e-11
    return G * cuerpo1.masa * cuerpo2.masa / distancia ** 2

tierra = CuerpoCeleste("Tierra", 5.972e24)
luna = CuerpoCeleste("Luna", 7.348e22)
sol = CuerpoCeleste("Sol", 1.989e30)
marte = CuerpoCeleste("Marte", 6.417e23)

fuerza_tierra_luna = fuerza_gravitatoria(tierra, luna, 3.844e8)
print(f"Fuerza entre {tierra.nombre} y {luna.nombre}:", fuerza_tierra_luna, "N")

fuerza_tierra_sol = fuerza_gravitatoria(tierra, sol, 1.496e11)
print(f"Fuerza entre {tierra.nombre} y {sol.nombre}:", fuerza_tierra_sol, "N")

fuerza_marte_sol = fuerza_gravitatoria(marte, sol, 2.279e11)
print(f"Fuerza entre {marte.nombre} y {sol.nombre}:", fuerza_marte_sol, "N")

Ejecútalo tú mismo y compara los tres resultados, número por número, con los que guardaste en el paso 1 — en la prueba de este tutorial salieron idénticos hasta el último decimal. El constructor __init__ es el bloque que se ejecuta al crear cada objeto y decide qué guarda: aquí, self.nombre y self.masa, para que cada cuerpo lleve siempre pegados su propio nombre y su propia masa.

Si Claude Code, además del cambio que pediste, sugiere algo más (en la prueba de este tutorial, convertir la función en un método de la propia clase, algo como tierra.fuerza_con(luna, distancia)), no lo aceptes ni lo rechaces sin más: es una decisión de diseño válida, pero va un paso más allá de lo que pediste. Coméntalo con tus alumnos antes de decidir si la incorporáis.

Paso 4 — Añade un cuerpo nuevo, ahora en una sola línea

La prueba de que el refactor mereció la pena es lo fácil que es añadir un cuerpo nuevo sin tener que crear dos variables sueltas que recordar:

python

jupiter = CuerpoCeleste("Júpiter", 1.898e27)
fuerza_jupiter_sol = fuerza_gravitatoria(jupiter, sol, 7.785e11)
print(f"Fuerza entre {jupiter.nombre} y {sol.nombre}:", fuerza_jupiter_sol, "N")

Una sola línea crea el nombre y la masa juntos, ya inseparables.

Avisos

Este tutorial da por hecho que ya se ha visto el anterior sobre funciones — conviene verlo primero o repasarlo en un minuto. Deja fuera, a propósito, la herencia y el polimorfismo: son el siguiente escalón del currículo de Programación y Computación de 2º de Bachillerato, pero mezclarlos aquí sería demasiado de golpe.

Idea para llevarse a casa

Una clase agrupa datos que describen la misma cosa dentro de un único objeto, para que no puedan mezclarse por error ni vivir desincronizados en variables sueltas. El constructor es el bloque que rellena esos datos al crear cada objeto — y comprobar que el resultado no cambia sigue siendo tan importante como pedir el cambio.