A medida que un script crece, terminas pasando el mismo grupo de variables entre funciones y resulta difícil saber qué datos pertenecen a qué lógica. Las clases y objetos de Python resuelven esto agrupando datos y comportamiento en una unidad.

En este tutorial, creamos una pequeña cuenta bancaria paso a paso y agregamos cada idea de programación orientada a objetos solo cuando resuelve un problema. Ejecutamos todos los ejemplos en Python 3.13 y el resultado que se muestra proviene de esa ejecución. Si eres nuevo en el idioma, lee primero nuestro tutorial de Python para principiantes.

¿Qué son las clases y los objetos?

Una clase describe qué es algo y qué puede hacer. Un objeto, también llamado instancia, es uno específico creado a partir de esa descripción. “Cuenta” es una clase, mientras que la cuenta de Asha y la cuenta de Ben son dos objetos.

Has estado usando objetos todo el tiempo. En Python, las cadenas, listas e incluso funciones son objetos, por eso puedes escribir "hello".upper().

tu primera clase

class Account:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self.balance += amount
        return self.balance

a = Account("Asha", 100)
b = Account("Ben")

a.deposit(50)
print(a.balance, b.balance)

# 150 0

__init__ se ejecuta automáticamente cada vez que crea un objeto y establece el estado inicial. Depositar en a no tocó b, porque cada objeto tiene sus propios datos. Tenga en cuenta que el método también protege el saldo de un valor incorrecto. Nuestra guía para el manejo de excepciones de Python explica raise con más profundidad.

¿Qué es uno mismo?

self es simplemente el objeto en el que está trabajando un método. Cuando escribes a.deposit(50), Python llama efectivamente a Account.deposit(a, 50), pasando el objeto como primer argumento. Así es como una definición de método puede servir a cada objeto.

El nombre self es una convención fuerte más que una palabra clave, pero utilícela siempre. Olvidarlo en la definición de un método es el error más común de los principiantes y produce un mensaje confuso sobre la cantidad de argumentos.

Atributos de clase versus atributos de instancia

Todos los objetos comparten un atributo establecido directamente en el cuerpo de la clase. Un conjunto en self pertenece únicamente a ese objeto. Este ejemplo muestra cómo se comportan las búsquedas:

class Account:
    interest_rate = 0.04    # class attribute

    def __init__(self, owner, balance=0):
        self.owner = owner  # instance attribute
        self.balance = balance

a = Account("Asha", 100)
b = Account("Ben")
print(a.interest_rate, b.interest_rate)   # 0.04 0.04

Account.interest_rate = 0.05
print(a.interest_rate, b.interest_rate)   # 0.05 0.05

a.interest_rate = 0.09
print(a.interest_rate, b.interest_rate, Account.interest_rate)
# 0.09 0.05 0.05

Esa última línea sorprende a la gente. La asignación a través de a no cambió el valor compartido. Creó un nuevo atributo de instancia en a que oculta el de clase. Python mira primero el objeto y luego la clase.

Métodos especiales (dunder)

Los métodos con guiones bajos dobles permiten que sus objetos funcionen con las funciones integradas de Python. Sin ellos, imprimir una cuenta muestra una dirección de memoria inútil. Agregar dos le da una forma legible:

    def __str__(self):
        return f"{self.owner}: {self.balance}"

    def __repr__(self):
        return f"Account({self.owner!r}, {self.balance})"

print(a)        # Asha: 150
print([a, b])   # [Account('Asha', 150), Account('Ben', 0)]

herencia

La herencia permite que una nueva clase reutilice una existente y cambie sólo lo que difiere. Aquí, Savings es un Account con una configuración adicional:

class Savings(Account):
    def __init__(self, owner, balance=0, limit=3):
        super().__init__(owner, balance)
        self.limit = limit

    def __str__(self):
        return f"{super().__str__()} (savings)"

s = Savings("Chitra", 500)
s.deposit(100)
print(s, isinstance(s, Account), s.limit)

# Chitra: 600 (savings) True 3

super() llama a la versión principal, por lo que la lógica de configuración no se repite. deposit se heredó tal como estaba y __str__ se anuló para agregar una etiqueta. Utilice la herencia únicamente para una relación real “es un”. Si una clase simplemente necesita algo, como un automóvil que necesita un motor, dale ese objeto como atributo. Esto se conoce como composición y suele ser más flexible que las cadenas de herencia profunda.

polimorfismo

El polimorfismo significa que diferentes objetos pueden responder a la misma llamada a un método a su manera. El código de llamada no necesita saber el tipo exacto:

class Square:
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

class Circle:
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return round(3.14159 * self.radius ** 2, 2)

for shape in [Square(3), Circle(2)]:
    print(type(shape).__name__, shape.area())

# Square 9
# Circle 12.57

Estas dos clases ni siquiera comparten un padre. A Python solo le importa que el objeto tenga un método area, un enfoque conocido como tipificación pato. Agregar un Triangle más tarde no necesitaría cambios en el bucle.

Encapsulación y propiedades.

Python no tiene atributos verdaderamente privados y, en cambio, se basa en convenciones. Un solo guión bajo, como en _price, les dice a otros desarrolladores “esto es interno, no lo toques”. Para verificar los valores cuando están configurados, use una propiedad, que parece un atributo simple desde el exterior:

class Product:
    def __init__(self, price):
        self.price = price

    @property
    def price(self):
        return self._price

    @price.setter
    def price(self, value):
        if value < 0:
            raise ValueError("price cannot be negative")
        self._price = value

p = Product(100)
p.price = 150
print(p.price)      # 150
p.price = -5        # ValueError: price cannot be negative

Esto significa que puede comenzar con un atributo simple y agregar validación más adelante sin cambiar ningún código que use la clase. Por lo tanto, no escriba los métodos get_price() y set_price() por costumbre, como podría hacerlo en Java. La sintaxis @ aquí es un decorador, que explicamos en Explicación de los decoradores de Python.

Métodos de clase y métodos estáticos.

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    @classmethod
    def from_fahrenheit(cls, f):
        return cls(round((f - 32) * 5 / 9, 1))

    @staticmethod
    def is_freezing(celsius):
        return celsius <= 0

Temperature.from_fahrenheit(212).celsius   # 100.0
Temperature.is_freezing(-3)                # True

Clases de datos

Cuando una clase contiene principalmente datos, escribir __init__, __repr__ y __eq__ a mano es tedioso. @dataclass los genera a partir de anotaciones de tipo:

from dataclasses import dataclass, field

@dataclass
class Item:
    name: str
    price: int
    tags: list = field(default_factory=list)

print(Item("Pen", 10))
print(Item("Pen", 10) == Item("Pen", 10))

# Item(name='Pen', price=10, tags=[])
# True

Errores comunes

Usando un atributo de clase mutable

Este es un error clásico. La lista está definida en la clase, por lo que todos los carritos la comparten:

class Cart:
    items = []            # shared by every cart!

    def add(self, item):
        self.items.append(item)

c1, c2 = Cart(), Cart()
c1.add("pen")
print(c2.items)

# ['pen']

Créelo en __init__ con self.items = [], para que cada objeto tenga su propia lista.

Otros errores comunes

• Olvidando self. Escriba self.balance, no balance, dentro de los métodos.
• Olvidar super().__init__(). El niño entonces pierde los atributos establecidos por el padre.
• Construyendo clases enormes. Una clase que hace de todo es difícil de probar. Divídalo por responsabilidad.
• Herencia profunda. Dos niveles suelen ser suficientes y la composición suele ser más clara.
• No escribir pruebas. Las clases con reglas son fáciles de probar, como muestra nuestro tutorial de pytest usando un carrito pequeño.

Conclusión

Python orientado a objetos se reduce a agrupar datos con el comportamiento que los protege. Comience con __init__, métodos y __str__, luego agregue herencia y propiedades cuando encuentre un problema que resuelvan. Como siguiente paso, tome un script que pase las mismas variables en todas partes y conviértalos en una clase pequeña.

Preguntas frecuentes

sigue aprendiendo