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.
En una línea
Sección titulada «En una línea»Python no tiene tipos primitivos. Tiene objetos con cabecera, y la cabecera se paga siempre.
La tríada: identidad, tipo, valor
Sección titulada «La tríada: identidad, tipo, valor»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 valorid() 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.
Medido: el precio de cada valor
Sección titulada «Medido: el precio de cada valor»| 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.
Por dentro: qué hay antes del dato
Sección titulada «Por dentro: qué hay antes del dato»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 cabeceraDe 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.
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.
| 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.
La caché de enteros
Sección titulada «La caché de enteros»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:
| 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, ==.
Por qué esto importa en producción
Sección titulada «Por qué esto importa en producción»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é:
| 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.
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.
La trampa
Sección titulada «La trampa»Cuándo NO pensar en esto
Sección titulada «Cuándo NO pensar en esto»- Por debajo de cien mil objetos, el tamaño no decide nada. Un
listde 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
dataclasscon nombres de campo vale más que unarraycompacto. El manual vuelve sobre este intercambio en el capítulo 11.
Ejercicio
Sección titulada «Ejercicio»Sin ejecutar, predice el resultado de estas cuatro expresiones y explica cada una en una línea:
a = 1000b = 1000a is b
c = 1000d = int("1000")c is d
e = ()f = ()e is f
g = [1]h = [1]g is hSolució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.
Referencias
Sección titulada «Referencias»- 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.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 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.