Saltearse al contenido

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.

Todas las secuencias se manejan igual y cuestan distinto; la sintaxis no te avisa de cuál estás usando.

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.

1 000 elementos, tres secuencias
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

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:

Sacar 1 000 elementos por el principio
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.

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:

Cortar 500 000 elementos
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.

a = [1, 2]
b = a + [3] # lista nueva
a # [1, 2] — intacta
c = a * 3 # [1, 2, 1, 2, 1, 2]
d = [a] * 3 # tres referencias a la MISMA lista

La ú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.

range, str y bytes cumplen el mismo contrato y se comportan distinto por dentro:

r = range(1_000_000)
len(r) # 1000000
r[999_999] # 999999
bytearray(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.

  • 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, deque no los tiene: d[500] recorre. Para acceso por posición, list.
  • Si el dato es homogéneo y numérico, la respuesta no es array sino numpy, que además vectoriza las operaciones. array sólo gana cuando no puedes añadir dependencias.

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.

  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 2: An Array of Sequences.
  • CPython 3.13: Objects/listobject.c (slicing y list_ass_slice).
  • Mediciones: mediciones/02-01-04-secuencias.py.
  • 02 · list por dentro: por qué el slicing copia y el append es barato.
  • 04 · array y memoryview: cómo cortar sin copiar.
  • 11 · Elección por coste: la tabla maestra que cierra la parte.