Secuencias
Python tiene nueve secuencias en la biblioteca estándar y todas comparten el mismo contrato: acceso por índice, longitud, slicing, iteración. Elegir entre ellas no es elegir sintaxis, porque la sintaxis es idéntica. Es elegir dónde vive el dato y qué operación sale gratis.
En una línea
Sección titulada «En una línea»Todas las secuencias se manejan igual y cuestan distinto; la sintaxis no te avisa de cuál estás usando.
El mapa
Sección titulada «El mapa»Fluent Python separa las secuencias en dos familias, y la distinción ordena todo lo demás:
Planas — guardan los valores directamente: str, bytes, bytearray, array.array, memoryview.
Contenedoras — guardan referencias a objetos: list, tuple, deque.
Esa diferencia es la del capítulo 01: una list[int] guarda ocho bytes de puntero por elemento y el entero vive aparte; un array('i') guarda cuatro bytes de valor y no hay objeto.
| Secuencia | Memoria | Por elemento |
|---|---|---|
list[int] |
8 056 B | 8.0 B (punteros) |
array('i') |
4 200 B | 4.1 B (valores) |
deque |
8 680 B | 7.9 B (bloques + punteros) |
python mediciones/02-01-04-secuencias.py
Qué cuesta cada operación
Sección titulada «Qué cuesta cada operación»| Operación | list |
deque |
array |
|---|---|---|---|
Acceso por índice a[i] |
O(1) | O(n) | O(1) |
append / pop() al final |
O(1)* | O(1) | O(1)* |
insert(0, x) / pop(0) |
O(n) | O(1) | O(n) |
Pertenencia x in a |
O(n) | O(n) | O(n) |
Slicing a[i:j] |
O(k) copia | — | O(k) copia |
| Memoria por elemento | 8 B | 8 B + bloque | 1–8 B |
* amortizado: la lista sobreasigna, el array también.
La fila de pop(0) es la que más se ignora:
| Operación | Total | Por operación |
|---|---|---|
list.pop(0) |
11.56 ms | 11.6 µs |
deque.popleft() |
0.03 ms | 0.03 µs |
python mediciones/02-01-04-secuencias.py
Cuatrocientas veces. list.pop(0) mueve todos los punteros una posición a la izquierda; deque sólo mueve un índice de bloque. Si el código hace while cola: x = cola.pop(0), tiene un O(n²) disfrazado de cola.
El slicing copia, siempre
Sección titulada «El slicing copia, siempre»a[i:j] devuelve una secuencia nueva con los elementos copiados. Para una lista de un millón, cortar por la mitad copia cuatro megabytes:
| Expresión | Coste | Copia |
|---|---|---|
lista[:500_000] |
3 476 µs | Sí: 4 MB |
memoryview(array)[:500_000] |
0.24 µs | No |
python mediciones/02-01-04-secuencias.py
Catorce mil veces de diferencia, y la razón es que memoryview no copia: devuelve una vista sobre los mismos bytes. Es la herramienta del capítulo 04, y la única forma de «cortar» sin pagar.
En el código normal, la consecuencia práctica es que pasar trozos grandes a funciones crea copias invisibles. procesar(datos[1000:]) copia; procesar(datos, desde=1000) no.
+ y * crean objetos nuevos
Sección titulada «+ y * crean objetos nuevos»a = [1, 2]b = a + [3] # lista nuevaa # [1, 2] — intacta
c = a * 3 # [1, 2, 1, 2, 1, 2]d = [a] * 3 # tres referencias a la MISMA listaLa última línea es la trampa del capítulo 05: multiplicar una lista que contiene mutables repite la referencia, no el contenido. Y a + b en un bucle es O(n²) aunque parezca una concatenación barata.
Secuencias que no parecen secuencias
Sección titulada «Secuencias que no parecen secuencias»range, str y bytes cumplen el mismo contrato y se comportan distinto por dentro:
r = range(1_000_000)len(r) # 1000000r[999_999] # 999999bytearray(len(r)) # 1 MB reservado de verdad (bytes(r) fallaría: los valores pasan de 255)Un range no guarda un millón de números: guarda inicio, fin y paso, y calcula cada valor al pedirlo. Ocupa 48 bytes. Por eso for i in range(10**9) es instantáneo al empezar y no consume memoria, mientras que list(range(10**9)) no cabe en ningún ordenador.
Es el primer ejemplo de la diferencia entre materializar y generar, que la Parte III desarrolla con generadores. La regla que se deduce: si sólo vas a recorrer, no construyas la secuencia.
La trampa
Sección titulada «La trampa»Cuándo NO cambiar de secuencia
Sección titulada «Cuándo NO cambiar de secuencia»- Si la colección tiene menos de mil elementos, la diferencia entre O(1) y O(n) se mide en microsegundos. Elige por legibilidad.
- Si necesitas índices,
dequeno los tiene:d[500]recorre. Para acceso por posición,list. - Si el dato es homogéneo y numérico, la respuesta no es
arraysinonumpy, que además vectoriza las operaciones.arraysólo gana cuando no puedes añadir dependencias.
Ejercicio
Sección titulada «Ejercicio»Una función recibe una lista de un millón de registros y devuelve los últimos mil. Alguien escribe:
def ultimos(registros): return registros[-1000:]¿Está bien? ¿Y si la función se llamara una vez por segundo con la misma lista?
Solución
El código es correcto: registros[-1000:] copia sólo mil referencias, no el millón. El slicing negativo no recorre la lista entera, calcula el índice inicial y copia desde ahí.
El problema aparece si la función hace algo más caro, como registros[-1000:][::-1] (dos copias) o sorted(registros)[-1000:] (ordena un millón para devolver mil). Ahí la solución es heapq.nlargest(1000, registros), que es O(n log k) en lugar de O(n log n).
La lección: el slicing no es el problema por defecto; hay que mirar qué se hace con el resultado.
Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulo 2: An Array of Sequences.
- CPython 3.13:
Objects/listobject.c(slicing ylist_ass_slice). - Mediciones:
mediciones/02-01-04-secuencias.py.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 02 ·
listpor dentro: por qué el slicing copia y el append es barato. - 04 ·
arrayymemoryview: cómo cortar sin copiar. - 11 · Elección por coste: la tabla maestra que cierra la parte.