Saltearse al contenido

Todo es un objeto

La frase «en Python todo es un objeto» se repite tanto que ha dejado de significar algo. Significa una cosa muy concreta y muy cara: cada valor del lenguaje lleva una cabecera de dieciséis bytes antes de contener un solo dato, y esa cabecera se paga en cada número, cada letra y cada lista que tu programa crea.

Entender eso convierte varias intuiciones vagas en decisiones: por qué un millón de enteros ocupa cuarenta megabytes, por qué numpy existe, por qué is no sirve para comparar valores y por qué id() no es un identificador que puedas guardar.

Python no tiene tipos primitivos. Tiene objetos con cabecera, y la cabecera se paga siempre.

Todo objeto tiene tres cosas, y sólo una puede cambiar:

Propiedad Qué es Se consulta con ¿Cambia?
Identidad El objeto concreto que es id(x) Nunca, mientras viva
Tipo Qué operaciones admite type(x) Nunca
Valor Lo que contiene ==, len(x), etc. Sólo si es mutable
x = [1, 2, 3]
id(x) # 2314983724352 (una dirección; cambia entre ejecuciones)
type(x) # <class 'list'>
x == [1, 2, 3] # True — mismo valor

id() devuelve, en CPython, la dirección de memoria del objeto. Es un detalle de implementación, no una garantía del lenguaje: otra implementación podría devolver cualquier número estable. Lo único prometido es que mientras el objeto viva, su id no cambia.

El tipo tampoco cambia, y eso incluye a bool: type(True) is int da False, aunque isinstance(True, int) da True, porque bool es una subclase de int. Comparar tipos con type() es más estricto que con isinstance(), y casi nunca es lo que quieres.

Tamaño de objetos sueltos
Objeto bytes Qué lo compone
int pequeño (0) 28 B cabecera 16 + tamaño 8 + un dígito 4
int grande (10**18) 32 B igual, con dos dígitos
float 24 B cabecera 16 + un double 8
str vacío 41 B cabecera de cadena 40 + terminador
str de 12 caracteres ASCII 53 B 41 de cabecera + 12 caracteres
list vacía 56 B cabecera + puntero a items + capacidad
dict vacío 64 B cabecera + tabla hash mínima

python mediciones/02-11-coste.py

Dos observaciones que ordenan el resto del manual.

La primera: el suelo es 24 bytes. Un float —el tipo más simple que existe— pesa 24. Nada en Python baja de ahí, porque nada puede prescindir de la cabecera.

La segunda: el texto es barato por carácter y caro por objeto. Mil caracteres ASCII cuestan 1.041 bytes: 41 de estructura y 1.000 de contenido. Pero un millón de cadenas de tres letras cuesta 44 bytes cada una, no tres.

En C, todo objeto de Python empieza con la misma estructura:

typedef struct {
Py_ssize_t ob_refcnt; // 8 bytes: cuántas referencias lo apuntan
PyTypeObject *ob_type; // 8 bytes: de qué clase es
} PyObject; // 16 bytes de cabecera

De ahí sale todo lo demás. Un int añade un campo de tamaño y al menos un dígito de 30 bits: 16 + 8 + 4 = 28. Un float añade un double: 16 + 8 = 24. Una str añade longitud, hash cacheado y banderas, y guarda los caracteres a continuación en el mismo bloque: por eso mil caracteres ASCII son cuarenta bytes de estructura más mil de contenido.

La cabecera se repite en cada objeto
int 0 refcnt 8 B type 8 B tamaño 8 B dígito 4 B = 28 B float 3.14 refcnt 8 B type 8 B double 8 B = 24 B str '' refcnt 8 B type 8 B longitud 8 B hash 8 B estado 8 B \0 1 B = 41 B

Los dos primeros bloques —contador de referencias y puntero al tipo— son idénticos en todo objeto. Ese es el precio de entrada del lenguaje.

El campo ob_type es el que hace posible el polimorfismo sin compilación anticipada: cuando escribes x + y, el intérprete mira el tipo de x, busca __add__ en su tabla y lo llama. No hay tipos estáticos, hay una búsqueda en cada operación. Ese es el intercambio: flexibilidad a cambio de una indirección permanente.

La lección caducada: el despacho ya no cuesta

Sección titulada «La lección caducada: el despacho ya no cuesta»

Durante veinte años se enseñó a atar el método a una variable local antes de un bucle, porque «buscar el atributo en cada vuelta es caro». En Python 3.13 ya no gana nada: la diferencia está dentro del ruido.

Llamar a un método dos millones de veces
Forma Coste por vuelta
c.inc() dentro del bucle 35.0 ns
inc = c.inc y luego inc() 36.4 ns

timeit, CPython 3.13

El motivo está en el campo ob_type: desde Python 3.11 el intérprete es especializante (PEP 659). La primera vez que ejecuta c.inc() en un sitio del código, mira el tipo de c y busca el método; en las siguientes, ese mismo sitio recuerda el tipo y la entrada encontrada y salta directamente. La búsqueda que la vieja regla intentaba evitar ya sólo ocurre una vez.

Es el primer ejemplo de una advertencia que recorre este manual: los consejos de rendimiento caducan. Muchos siguen citándose de libros escritos contra Python 3.4, donde el bytecode era genérico y cada atributo costaba una búsqueda en un diccionario. Medir antes de optimizar no es una virtud abstracta: es la única forma de no aplicar una optimización que ya no optimiza.

CPython crea de antemano los enteros de −5 a 256 y los reutiliza. Por eso dos formas distintas de obtener 256 devuelven el mismo objeto, y 257 no:

Cuándo dos enteros son el mismo objeto
Expresión Resultado Motivo
256 is int("256") True 256 está en la caché
257 is int("257") False fuera de la caché, dos objetos
1000 is 1000 True dos literales del mismo bloque se pliegan en uno
"".join(["ho", "la"]) is "hola" False construido en ejecución, objeto nuevo

verificado en CPython 3.13

La tercera fila es la trampa: dos literales iguales en el mismo bloque de código se convierten en una sola constante al compilar. Eso no significa que la comparación con is funcione; significa que el resultado depende de dónde esté escrito el código.

Regla operativa: is sólo para None y para centinelas que tú creas. Para todo lo demás, ==.

Un millón de enteros en una lista no pesa ocho megabytes. Pesa ocho de punteros más veintiocho por objeto, salvo los que caigan en la caché:

Un millón de enteros, dos representaciones
Representación Por elemento Un millón
list[int] 39.9 B ~40 MB
array('i') 4.1 B ~4 MB

python mediciones/02-11-coste.py (extrapolado de 100 000)

Ahí está la razón de ser de numpy y del módulo array: no son «más rápidos» por magia, guardan el número sin la cabecera. Cuando el dato es numérico y homogéneo, el objeto —cabecera incluida— es el 70 % del coste.

Punteros frente a valores
list[int] — solo punteros → 8 B → 8 B → 8 B → 8 B → 8 B → 8 B = 8 B por elemento array('i') — valores crudos int 4 B int 4 B int 4 B int 4 B int 4 B int 4 B = 4 B por elemento

Cada flecha de la lista apunta a un objeto int de 28 B que el dibujo no muestra. Esa es toda la diferencia: la lista guarda direcciones, el array guarda el número.

  • Por debajo de cien mil objetos, el tamaño no decide nada. Un list de diccionarios de 5.000 filas son 1,5 MB: irrelevante.
  • Cuando el cuello es la red o el disco, la cabecera de 16 bytes da igual. Mide el programa completo antes de contar bytes.
  • Cuando la legibilidad manda, una dataclass con nombres de campo vale más que un array compacto. El manual vuelve sobre este intercambio en el capítulo 11.

Sin ejecutar, predice el resultado de estas cuatro expresiones y explica cada una en una línea:

a = 1000
b = 1000
a is b
c = 1000
d = int("1000")
c is d
e = ()
f = ()
e is f
g = [1]
h = [1]
g is h
Solución
  • a is b → True: dos literales iguales en el mismo bloque se pliegan en una constante.
  • c is d → False: int("1000") construye un objeto nuevo en ejecución, fuera de la caché.
  • e is f → True: la tupla vacía es un singleton en CPython.
  • g is h → False: dos listas literales son dos objetos distintos, aunque sean iguales.

El ejercicio no va de memorizar el resultado, sino de ver que is depende de la implementación y del contexto de compilación, así que no sirve como comparación de valores.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 1: el modelo de datos y por qué len() no es un método.
  • CPython 3.13: Include/cpython/object.h (PyObject, PyVarObject), Objects/longobject.c (caché de enteros), Objects/unicodeobject.c (cadena compacta).
  • Mediciones: mediciones/02-11-coste.py.
  • 02 · El modelo de datos: qué se puede hacer con un objeto una vez que sabes que lo es.
  • 04 · Mutabilidad: la única de las tres propiedades que puede cambiar.
  • 11 · Elegir estructura por coste: la aritmética completa de la cabecera aplicada a colecciones.