Listas y Tuplas

Las listas y tuplas son las secuencias ordenadas principales de Python. Las listas destacan cuando necesitas mutabilidad y métodos como sort; las tuplas señalan registros fijos y permiten la hashabilidad cuando el contenido lo permite.

Receta

nums = [3, 1, 4, 1, 5]
nums.sort()
unique_sorted = sorted(set(nums))
 
row = ("ada", 1842)
name, year = row
subset = nums[1:4:2]

Cuándo usar esto:

• Construir colecciones ordenadas con append/pop
• Devolver resultados de múltiples valores fijos desde funciones
• Slicing y desempaquetado en procesamiento de datos
• Mantener secuencias ordenadas con bisect

Ejemplo de Trabajo

import bisect
from typing import NamedTuple
 
class Event(NamedTuple):
    ts: float
    kind: str
 
def top_k(items: list[int], k: int) -> list[int]:
    return sorted(items, reverse=True)[:k]
 
def insert_timestamped(events: list[Event], ts: float, kind: str) -> None:
    bisect.insort(events, Event(ts, kind))
 
def partition(pred, items: list[object]) -> tuple[list[object], list[object]]:
    yes, no = [], []
    for item in items:
        (yes if pred(item) else no).append(item)
    return yes, no
 
if __name__ == "__main__":
    timeline: list[Event] = []
    insert_timestamped(timeline, 1.0, "start")
    insert_timestamped(timeline, 0.5, "warmup")
    print(timeline)
    print(top_k([4, 1, 7, 3], 2))

Lo que esto demuestra:

• NamedTuple da inmutabilidad de tupla con campos nombrados
• bisect.insort mantiene el orden ordenado para inserciones
• sorted devuelve una nueva lista sin mutar la original
• El retorno de tupla empaqueta dos listas relacionadas desde partition

Inmersión Profunda

Cómo Funciona

• Listas - Arrays dinámicos; sobreasignan para un append amortizado O(1).
• Tuplas - Tamaño fijo en la creación; menor huella de memoria que las listas.
• Slicing - start:stop:step crea una copia superficial de una porción de la secuencia.
• Ordenación - Timsort; estable; key= evita la decoración manual.
• bisect - Punto de inserción de búsqueda binaria para listas ordenadas.

list vs tuple

Notas de Python

# copia vs vista
a = [1, 2, 3]
b = a[:]       # copia superficial
c = list(a)    # igual
 
# desempaquetado de tupla con *
first, *middle, last = (1, 2, 3, 4)

Errores Comunes

• Copia superficial de lista anidada - Las listas internas todavía se comparten. Solución: copy.deepcopy.
• Ordenar tipos mixtos - TypeError en Python 3. Solución: Normalizar a valores comparables o usar key.
• bisect en lista no ordenada - Posición de inserción incorrecta silenciosamente. Solución: Mantener el invariante documentado o ordenar primero.
• += crea una nueva tupla - t += (1,) reasigna; no muta la tupla (inmutabilidad). Solución: Esperado - asignar una nueva tupla.
• Lista grande como miembro de conjunto - Las listas no son hashables. Solución: Convertir a tupla o usar un diccionario indexado por id.

Alternativas

Preguntas Frecuentes

Relacionado

• Inmutabilidad y Hashabilidad - tuplas hashables
• Diccionarios - cuando las listas se convierten en valores
• heapq y Colas de Prioridad - ordenar por prioridad
• Comprensiones y Expresiones Generadoras - construir listas

Versiones de Stack: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, y uv 0.6+.