Python · Lección 13 de 27

Métodos de listas

En la lección 08 aprendiste a crear y acceder a listas. Ahora vas a dominar TODOS los métodos para modificarlas, ordenarlas, buscar en ellas y transformarlas con comprehensions avanzadas, enumerate, zip, map y filter.

90–110 min Prerrequisitos: 08 Listas, 12 Métodos de strings

Concepto teórico

sort() vs sorted() — la diferencia más importante

Esta es probablemente la fuente de bugs más común con listas:

lista.sort() — ordena la lista in-place (modifica la original) y devuelve None. Si hacés resultado = lista.sort(), resultado es None y tu lista original cambió.
sorted(lista) — devuelve una nueva lista ordenada sin modificar la original. Esto es lo que querés el 90% de las veces.

Ambas aceptan dos parámetros opcionales: key (función que transforma cada elemento para comparar) y reverse=True (orden descendente).

Bug clásico: lista_ordenada = mi_lista.sort() → lista_ordenada es None y mi_lista ya se modificó. Si querés una copia ordenada sin tocar la original, usá sorted(mi_lista).

Métodos de modificación

Método	Qué hace	Devuelve	Uso típico
`.append(x)`	Agrega x al final	`None`	Acumular resultados en un loop
`.insert(i, x)`	Inserta x en posición i	`None`	Agregar al inicio: `.insert(0, x)`
`.extend(iterable)`	Agrega todos los elementos del iterable	`None`	Merge de dos listas
`.remove(x)`	Elimina primera ocurrencia de x	`None`	Eliminar por valor (ValueError si no existe)
`.pop(i)`	Elimina y devuelve elemento en i	El elemento	Sin argumento: el último. Con índice: el específico
`.clear()`	Vacía la lista	`None`	Resetear datos
`.reverse()`	Invierte in-place	`None`	Invertir orden (también `[::-1]`)
`.sort()`	Ordena in-place	`None`	Cuando no necesitás la original

Regla mnemotécnica: los métodos que MODIFICAN la lista devuelven None (append, sort, reverse, remove, insert, extend, clear). Los que NO modifican devuelven un valor (index, count, copy). Esta es una decisión de diseño de Python para evitar que encadenes operaciones destructivas.

Métodos de consulta

Método	Qué hace	Devuelve
`.index(x)`	Posición de la primera ocurrencia	`int` (ValueError si no existe)
`.count(x)`	Cuántas veces aparece x	`int`
`.copy()`	Copia superficial (shallow copy)	Nueva lista

Copia superficial vs profunda

Cuando hacés b = a con listas, b no es una copia — es una referencia a la misma lista. Si modificás b, a también cambia. Para una copia independiente necesitás .copy() o list(a).

Pero cuidado: .copy() es superficial (shallow). Si la lista contiene listas anidadas, los elementos internos siguen siendo referencias. Para una copia 100% independiente de estructuras anidadas, necesitás import copy; copy.deepcopy(a).

Herramientas funcionales: enumerate, zip, map, filter

Python tiene funciones incorporadas que se combinan con listas para patrones muy potentes:

enumerate(lista, start=0) — devuelve pares (índice, elemento). Reemplaza el anti-patrón for i in range(len(lista)).
zip(lista1, lista2) — recorre dos listas en paralelo. Esencial para combinar datos relacionados.
map(función, lista) — aplica una función a cada elemento. Similar a comprehension pero funcional.
filter(función, lista) — filtra elementos que cumplen una condición.

Tip profesional: enumerate() es la forma pythónica de obtener índice + valor. NUNCA escribas for i in range(len(lista)): elemento = lista[i]. Escribí for i, elemento in enumerate(lista):. Es más legible, más seguro y más rápido.

List comprehensions avanzadas

En la lección 08 viste el básico: [expr for x in lista if cond]. Ahora vamos más allá:

Comprehension anidada: [x for sublista in lista for x in sublista] — "aplanar" listas de listas
Con if/else: [expr_true if cond else expr_false for x in lista] — transformar cada elemento condicionalmente
Múltiples condiciones: [x for x in lista if cond1 and cond2]

En pandas: df.apply(lambda x: ...) es la versión DataFrame de map(). df[df["col"] > 100] es la versión de filter(). df.reset_index() te da algo similar a enumerate(). Todo lo que aprendés acá se traslada directamente.

Ejemplos explicados paso a paso

Ejemplo 1: sort() vs sorted() en acción

ejemplo_01_sort.pyPython

scores = [720, 590, 810, 645, 680, 750, 520]
print(f"Original: {scores}")

# sorted() — devuelve NUEVA lista, no toca la original
asc = sorted(scores)
desc = sorted(scores, reverse=True)
print(f"sorted() asc: {asc}")
print(f"sorted() desc: {desc}")
print(f"Original intacta: {scores}")

# sort() — modifica la lista, devuelve None
resultado = scores.sort()
print(f"\nDespués de .sort(): {scores}")
print(f"¿Qué devolvió sort()? {resultado}")  # None!

# Ordenar con key (criterio personalizado)
nombres = ["Martínez", "García", "López", "Pérez", "Ana"]
por_largo = sorted(nombres, key=len)  # por largo del nombre
print(f"\nPor largo: {por_largo}")

# Ordenar lista de tuplas por segundo elemento
clientes = [("García", 720), ("López", 680), ("Pérez", 810), ("Sosa", 590)]
por_score = sorted(clientes, key=lambda c: c[1], reverse=True)
print(f"Por score desc: {por_score}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: append, extend, insert — construir listas dinámicamente

ejemplo_02_construir.pyPython

# Construir una lista de resultados procesando datos
montos_crudos = ["$1,500", "N/A", "$3,200", "", "$820", "error", "$4,100"]

validos = []
errores = []

for m in montos_crudos:
    m = m.strip()
    if m.startswith("$"):
        valor = float(m.replace("$", "").replace(",", ""))
        validos.append(valor)        # append: agrega al final
    else:
        errores.append(m)

print(f"Válidos ({len(validos)}): {validos}")
print(f"Errores ({len(errores)}): {errores}")
print(f"Total válidos: ${sum(validos):,.0f}")

# insert: agregar un encabezado al inicio
reporte = validos.copy()
reporte.insert(0, "--- MONTOS ---")
print(f"\nCon encabezado: {reporte}")

# extend: combinar dos listas
lote_1 = [100, 200, 300]
lote_2 = [400, 500]
lote_1.extend(lote_2)     # modifica lote_1
print(f"\nExtend: {lote_1}")

# Diferencia con append:
lote_3 = [100, 200]
lote_3.append([300, 400])  # agrega la LISTA como un solo elemento
print(f"Append lista: {lote_3}")  # [100, 200, [300, 400]] ← ojo!

Hacé clic en ▶ Ejecutar

Ejemplo 3: enumerate y zip — los aliados del for

ejemplo_03_enumerate_zip.pyPython

# enumerate: índice + valor sin range(len())
clientes = ["García", "López", "Martínez", "Pérez"]
scores = [720, 680, 590, 810]

# ❌ Anti-patrón (funciona pero es feo)
# for i in range(len(clientes)):
#     print(f"{i+1}. {clientes[i]}: {scores[i]}")

# ✅ Pythónico con enumerate + zip
print("=== Ranking ===")
for i, (nombre, score) in enumerate(zip(clientes, scores), start=1):
    medalla = "🥇" if i == 1 else "🥈" if i == 2 else "🥉" if i == 3 else "  "
    print(f"  {medalla} {i}. {nombre:<12} Score: {score}")

# zip con 3 listas
ciudades = ["BsAs", "Córdoba", "Rosario", "Mendoza"]
saldos = [150000, 320000, 45000, 890000]
print(f"\n=== Detalle ===")
for nombre, ciudad, saldo in zip(clientes, ciudades, saldos):
    print(f"  {nombre} ({ciudad}): ${saldo:,}")

# zip trunca al más corto
corta = [1, 2]
larga = [10, 20, 30, 40]
print(f"\nZip desigual: {list(zip(corta, larga))}")  # solo 2 pares

# dict desde zip (patrón muy común)
scoring = dict(zip(clientes, scores))
print(f"Dict: {scoring}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: map() y filter() — programación funcional

ejemplo_04_map_filter.pyPython

precios = [1200, 3500, 800, 15000, 4200, 950, 22000]

# map: aplicar función a cada elemento
con_iva = list(map(lambda p: round(p * 1.21), precios))
print(f"Con IVA: {con_iva}")

# Equivalente con comprehension (más pythónico):
con_iva_2 = [round(p * 1.21) for p in precios]
print(f"Con IVA (comp): {con_iva_2}")

# filter: quedarse con los que cumplen condición
caros = list(filter(lambda p: p > 3000, precios))
print(f"\nCaros (>$3K): {caros}")

# Equivalente con comprehension:
caros_2 = [p for p in precios if p > 3000]

# Combinando map + filter (primero filtrar, después transformar)
caros_con_iva = list(map(lambda p: round(p * 1.21), filter(lambda p: p > 3000, precios)))
print(f"Caros + IVA: {caros_con_iva}")

# Más legible con comprehension:
caros_con_iva_2 = [round(p * 1.21) for p in precios if p > 3000]
print(f"Comp equiv: {caros_con_iva_2}")

# map con función nombrada (no lambda)
nombres = ["  garcía  ", "LÓPEZ", "  martínez  "]
limpios = list(map(str.strip, nombres))
titulados = list(map(str.title, limpios))
print(f"\nLimpios: {limpios}")
print(f"Titulados: {titulados}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Comprehensions avanzadas

ejemplo_05_comp_avanzada.pyPython

# Comprehension con if/else (transformar condicionalmente)
scores = [720, 590, 810, 645, 680, 520, 750]
categorias = ["Alto" if s >= 700 else "Medio" if s >= 600 else "Bajo" for s in scores]
print(f"Categorías: {categorias}")

# Aplanar lista de listas
listas_anidadas = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
plana = [x for sublista in listas_anidadas for x in sublista]
print(f"\nAplanada: {plana}")

# Comprehension con múltiples condiciones
numeros = range(1, 51)
# Múltiplos de 3 que también son pares
filtrados = [n for n in numeros if n % 3 == 0 and n % 2 == 0]
print(f"Múltiplos de 3 y pares (1-50): {filtrados}")

# Comprehension con expresión compleja
datos = [("García", 720, 150000), ("López", 680, 320000), ("Pérez", 810, 890000)]
resumen = [
    f"{n}: {'Premium' if s>=700 else 'Estándar'} (${sal:,})"
    for n, s, sal in datos
]
print(f"\nResumen:")
for r in resumen:
    print(f"  {r}")

# Crear diccionarios con comprehension desde lista de tuplas
scoring = {nombre: score for nombre, score, _ in datos if score >= 700}
print(f"\nPremium: {scoring}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Método/Función	Modifica original?	Devuelve	Cuándo usar
`.sort()`	Sí	`None`	No necesitás la original
`sorted()`	No	Nueva lista	Necesitás mantener original (90% de los casos)
`.append(x)`	Sí	`None`	Agregar un elemento al final
`.extend(iter)`	Sí	`None`	Agregar TODOS los elementos de otro iterable
`.insert(i, x)`	Sí	`None`	Agregar en posición específica
`.pop(i)`	Sí	Elemento	Eliminar y usar el valor
`.remove(x)`	Sí	`None`	Eliminar por valor (error si no existe)
`enumerate()`	—	Iterador	Obtener índice + valor
`zip()`	—	Iterador	Recorrer listas en paralelo
`map(f, lista)`	—	Iterador	Aplicar función a cada elem
`filter(f, lista)`	—	Iterador	Filtrar por condición

Ejercicios

Nivel 1 · Básico

Ejercicio 1: sorted() con reverse

Dada ventas = [45000, 72000, 38000, 91000, 55000], imprimí la lista ordenada de mayor a menor SIN modificar la original. Debe incluir [91000.

ejercicio_01.pyDebe incluir "[91000"

ventas = [45000, 72000, 38000, 91000, 55000]

# Ordená descendente sin modificar la original:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: append para acumular

Empezá con pares = []. Recorré los números del 1 al 20 y agregá con .append() solo los pares. Imprimí la lista. Debe incluir 20.

ejercicio_02.pyDebe incluir "20"

pares = []

# Recorré 1 a 20 y appendeá los pares:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: enumerate para numeración

Dada productos = ["Notebook", "Mouse", "Teclado", "Monitor"], imprimilos numerados empezando en 1 usando enumerate. Debe incluir 3. Teclado.

ejercicio_03.pyDebe incluir "3. Teclado"

productos = ["Notebook", "Mouse", "Teclado", "Monitor"]

# Enumerá desde 1:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: zip para combinar datos

Tenés nombres = ["García","López","Pérez"] y saldos = [150000, 320000, 890000]. Creeá un diccionario con dict(zip(...)) e imprimilo. Debe incluir 320000.

ejercicio_04.pyDebe incluir "320000"

nombres = ["García", "López", "Pérez"]
saldos = [150000, 320000, 890000]

# Creá dict con zip:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Comprehension con if/else

Dada scores = [720, 590, 810, 645, 520, 750], creá una lista que tenga "Alto" si >= 700, "Medio" si >= 600, "Bajo" si no. Debe incluir Bajo.

ejercicio_05.pyDebe incluir "Bajo"

scores = [720, 590, 810, 645, 520, 750]

# Comprehension con if/else:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: sorted con key lambda

Dada clientes = [("García",720), ("López",680), ("Pérez",810), ("Sosa",590)], ordenalos por score (segundo elemento) de mayor a menor. Imprimí el top 1. Debe incluir Pérez.

ejercicio_06.pyDebe incluir "Pérez"

clientes = [("García", 720), ("López", 680), ("Pérez", 810), ("Sosa", 590)]

# Ordená por score descendente:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Aplanar lista de listas

Dada cuentas = [[150000, 5000], [320000], [45000, 890000, 72000]], aplaná en una sola lista y calculá el total. Debe incluir 1482000.

ejercicio_07.pyDebe incluir "1482000"

cuentas = [[150000, 5000], [320000], [45000, 890000, 72000]]

# Aplana y sumá:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Pipeline con map y filter

Dada montos_str = ["$1,500", "$800", "$3,200", "$12,000", "$950"]: (1) limpiá símbolos con map, (2) convertí a float, (3) filtrá > 1000. Imprimí la suma de los filtrados. Debe incluir 16700.

ejercicio_08.pyDebe incluir "16700"

montos_str = ["$1,500", "$800", "$3,200", "$12,000", "$950"]

# Limpiá, convertí, filtrá y sumá:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Reporte con enumerate + zip + f-strings

Combina clientes = ["García","López","Pérez"], scores = [720,680,810] y saldos = [150000,320000,890000] en un reporte numerado con emojis (🟢 score>=700, 🔴 si no). Debe incluir Total:.

ejercicio_09.pyDebe incluir "Total:"

clientes = ["García", "López", "Pérez"]
scores = [720, 680, 810]
saldos = [150000, 320000, 890000]

# Reporte con enumerate + zip:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Procesamiento completo de datos crudos

Tenés datos crudos de un CSV: registros = ["García|720|$150,000", "López|680|$320,000", "Martínez|590|$45,000", "Pérez|810|$890,000"]. Procesá cada uno: (1) split, (2) convertir tipos, (3) crear lista de tuplas (nombre, score_int, saldo_float), (4) ordená por saldo descendente, (5) imprimí top 3 con formato. Debe incluir Top 3.

ejercicio_10_desafio.pyDebe incluir "Top 3"

registros = [
    "García|720|$150,000",
    "López|680|$320,000",
    "Martínez|590|$45,000",
    "Pérez|810|$890,000",
]

# Procesá, ordená e imprimí:
print("=== Top 3 por saldo ===")

Hacé clic en ▶ Ejecutar

Resumen y conexión

.sort() modifica in-place y devuelve None. sorted() devuelve nueva lista sin modificar.
.append() agrega uno, .extend() agrega muchos, .insert(i, x) en posición específica.
enumerate() reemplaza range(len()). zip() combina listas en paralelo.
map() transforma, filter() filtra — pero las comprehensions son más pythónicas.
Comprehensions avanzadas: [expr if cond else expr for x in lista] y [x for sub in lista for x in sub].
Cuidado con las referencias: b = a NO copia la lista. Usá .copy().

En la siguiente lección (14 · Métodos de diccionarios) vas a profundizar en los métodos de diccionarios: .setdefault(), .update() avanzado, defaultdict, Counter y patrones profesionales.

Recursos: Python docs — Lists · enumerate · zip

Hecho con ❤️ por Rodri Gonzalez