Listas y tuplas

📐 Fundamento

Sintaxis básica:

vacia = []
numeros = [1, 2, 3, 4, 5]
mezclada = [1, "hola", 3.14, True]      # Python permite tipos mezclados
anidada = [[1, 2], [3, 4], [5, 6]]      # lista de listas

Notar:

• Corchetes [ ].
• Elementos separados por coma.
• Pueden contener cualquier cosa (incluso otras listas).
• En Python, mezclar tipos es legal pero no recomendado — confunde al lector.

Crear con range:

numeros = list(range(10))    # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
pares = list(range(0, 20, 2))  # [0, 2, 4, ..., 18]

Repetir:

ceros = [0] * 10            # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
ab = ["a", "b"] * 3          # ['a', 'b', 'a', 'b', 'a', 'b']

Importante con la repetición: funciona bien con valores inmutables. Con mutables (listas, dicts) hay un trampa que veremos después.

📐 Fundamento

Indexado. Empieza en 0.

notas = [7, 8, 6, 9, 10]
notas[0]    # 7  (primer elemento)
notas[3]    # 9  (cuarto)
notas[-1]   # 10 (último — índice negativo cuenta desde el final)
notas[-2]   # 9  (anteúltimo)
notas[10]   # IndexError: list index out of range

Por qué desde 0: convención heredada de C. Los primeros lenguajes (Fortran) empezaban en 1, pero la mayoría moderna usa 0. Acostumbrate, no vale pelearse.

Modificar:

notas[0] = 8
print(notas)    # [8, 8, 6, 9, 10]

Eso solo funciona si la posición existe. Para agregar nuevos al final:

notas.append(7)              # agrega al final
notas.insert(0, 5)            # inserta en posición 0
notas.extend([3, 4])          # agrega varios al final

Borrar:

del notas[0]                  # borra por índice
notas.remove(8)                # borra el primer 8 (por valor)
ultimo = notas.pop()           # quita y devuelve el último
primero = notas.pop(0)         # quita y devuelve el de posición 0

Tamaño:

len(notas)

📐 Fundamento

Una de las features más amadas de Python: extraer un trozo de una lista.

Sintaxis: lista[inicio:fin:paso]

• inicio (incluido), fin (excluido).
• Si omitís alguno, default: inicio del array, fin del array, paso 1.

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a[2:5]         # [2, 3, 4]
a[:3]          # [0, 1, 2]            (desde el inicio)
a[5:]          # [5, 6, 7, 8, 9]      (hasta el final)
a[:]           # copia completa
a[::2]         # [0, 2, 4, 6, 8]      (cada 2)
a[::-1]        # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]   (al revés)
a[-3:]         # [7, 8, 9]            (los últimos 3)

Slicing también modifica:

a[2:5] = [99, 99]
print(a)      # [0, 1, 99, 99, 5, 6, 7, 8, 9]   (reemplazó posiciones 2-4)

Slicing en cadenas (que son secuencias también):

nombre = "Maria"
nombre[1:3]      # "ar"
nombre[::-1]     # "airaM"  (reverso clásico)

Truco famoso: lista[::-1] es la forma idiomática de invertir.

📐 Fundamento

Diferencia importante: in-place vs new.

a = [3, 1, 2]
a.sort()             # modifica a → [1, 2, 3]
b = sorted(a)        # devuelve nueva, a no cambia

Convención en Python: las funciones que modifican devuelven None. Si esperabas el resultado, te confundís:

b = a.sort()        # ¡b es None!

sorted y reversed (sin método) devuelven copia. Métodos .sort() y .reverse() modifican.

Ordenar con criterio personalizado:

gente = ["Maria", "ana", "JOSE", "carlos"]
gente.sort()                              # alfabético: 'JOSE','Maria','ana','carlos' (Unicode)
gente.sort(key=str.lower)                 # alfabético sensato
gente.sort(key=len)                        # por longitud
gente.sort(key=len, reverse=True)         # invertido

key recibe una función que aplica a cada elemento para extraer la "clave de ordenamiento".

📐 Fundamento

Forma idiomática (mejor):

for nota in notas:
    print(nota)

for le pide a la lista uno por uno. Más limpio que for i in range(len(...)).

Cuando necesitás el índice:

for i, nota in enumerate(notas):
    print(f"Nota {i}: {nota}")

Recorrer dos listas en paralelo:

nombres = ["Ana", "Beto", "Carla"]
notas = [7, 8, 6]

for n, nt in zip(nombres, notas):
    print(f"{n}: {nt}")

zip empareja elementos en posición. Si las listas son de distinto largo, se detiene en la corta.

Buscar un elemento (forma estructurada):

def buscar(lista, x):
    for i, elem in enumerate(lista):
        if elem == x:
            return i
    return -1     # no encontrado

(Esto ya existe como lista.index(x), pero el ejercicio mental vale.)

📐 Fundamento

Una tupla es como una lista, pero no se puede modificar después de crearse.

Sintaxis:

punto = (3, 4)
sin_parentesis = 3, 4         # también es tupla
una_sola = (5,)                # ¡coma obligatoria!
vacia = ()

Operaciones: las mismas que listas excepto las que modifican.

punto[0]           # 3 — lectura sí
len(punto)         # 2
punto[0] = 99      # ❌ TypeError: 'tuple' object does not support item assignment

Por qué existen las tuplas:

1. Datos que no deben cambiar (coordenadas, fechas, registros). Garantía de inmutabilidad.
2. Más rápidas y compactas que listas (menos overhead).
3. Pueden ser claves de diccionario (las listas no, porque son mutables).
4. Múltiples valores de retorno de funciones — pattern muy usado.

def divmod_propio(a, b):
    return a // b, a % b      # devuelve tupla

q, r = divmod_propio(17, 5)   # desempaca

Desempacado:

x, y = (3, 4)            # x=3, y=4
a, b, c = [1, 2, 3]      # también funciona con listas

# Intercambio elegante:
a, b = b, a              # sin variable temporal

Tupla con * para "el resto":

primero, *resto = [1, 2, 3, 4, 5]
print(primero)   # 1
print(resto)     # [2, 3, 4, 5]

Cuándo lista, cuándo tupla:

📐 Fundamento

La feature más pythónica de Python. Permite construir una lista a partir de otra en una sola línea legible.

Sintaxis básica:

[expresion for elemento in iterable]

Ejemplos:

# Cuadrados de 1 a 10
cuadrados = [x ** 2 for x in range(1, 11)]
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# Mayúsculas
nombres = ["ana", "beto", "carla"]
mayus = [n.upper() for n in nombres]
# ["ANA", "BETO", "CARLA"]

# Equivalente con bucle (peor):
mayus = []
for n in nombres:
    mayus.append(n.upper())

Con filtro:

[expresion for elem in iterable if condicion]

# Pares al cuadrado
[x ** 2 for x in range(20) if x % 2 == 0]
# [0, 4, 16, 36, 64, 100, 144, 196, 256, 324]

Anidadas (matrices):

matriz = [[i * j for j in range(5)] for i in range(5)]

Con condicional ternario en la expresión:

# Etiquetar como par/impar
etiquetas = ["par" if x % 2 == 0 else "impar" for x in range(10)]

Cuándo NO usar comprehension. Si la lógica es compleja (varios if/else anidados, side-effects), un for clásico es más legible. La regla es: una línea legible es mejor que tres clásicas; tres líneas crípticas son peor que ocho clásicas.

📐 Fundamento

Aunque Python prefiere comprehensions, conviene conocer las primitivas funcionales — son más comunes en otros lenguajes y siguen apareciendo.

map(función, iterable) — aplica función a cada elemento.

nombres = ["ana", "beto"]
mayus = list(map(str.upper, nombres))   # ["ANA", "BETO"]

# Equivale a:
mayus = [n.upper() for n in nombres]

filter(función, iterable) — deja solo los que cumplen.

nums = [1, 2, 3, 4, 5, 6]
pares = list(filter(lambda x: x % 2 == 0, nums))
# [2, 4, 6]

# Equivale a:
pares = [x for x in nums if x % 2 == 0]

reduce(función, iterable) — acumula. Está en functools.

from functools import reduce
nums = [1, 2, 3, 4, 5]
total = reduce(lambda a, b: a + b, nums)   # 15

# Equivale a:
total = sum(nums)

Lambdas. Funciones anónimas inline:

cuadrado = lambda x: x ** 2
print(cuadrado(5))    # 25

Útiles cuando una función es chiquita y se usa solo una vez (en map, filter, sort key=).

En la práctica: Python prefiere comprehensions. map y filter aparecen en código de otros lenguajes (Java streams, JavaScript, Lisp). Conocelos pero no los uses obsesivamente en Python.