Introducción a la programación orientada a objetos en Python

Ya has usado objetos siempre que has trabajado con un número, una cadena, una lista o un diccionario. Un objeto tiene un tipo, un valor o estado y operaciones que admite. Incluso las funciones y None son objetos. Escribir tu propia clase amplía este sistema que ya conoces.

Averigua el tipo y los métodos de un objeto

type("hello") devuelve <class 'str'>; type([1, 2]) devuelve <class 'list'>. Las palabras tipo y clase describen aquí la misma función. isinstance(3.5, float) es True, mientras que isinstance("3.5", float) es False: el segundo valor es texto, aunque parezca numérico.

Un método es una función que proporciona un tipo. En "ada lovelace".title(), la cadena anterior al punto es el objeto, title es el método y los paréntesis lo llaman. El resultado es "Ada Lovelace". dir(value) enumera los nombres que ofrece un objeto; nombres como __len__ son métodos especiales que conectan los objetos con operaciones de Python como len(value).

Sigue el resultado y el original

Una llamada a método puede devolver un resultado, modificar un objeto o hacer ambas cosas. Comprueba el comportamiento del método antes de decidir qué asignar.

word = "level"
print(word.count("l"))  # 2
print(word.upper())     # LEVEL
print(word)             # level

nums = [3, 1, 2]
result = nums.sort()
print(nums)             # [1, 2, 3]
print(result)           # None

Las cadenas son inmutables: su contenido no puede cambiar. upper() devuelve otra cadena, por lo que word conserva su valor original. Para guardar el resultado en mayúsculas con ese nombre, escribe word = word.upper().

Las listas son mutables. sort() modifica la propia lista y devuelve None. Escribir nums = nums.sort() pierde la referencia a la lista que contenía nums y asigna None. Usa nums.sort() en su propia línea o nums = sorted(nums) para obtener una lista nueva ordenada. Para un diccionario, {"a": 1}.get("b", 0) devuelve 0 porque falta la clave solicitada.

Los paréntesis también importan. word.upper es un objeto método; word.upper() lo ejecuta. Muchos objetos pueden ofrecer el mismo comportamiento: "cat".upper() y "dog".upper() usan un mismo tipo de método con distintos datos de cadena.

Distingue igualdad e identidad

La igualdad comprueba si los valores coinciden. La identidad comprueba si dos nombres se refieren a un mismo objeto.

a = [1, 2]
b = [1, 2]
c = a
print(a == b)  # True
print(a is b)  # False
print(c is a)  # True
c.append(3)
print(a)       # [1, 2, 3]
print(b)       # [1, 2]

a y b empiezan con contenidos iguales, pero son listas independientes. c = a crea un alias, otro nombre para la misma lista. Añadir un elemento a través de c modifica el objeto al que también se refiere a. No modifica la lista independiente que contiene b. Al seguir la ejecución de un programa, dibuja una caja por objeto y una flecha desde cada nombre hasta su caja.

Una clase define un tipo que puedes usar en tu propio programa. Cada objeto creado a partir de ella es una instancia. Una clase describe el tipo de cosa; las instancias contienen los datos de cosas concretas. Un formulario en blanco y sus copias rellenadas ofrecen una comparación útil.

Escribe una clase y llámala

Una sentencia class tiene la palabra reservada class, un nombre, dos puntos y un cuerpo con sangría. pass proporciona un cuerpo vacío mientras pruebas la estructura.

class Book:
    pass

b1 = Book()
b2 = Book()
print(b1 is b2)           # False
print(isinstance(b1, Book))  # True

Cada llamada Book() crea una instancia independiente. En un archivo de programa, type(b1) muestra <class '__main__.Book'>. La sentencia class debe ejecutarse antes de que el código intente usar Book. También puedes definir una clase en un módulo e importarla con from library import Book, y después crear instancias en el programa que la usa.

Sigue las convenciones de nombres de Python: Book, BankAccount y ShoppingCart usan CapWords, con cada palabra iniciada en mayúscula. Las variables y los métodos usan palabras en minúsculas separadas por guiones bajos, como book_count y add_item. Usa cuatro espacios por cada nivel de sangría.

Almacena datos en cada instancia

Un atributo es un valor con nombre al que se accede con un punto. Asignar un atributo lo almacena; leer el mismo nombre lo recupera.

b1.title = "Dune"
b2.title = "Emma"
b1.pages = 412
print(b1.title)  # Dune
print(b2.title)  # Emma
print(b1.pages)  # 412

Los datos pertenecen a la instancia seleccionada. Dar a b1 un atributo pages no se lo da a b2. Leer ahora b2.pages lanza AttributeError, porque ese objeto no tiene un atributo llamado pages.

Las asignaciones pueden crear nombres nuevos sin comprobar qué querías hacer. Después de b1.titel = "X", el b1.title original sigue conteniendo "Dune"; el objeto ha adquirido un segundo atributo con un nombre mal escrito. Si parece que un valor no cambia, compara cómo está escrito donde se asigna y donde se lee.

Distingue la clase de sus instancias

b = Book da otro nombre a la clase. No crea un libro. Si los títulos solo se han asignado en las instancias, solicitar Book.title lanza AttributeError; no hay un único título compartido por el tipo.

Da a cada objeto un inicio fiable

Es posible asignar atributos desde fuera, pero eso deja la inicialización repartida por el programa. Un libro podría recibir un título y un número de páginas, mientras que otro solo recibe un título. El código posterior no puede dar por seguro que ambos tengan pages.

Un método de inicialización llamado __init__ coloca las asignaciones iniciales dentro de la clase. Cada llamada de creación sigue entonces el mismo proceso de inicialización. La clase puede exigir un título y crear otros atributos con valores iniciales adecuados, para que el código que la llama no tenga que recordar una secuencia aparte de asignaciones.

Cada cuenta recién creada necesita un titular y un saldo inicial. Colocar esa inicialización en __init__ da a cada objeto los atributos que esperan los métodos posteriores. Python crea primero la instancia y después llama a __init__ para inicializarla.

Conecta los argumentos con los atributos

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
        self.transactions = []

acct = BankAccount("Maya", 50)
other = BankAccount("Leo")

En la primera llamada, Python pasa la cuenta nueva como self, "Maya" como owner y 50 como balance. Las asignaciones hacen que acct.owner sea igual a "Maya" y acct.balance sea igual a 50. La segunda llamada usa el saldo predeterminado, por lo que other.balance es 0.

self es el parámetro que recibe el objeto actual. Es una convención, no una palabra reservada de Python. Usa este nombre para que quien lea el código reconozca el objeto enseguida. El código que realiza la llamada lo omite: BankAccount("Maya", 50) proporciona dos argumentos, no tres.

Distingue los nombres locales de los datos almacenados

En self.owner = owner, el nombre de la derecha es un parámetro local. El nombre de la izquierda es un atributo almacenado en el objeto. Cuando termina la inicialización, otros métodos pueden seguir usando self.owner.

Escribir balance = balance solo reasigna el nombre local. No crea ningún atributo, por lo que leer acct.balance después falla. Pon self. delante de cada atributo que deba permanecer como parte del objeto.

Planifica la inicialización enumerando lo que necesita cada instancia. Los valores obligatorios se convierten en parámetros después de self; los opcionales pueden tener valores predeterminados. Los valores que siempre comienzan igual pueden asignarse en el cuerpo, como self.visits = 0. Una lista creada mediante self.transactions = [] se crea de nuevo en cada llamada.

Evita una lista predeterminada compartida

Un argumento predeterminado se evalúa cuando Python define el método. Con def __init__(self, items=[]), las llamadas que omiten items reciben la misma lista. Si el inicializador almacena esa lista directamente, modificar los elementos de un objeto cambia los elementos que ve otro.

Usa None como valor predeterminado y crea una lista nueva durante cada llamada:

class Cart:
    def __init__(self, items=None):
        self.items = [] if items is None else list(items)

a = Cart()
b = Cart()
a.items.append("pen")
print(b.items)  # []

list(items) también crea una lista externa nueva cuando el código que realiza la llamada proporciona una. Los objetos de esa lista siguen siendo referencias compartidas; crear la lista no recrea cada elemento.

Interpreta los errores de inicialización

A BankAccount() le falta el argumento obligatorio owner y lanza TypeError. Compara la llamada con los parámetros que aparecen después de self.

El nombre __init__ tiene dos guiones bajos a cada lado. _init_ es un nombre de método normal y no realizará esta inicialización automáticamente. __init__ debe devolver None, así que normalmente se omite la sentencia return. Devolver un saldo lanza TypeError; la propia llamada a la clase proporciona la instancia nueva al código que la llama.

Algunos valores describen un objeto; otros describen el tipo en su conjunto. El tamaño de una pizza pertenece a esa pizza. Un límite de ingredientes o un recuento de pizzas creadas puede pertenecer a la clase. El lugar donde se realiza una asignación determina qué tipo de atributo crea.

Coloca el valor en el lugar adecuado

class Pizza:
    MAX_TOPPINGS = 5
    count = 0

    def __init__(self, size):
        self.size = size
        self.toppings = []
        Pizza.count += 1

p1 = Pizza("large")
p2 = Pizza("small")

size y toppings son atributos de instancia, asignados en self. Cada pizza tiene sus propios valores. MAX_TOPPINGS y count son atributos de clase, asignados en el cuerpo de la clase fuera de un método. Las mayúsculas indican que un valor se considera una constante; no impiden su reasignación.

Después de estas llamadas, Pizza.count es 2. Cada inicializador actualiza el mismo atributo de clase. p1.size es "large", mientras que p2.size es "small".

Sigue la búsqueda y la ocultación de nombres

Para atributos de datos normales como estos, leer p1.MAX_TOPPINGS comprueba primero la instancia y después la clase. Como no hay ningún valor almacenado en p1, Python encuentra Pizza.MAX_TOPPINGS, que es 5.

Asignar a través de una instancia tiene un efecto distinto:

p1.MAX_TOPPINGS = 8
Pizza.MAX_TOPPINGS = 6
print(p1.MAX_TOPPINGS)     # 8
print(p2.MAX_TOPPINGS)     # 6
print(Pizza.MAX_TOPPINGS)  # 6

La primera línea crea un atributo de instancia en p1. Este oculta el valor de clase para ese objeto. Cambiar después el valor de clase llega a p2, que sigue leyendo de la clase, pero no sustituye el valor propio de p1.

Vigila dos formas de compartir datos por accidente

Si el inicializador usara self.count += 1, Python leería el 0 de la clase, sumaría uno y almacenaría un atributo de instancia. Cada pizza nueva recibiría su propio count de 1, mientras que Pizza.count seguiría siendo 0. Usa el nombre de la clase al actualizar un contador de toda la clase.

Una lista en el cuerpo de la clase causa un problema distinto. Con toppings = [], todas las instancias que no tienen un atributo de ingredientes independiente encuentran la misma lista. p1.toppings.append("olives") modifica esa lista compartida; no asigna un atributo de instancia nuevo. Pon self.toppings = [] en __init__ cuando cada pizza necesite sus propios ingredientes.

Inspecciona los datos propios de un objeto

Para el p2 original, vars(p2) da {'size': 'small', 'toppings': []}. Los valores de clase no aparecen porque están en Pizza. Esto resulta útil al depurar una búsqueda inesperada: comprueba si la instancia tiene su propio valor y después inspecciona el valor de clase. Un ajuste compartido pertenece a la clase; un nombre, tamaño, saldo o colección personal pertenece a la instancia.

Un objeto debe comenzar en un estado que sus métodos puedan usar. Un rectángulo con anchura negativa no puede representar la figura prevista. Una regla que debe seguir siendo verdadera para todos los objetos de una clase es un invariante. La validación comprueba esas reglas antes de aceptar datos.

Comprueba antes de almacenar

class Rectangle:
    def __init__(self, width, height):
        if width <= 0:
            raise ValueError("width must be positive")
        if height <= 0:
            raise ValueError("height must be positive")
        self.width = width
        self.height = height

Rectangle(3, 4) supera ambas comprobaciones y devuelve un objeto inicializado. Rectangle(-2, 4) lanza ValueError en la primera comprobación. Las asignaciones posteriores nunca se ejecutan. Si el programa no captura esa excepción, la ejecución se detiene ahí.

Supón que r ya se refiere a un rectángulo válido. En r = Rectangle(-2, 4), la llamada de la derecha falla antes de la asignación. r conserva su valor anterior. Si r no tenía valor antes de la llamada fallida, la asignación no crea ninguno.

Elige una excepción útil

Una anchura numérica negativa es un error de valor. Proporcionar texto donde se requiere un número es un error de tipo. La comparación con 0 de este ejemplo ya lanza TypeError para texto. Una clase también puede comprobar un tipo explícitamente con isinstance cuando necesita un mensaje más claro.

Escribe mensajes que indiquen la regla, como "width must be positive". Un mensaje que solo diga "bad input" obliga al código que realiza la llamada a adivinar qué valor debe corregirse.

Deja que el código que realiza la llamada gestione la recuperación

while True:
    try:
        width = float(input("Width: "))
        room = Rectangle(width, 3)
        break
    except ValueError as error:
        print("Try again:", error)

Introducir abc falla en float; introducir -2 supera la conversión, pero falla en Rectangle. Ambos lanzan ValueError, así que este bucle gestiona los dos casos. La clase establece su regla de datos, mientras que el código que realiza la llamada decide volver a preguntar.

Mostrar una advertencia dentro de __init__ no rechaza la llamada. Si la ejecución continúa, el programa puede recibir un objeto no válido y fallar después al usarlo. Lanzar una excepción detiene la inicialización fallida donde se produce el problema.

Limpia los datos de forma deliberada y mantén la regla

Una limpieza documentada puede ser útil. self.name = name.strip() elimina los espacios de los extremos; valida el nombre limpio si no se permiten nombres en blanco. self.items = list(items) crea una lista externa independiente, de modo que añadir elementos a la lista del código que realiza la llamada no los añade a esta. Cambiar una anchura no válida por su valor absoluto alteraría la intención del código que realiza la llamada, así que necesita una regla de diseño explícita.

Las comprobaciones de inicialización se ejecutan al crear el objeto. Una asignación simple como r.width = -5 sigue saltándoselas después. Los métodos que cambian una anchura deben comprobarla de nuevo. Una propiedad puede incluir una comprobación en la propia asignación del atributo, lo que permite ejecutar la misma regla durante la inicialización y en actualizaciones posteriores.

Un método de instancia es una función definida dentro de una clase que trabaja con el objeto pasado como self. El objeto proporciona sus datos almacenados; los parámetros adicionales proporcionan cualquier otra información necesaria para la acción.

Lee los atributos a través de self

Añade estos métodos dentro de la clase Rectangle con validación, al mismo nivel de sangría que __init__:

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

    def is_square(self):
        return self.width == self.height

Con r = Rectangle(3, 4), r.area() devuelve 12, r.perimeter() devuelve 14 y r.is_square() devuelve False. Cada método lee los atributos del mismo objeto. Un segundo rectángulo usa las mismas definiciones de métodos con su propia anchura y altura.

Dentro de un método, self.width nombra un atributo. width por sí solo nombra una variable local u otra variable accesible; Python no la busca automáticamente en el objeto actual. Si no existe tal variable, return width * height lanza NameError. Escribir self. deja explícito a qué objeto pertenecen los datos.

Sigue la llamada

Para esta clase, r.area() funciona como Rectangle.area(r). Python encuentra la función en la clase y proporciona r como primer argumento. Una referencia a método como r.area es un método vinculado: recuerda la función y este rectángulo. Añadir () realiza la llamada.

Si un método se define como def resize(self, factor), llámalo como r.resize(2). r ocupa self y 2 ocupa factor. No vuelves a pasar r. Si un método de instancia se escribe por accidente como def area():, una llamada sobre r lanza TypeError porque Python sigue proporcionando el objeto a una función que no acepta argumentos.

Un método puede usar otro a través de self:

    def double_area(self):
        return self.area() * 2

Aquí self.area() calcula usando el mismo rectángulo. Omitir self. solicitaría una función independiente llamada area, no el método del objeto.

Devuelve resultados al código que realiza la llamada

Un método de cálculo normalmente debe devolver su resultado. Devolver proporciona al código que realiza la llamada un valor que puede almacenar, combinar, comprobar o mostrar:

r1 = Rectangle(3, 4)
r2 = Rectangle(2, 5)
total = r1.area() + r2.area()
print(total)  # 22

Si area solo mostrara su respuesta, cada llamada devolvería None. La suma fallaría entonces con TypeError, aunque hubieran aparecido dos números en la pantalla. Mostrar es una acción; devolver proporciona un valor a la expresión que contiene la llamada.

Usa nombres de métodos que indiquen la tarea. deposit y resize nombran acciones; is_square y has_room sugieren comprobaciones booleanas. Un método no necesita parámetros para los datos que ya están almacenados en su objeto. Necesita parámetros para entradas nuevas, como un factor de cambio de tamaño o el importe de un depósito.

El estado de un objeto es el conjunto actual de valores de sus atributos. Un método de consulta informa sobre ese estado. Un método modificador lo cambia. Un método modificador útil comprueba sus entradas y mantiene todos los atributos relacionados, para que el código que lo llama no tenga que coordinar varias actualizaciones.

Valida primero todo el cambio

Añade estos métodos dentro de la clase BankAccount, que tiene titular, saldo y lista de transacciones:

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

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("withdrawal must be positive")
        if amount > self.balance:
            raise ValueError("insufficient funds")
        self.balance -= amount
        self.transactions.append(("withdraw", amount))

Un depósito cambia el saldo y registra la operación. Una retirada comprueba tanto el signo del importe como el saldo disponible antes de restar. Estas comprobaciones impiden que una retirada rechazada cambie el saldo o su historial.

Partiendo de BankAccount("Maya", 50), depositar 25 da 75 y retirar 30 da 45. Un intento posterior de retirar 100 lanza ValueError; deja el saldo en 45 y no añade ninguna transacción. Colocar la resta antes de la comprobación de fondos cambiaría el estado incluso en caso de fallo.

Distingue un cambio de un valor devuelto

Estos métodos modificadores no tienen sentencia return, por lo que devuelven None. Después de new_balance = acct.deposit(25), el depósito se ha realizado, pero new_balance es None. Lee acct.balance después para obtener el número actualizado.

Una clase puede ofrecer otro estilo de método que devuelva un objeto nuevo. resize sugiere cambiar un rectángulo; resized puede elegirse para un método que devuelva un rectángulo nuevo y deje intacto el original. Lee el contrato del método: el nombre ayuda, pero su definición determina el comportamiento.

Sigue las referencias compartidas

a = BankAccount("Maya", 50)
b = a
b.deposit(10)
print(a.balance)  # 60
print(a is b)     # True

La asignación vincula un nombre a un objeto; no copia ese objeto. Ambos nombres acceden a la cuenta cuyo saldo ha cambiado. Pasar a a una función también proporciona acceso a ese objeto. Por tanto, una función que llame a account.withdraw(5) puede cambiar la cuenta que ve el código que la llama.

Para obtener una cuenta independiente con el mismo titular y saldo, crea BankAccount(a.owner, a.balance). Ese constructor también proporciona un historial nuevo y vacío. Es una cuenta nueva, no una copia completa de su historial.

copy.copy(a) crea un objeto externo nuevo, pero conserva las referencias a los mismos objetos internos, incluida la lista de transacciones. copy.deepcopy(a) copia también los objetos anidados. Cuando la independencia sea importante, comprueba tanto los objetos dentro de los atributos como la instancia externa.

Asignar directamente acct.balance = -500 se salta las comprobaciones de los dos métodos. Las convenciones de atributos internos y las propiedades ayudan a dejar clara la vía prevista de actualización y a mantener la validación cerca de los cambios de estado.

El código que realiza las llamadas necesita una forma clara de leer y modificar un objeto. La encapsulación mantiene las reglas de sus datos junto a los métodos que los gestionan. Python usa convenciones y propiedades para expresar esa interfaz.

Marca el almacenamiento interno

Un guion bajo inicial en _balance indica un atributo interno. El código que usa la cuenta debe utilizar sus métodos, pero Python sigue permitiendo el acceso directo. No hay ninguna palabra reservada private que bloquee el acceso al valor.

Un nombre como __balance, con dos guiones bajos iniciales y sin dos guiones bajos finales, activa la transformación de nombres. Dentro de class Acc, self.__balance se almacena con el nombre _Acc__balance. Fuera, obj.__balance falla, pero obj._Acc__balance puede seguir funcionando. La transformación evita conflictos de nombres; no protege datos sensibles.

Ejecuta un método mediante la sintaxis de atributos

Una propiedad hace que se ejecute un método al leer un atributo. La línea @property es un decorador: cambia cómo Python expone el método. Una propiedad sin método de asignación permite leer, pero rechaza la asignación.

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

    @property
    def balance(self):
        return self._balance

Después de acct = Account("Maya", 50), lee acct.balance sin paréntesis. Asignar acct.balance = 10 lanza AttributeError porque esta propiedad no tiene método de asignación. Un método de depósito dentro de la clase podría actualizar _balance después de sus comprobaciones.

Comprueba la asignación con un método de asignación

class Student:
    def __init__(self, name, score):
        self.name = name
        self.score = score

    @property
    def score(self):
        return self._score

    @score.setter
    def score(self, value):
        if not 0 <= value <= 100:
            raise ValueError("score must be between 0 and 100")
        self._score = value

Los métodos de consulta y de asignación comparten el nombre score; el valor almacenado usa _score. Al crear el objeto, self.score = score ejecuta el método de asignación.

Para s = Student("Ana", 88), asignar s.score = 92 almacena 92. Asignar s.score = -1 lanza ValueError antes de almacenar, por lo que la puntuación sigue siendo 92. Student("Ana", 105) falla durante la inicialización.

Dentro del método de asignación, self.score = value volvería a llamar al método, repitiéndose hasta producir RecursionError. El método de consulta tiene el mismo riesgo si devuelve self.score. Usa el nombre de almacenamiento independiente _score en ambos cuerpos.

Calcula los valores cuando se leen

Una propiedad puede calcular un valor a partir de otros atributos:

    @property
    def area(self):
        return self.width * self.height

Colocada dentro de una clase de rectángulos, permite usar r.area. Para una anchura de 3 y una altura de 4, el valor es 12. Cambiar la anchura a 5 hace que la siguiente lectura devuelva 20. Almacenar un área una sola vez durante la inicialización dejaría un valor antiguo después de cambiar la anchura.

Empieza con un atributo simple cuando baste con almacenar el valor.

Un objeto resulta más fácil de inspeccionar cuando puede describir sus propios datos. Los métodos especiales permiten que Python solicite esa descripción mediante acciones conocidas como print, str y repr. Sus nombres empiezan y terminan con dos guiones bajos y suelen llamarse nombres dunder.

Elige texto para dos públicos

__str__ proporciona texto legible para los usuarios de un programa. __repr__ proporciona una descripción precisa para quienes programan. Ambos devuelven cadenas; ninguno debe mostrar su resultado en lugar de devolverlo.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"({self.x}, {self.y})"

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(p)        # (3, 4)
print(repr(p))  # Point(3, 4)

str(p) devuelve la cadena "(3, 4)". repr(p) devuelve "Point(3, 4)". Cuando es posible, una representación se parece a una llamada a la clase que recrearía el valor. Sigue siendo texto: llamar a repr no crea por sí mismo otro punto.

Sin una representación personalizada, una instancia simple suele mostrar un nombre de clase y un identificador parecido a una dirección. Eso ayuda a distinguir objetos, pero no muestra sus datos útiles. Rara vez llamas directamente a estos métodos especiales; defínelos una vez y usa las operaciones habituales de visualización de Python.

Predice qué muestra un contenedor

Con la clase anterior, print([Point(3, 4), Point(0, 0)]) muestra [Point(3, 4), Point(0, 0)]. La lista usa las representaciones de sus elementos, aunque cada elemento también tenga __str__.

Si defines solo __repr__, el __str__ predeterminado también lo usa. Definir solo __str__ no cambia repr ni la visualización de los contenedores. Por tanto, al añadir un único método de visualización, __repr__ sirve para más situaciones de inspección.

Haz que los campos de cadena sean inequívocos

Para un libro que ya almacena title, author y year, estos métodos ofrecen distintas vistas útiles:

    def __str__(self):
        return f"{self.title} by {self.author} ({self.year})"

    def __repr__(self):
        return f"Book({self.title!r}, {self.author!r}, {self.year})"

Para el libro con título "Dune", autor "Frank Herbert" y año 1965, el primer método da "Dune by Frank Herbert (1965)". El segundo da "Book('Dune', 'Frank Herbert', 1965)". !r solicita las representaciones de los campos de cadena, incluidas las comillas.

Un cuerpo que solo contiene print(self.x) devuelve None, por lo que str(p) falla con TypeError. Devolver un número entero también falla. Construye el texto necesario y después devuelve esa cadena.

Los métodos especiales conectan una clase con operadores y funciones incorporadas. Define solo operaciones con un significado claro para ese tipo: sumar vectores se entiende; añadir un jugador a un equipo resulta más claro como team.add_player(player).

Compara valores y mantén los hashes seguros

Dos instancias simples independientes se consideran distintas de forma predeterminada. Añade igualdad de valores a una clase de puntos con:

    def __eq__(self, other):
        if not isinstance(other, Point):
            return NotImplemented
        return self.x == other.x and self.y == other.y

Ahora dos puntos en (3, 4) se consideran iguales aunque sus identidades sean distintas. in, count, index y remove en listas pueden encontrar esos valores iguales. El resultado habitual de != se obtiene a partir de __eq__.

NotImplemented es un valor de retorno que permite a Python probar el otro operando o una alternativa predeterminada. No es una excepción que debas lanzar. Cuando ninguno de los operandos admite la igualdad de valores, == recurre a la identidad; un punto y la cadena "3,4" se consideran distintos.

Definir __eq__ sin __hash__ hace que las instancias no sean aptas para hash. Entonces no pueden ser elementos de conjuntos ni claves de diccionarios. Los objetos iguales deben tener hashes iguales y el hash de una clave debe mantenerse estable. Si los atributos comparados nunca cambian, un hash compatible puede devolver hash((self.x, self.y)). Mantén los objetos de valor mutables sin aptitud para hash cuando puedan cambiar sus campos de igualdad.

Define un orden

__lt__ proporciona <. Una clase de estudiantes puede comparar puntuaciones con return self.score < other.score. Las puntuaciones 88, 72 y 95 se ordenan entonces como 72, 88, 95. min elige la más baja; max elige la más alta usando > y su comparación reflejada <.

Con solo __lt__, a > b puede usar b < a. Python no deduce <= ni >= a partir de esa definición; necesitan sus propios métodos. Si un orden solo resulta útil para una tarea, pasa una función de clave de ordenación:

def by_score(student):
    return student.score

ordered = sorted(students, key=by_score)

Devuelve resultados nuevos en las operaciones aritméticas

Dentro de una clase de vectores con atributos x e y:

    def __add__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(self.x + other.x, self.y + other.y)

    def __mul__(self, factor):
        if not isinstance(factor, (int, float)):
            return NotImplemented
        return Vector(self.x * factor, self.y * factor)

    def __rmul__(self, factor):
        return self * factor

Vector(1, 2) + Vector(3, 4) produce un vector nuevo (4, 6). Multiplicar el primer vector por 3 produce (3, 6) y deja intacto el original. __mul__ gestiona el vector a la izquierda; __rmul__ admite un número a la izquierda. Python no supone que ambos órdenes signifiquen lo mismo.

Proporciona una longitud con sentido

Para una lista de reproducción que almacena self.songs, define __len__ para que devuelva len(self.songs). El resultado debe ser un número entero no negativo. len(playlist) cuenta entonces las canciones. En esta clase, una longitud de cero también hace que if playlist: sea falso; un __bool__ personalizado tendría prioridad sobre la longitud al comprobar el valor de verdad.

Los atributos de un objeto pueden referirse a otros objetos. Un carrito contiene artículos, una biblioteca contiene libros y un curso contiene estudiantes. La composición construye un objeto mayor a partir de otros más pequeños mediante esta relación tiene.

Da a cada objeto su propia responsabilidad

class Item:
    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price
        self.quantity = quantity

    def subtotal(self):
        return self.price * self.quantity

class ShoppingCart:
    def __init__(self):
        self.items = []

    def add(self, item):
        if not isinstance(item, Item):
            raise TypeError("a cart holds Item objects")
        self.items.append(item)

    def total(self):
        total = 0
        for item in self.items:
            total += item.subtotal()
        return total

El carrito tiene una lista independiente creada durante la inicialización. Su método add comprueba el objeto recibido antes de añadirlo. cart.add("pen") lanza TypeError en lugar de almacenar texto que fallará cuando se solicite un subtotal.

Crea los artículos antes de las llamadas o durante ellas:

cart = ShoppingCart()
cart.add(Item("notebook", 2.50, 4))
cart.add(Item("pen", 1.25, 3))
print(cart.total())         # 13.75
print(cart.items[0].name)   # notebook

Los subtotales son 10.0 y 3.75; el carrito los suma para obtener 13.75. La cadena cart.items[0].name accede primero a la lista del carrito, después a su primer objeto y después al nombre de ese objeto.

Delega el trabajo en el objeto que sabe hacerlo

El carrito pide subtotal() a cada artículo. Esto es delegación: un objeto llama al método de otro objeto para realizar parte de una tarea. Si un descuento por volumen cambia cómo se calcula un subtotal, esa regla pertenece a Item.subtotal. El carrito puede seguir sumando los subtotales devueltos sin duplicar las reglas de precios.

Pasar Item en lugar de Item(...) pasa la clase, no un artículo comprado. La comprobación de tipo rechaza ese objeto clase. Realiza todas las adiciones a través de la vía con comprobación; acceder directamente a cart.items.append(...) se saltaría add.

Busca un objeto

Añade este método dentro de ShoppingCart:

    def find(self, name):
        for item in self.items:
            if item.name == name:
                return item
        return None

La primera coincidencia devuelve el artículo existente. Si no hay coincidencia, devuelve None. Comprueba found is None antes de usar found.name; None no tiene ese atributo. Un método __len__ que devuelva len(self.items) también podría hacer que len(cart) contara los objetos artículo almacenados, mientras que __str__ podría unir las líneas de los artículos para formar un recibo.

Sigue las referencias dentro de las colecciones

Una lista almacena referencias, por lo que colocar el mismo artículo en dos carritos no lo copia. Actualizar el precio de ese artículo afecta al siguiente total que calculen ambos carritos. Las listas de carrito independientes evitan compartir listas por accidente, pero no hacen independientes los objetos que contienen. Crea artículos separados cuando los carritos deban contener datos independientes.

Los objetos pueden ser argumentos de métodos y valores de retorno igual que los números o las cadenas. Sigue por separado el objeto receptor, los argumentos y el resultado: un método puede modificar un objeto existente, devolver uno nuevo o simplemente informar de un valor.

Usa otro objeto como entrada

Dentro de una clase de puntos con x e y, un método puede leer ambos puntos:

    def midpoint(self, other):
        return Point((self.x + other.x) / 2,
                     (self.y + other.y) / 2)

Para p = Point(3, 4) y q = Point(1, 0), middle = p.midpoint(q) crea un tercer punto en (2.0, 2.0). Durante la llamada, self se refiere a p y other se refiere a q. El método calcula coordenadas y construye un punto nuevo; no asigna nada a ninguno de los originales.

Con import math, un método de distancia puede devolver math.hypot(self.x - other.x, self.y - other.y). Point(0, 0).distance_to(Point(3, 4)) da entonces 5.0. Esta llamada devuelve un número, mientras que midpoint devuelve un objeto.

Deja que cada objeto receptor gestione sus cambios

Dentro de una clase de cuentas con métodos withdraw y deposit que realizan comprobaciones:

    def transfer_to(self, other, amount):
        self.withdraw(amount)
        other.deposit(amount)

Si Maya tiene 100 y Leo tiene 20, maya.transfer_to(leo, 30) primero retira de la cuenta de Maya, dejándola en 70, y después deposita en la de Leo, dejándola en 50. En la primera llamada, self es la cuenta de Maya. En la llamada de depósito, su propio self es la cuenta de Leo.

Una transferencia posterior de 500 falla en withdraw porque Maya solo tiene 70. La ejecución se detiene antes de deposit, por lo que ambos saldos conservan sus valores anteriores. El orden de las llamadas importa. Python no deshace un cambio de estado anterior si una llamada posterior lanza una excepción; este método breve depende de que el depósito de la cuenta receptora pueda aceptar el importe.

Llamar a other.deposit(amount) ejecuta las reglas de la cuenta receptora en un mismo lugar. Cambiar directamente other.balance se las saltaría.

Sigue los objetos, no solo los nombres de las variables

Dibuja cada instancia como una caja que contiene sus atributos. Dibuja una flecha desde cada variable hasta su caja. En una llamada, identifica qué caja recibe self y qué cajas se pasan como argumentos. Actualiza la caja afectada después de cada línea que cambie el estado correctamente. Dos flechas hacia una caja significan que un cambio a través de cualquiera de los nombres llega al mismo objeto.

Una función normal también puede trabajar con varios objetos. total_balance(accounts) puede recorrer las cuentas y sumar sus saldos. Ese cálculo sobre toda la lista no tiene por qué pertenecer a una sola cuenta.

Representa una relación ausente

Un libro puede empezar con self.borrower = None y después almacenar un objeto miembro. Antes de leer un atributo del miembro, comprueba la relación:

if book.borrower is not None:
    print(book.borrower.name)

De lo contrario, book.borrower.name falla cuando el libro no tiene prestatario. Las clases pueden definirse encima de una función main() que crea y conecta los objetos. Llamar a main() bajo if __name__ == "__main__": impide que esas acciones se ejecuten al importar las clases.

Una clase se justifica cuando resulta más fácil entender juntos los datos relacionados y las operaciones repetidas. No necesitas convertir cada función o registro en una clase. Elige la estructura que deje claras las responsabilidades del programa.

Busca datos y comportamiento que vayan juntos

Las clases ayudan cuando varias funciones reciben continuamente el mismo grupo de valores, muchos registros comparten una estructura y los cambios de estado deben seguir reglas comunes. Varias cuentas que admiten depósitos y retiradas encajan bien. Un cálculo aislado puede seguir siendo una función. Un registro fijo de solo lectura puede seguir siendo una tupla o un diccionario.

Una clase que solo tiene inicialización y una operación que se realiza una vez suele añadir más formalidades que estructura útil. Pregúntate qué representa una instancia y qué acciones repetidas le corresponden. Si no puedes responder esas preguntas de forma sencilla, reconsidera el diseño.

Mueve una operación junto a sus datos

Una cuenta basada en un diccionario podría empezar así:

account = {"owner": "Maya", "balance": 50}

def deposit(account, amount):
    account["balance"] += amount

La versión con clase puede colocar la misma operación junto a su estado y sus reglas:

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

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

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

Después de acct = BankAccount("Maya", 50) y acct.deposit(25), su representación es BankAccount('Maya', 75). La regla de depósito positivo se ejecuta ahora siempre que el código usa ese método. Leer account["balence"] lanzaría KeyError; leer acct.balence lanza AttributeError. Una clase no elimina las erratas, pero da a los datos y a sus operaciones un lugar con nombre.

Planifica a partir de una descripción breve

En «Una biblioteca presta libros a sus miembros. Un miembro puede tener prestados como máximo 3 libros», los sustantivos sugieren Book, Member y Library. Los verbos sugieren métodos de préstamo y devolución.

1. Enumera lo que sabe cada instancia: el título, autor y prestatario de un libro; el nombre y los libros prestados de un miembro; los libros y miembros de una biblioteca.
2. Identifica las reglas: un libro no puede estar ya prestado y un miembro no puede superar MAX_LOANS = 3.
3. Coloca cada regla en la operación que cambia la relación, como Library.check_out(book, member).
4. Escribe la inicialización y una representación útil; después añade y prueba una acción cada vez.

Los títulos distintos necesitan instancias distintas de Book, no clases separadas con el nombre de cada título. Usa sustantivos en singular para los objetos individuales, como Book; nombra una colección por lo que representa, como Library. Mantén la tarea de cada clase lo bastante clara como para describirla en una frase.

Prueba el comportamiento observable

acct = BankAccount("Maya", 50)
acct.deposit(25)
assert acct.balance == 75

assert lanza AssertionError si su condición es falsa. Prueba también las acciones rechazadas: captura la excepción esperada y verifica que el estado no haya cambiado. Usa validación explícita con raise para los datos de entrada del código que realiza la llamada; las aserciones son comprobaciones durante el desarrollo y pueden desactivarse cuando Python se ejecuta con optimización.