Python · Lección 08 de 27

Listas

Las listas son la estructura de datos más versátil de Python. Son colecciones ordenadas y modificables que te permiten guardar, acceder y transformar múltiples valores bajo un solo nombre. Son el paso previo a los DataFrames de pandas.

90–120 min Prerrequisitos: 05 Operaciones, 06 Condicionales

Concepto teórico

¿Qué es una lista?

Una lista es una colección ordenada y modificable (mutable) de elementos. Se crea con corchetes [] y los elementos se separan por comas. Puede contener cualquier tipo de dato — incluso mezclarlos, aunque no es recomendable en la práctica.

numeros = [10, 20, 30, 40, 50]          # lista de ints
nombres = ["García", "López", "Pérez"]   # lista de strings
mixta = [1, "hola", True, 3.14, None]   # tipos mezclados (evitalo)
vacia = []                               # lista vacía
anidada = [[1, 2], [3, 4], [5, 6]]      # lista de listas

¿Por qué son tan importantes? Porque en análisis de datos, los datos vienen en colecciones: una lista de clientes, una lista de transacciones, una lista de precios. Antes de aprender pandas (que es el siguiente nivel), necesitás dominar listas. Un DataFrame de pandas es, en esencia, un diccionario de listas.

Índices: acceder a elementos

Cada elemento tiene una posición (índice) que empieza en 0, no en 1. Esto es universal en programación y es lo que más confunde a los principiantes.

Elemento	`"García"`	`"López"`	`"Pérez"`	`"Sosa"`	`"Luna"`
Índice positivo	`0`	`1`	`2`	`3`	`4`
Índice negativo	`-5`	`-4`	`-3`	`-2`	`-1`

Los índices negativos cuentan desde el final: -1 es el último elemento, -2 el anteúltimo, etc. Son extremadamente útiles cuando querés acceder al final sin saber cuántos elementos hay.

Error clásico: IndexError. Si intentás acceder a un índice que no existe (lista[10] en una lista de 5 elementos), Python da IndexError: list index out of range. Siempre verificá con len(lista) antes de acceder a índices variables.

Slicing: extraer sublistas

El slicing permite extraer una porción de la lista con la sintaxis lista[inicio:fin:paso]:

inicio — índice donde empieza (incluido). Default: 0
fin — índice donde termina (excluido). Default: largo de la lista
paso — de a cuántos elementos avanzar. Default: 1

Ejemplos con nums = [10, 20, 30, 40, 50, 60, 70]:

Slice	Resultado	Significado
`nums[1:4]`	`[20, 30, 40]`	Del índice 1 al 3 (4 excluido)
`nums[:3]`	`[10, 20, 30]`	Los primeros 3
`nums[3:]`	`[40, 50, 60, 70]`	Del índice 3 al final
`nums[-3:]`	`[50, 60, 70]`	Los últimos 3
`nums[::2]`	`[10, 30, 50, 70]`	De a 2 (posiciones pares)
`nums[::-1]`	`[70, 60, 50, 40, 30, 20, 10]`	Invertida

Un dato importante: el slicing nunca da IndexError. Si pedís nums[100:200] en una lista de 7 elementos, simplemente devuelve una lista vacía [].

Mutabilidad: las listas se pueden modificar

A diferencia de los strings (inmutables) y las tuplas (inmutables), las listas son mutables: podés agregar, eliminar, reordenar y modificar elementos después de crearlas. Esto es poderoso pero también peligroso — si dos partes de tu código referencian la misma lista, una modificación afecta a ambas.

Analogía: una lista es como una planilla de Excel donde podés insertar filas, borrar filas, reordenar y cambiar valores. Un string es como un PDF protegido — lo podés leer pero no modificar directamente.

Funciones útiles con listas

Función	Qué hace	Ejemplo	Resultado
`len()`	Cantidad de elementos	`len([1,2,3])`	`3`
`sum()`	Suma (solo números)	`sum([10,20,30])`	`60`
`min()`	Valor mínimo	`min([5,2,8])`	`2`
`max()`	Valor máximo	`max([5,2,8])`	`8`
`sorted()`	Devuelve copia ordenada	`sorted([3,1,2])`	`[1,2,3]`
`list()`	Convierte a lista	`list("hola")`	`['h','o','l','a']`
`x in lista`	Verifica pertenencia	`3 in [1,2,3]`	`True`

Tip: sorted() devuelve una NUEVA lista sin modificar la original. lista.sort() modifica la lista in-place y devuelve None. Es una diferencia crucial que genera bugs si no la entendés.

En análisis de datos: cuando trabajás con pandas, un DataFrame tiene columnas que son Series (similares a listas). Las operaciones de slicing, filtrado y funciones como sum(), min(), max() que aprendés acá se trasladan directamente a pandas. Dominá listas y pandas va a ser natural.

Ejemplos explicados paso a paso

Ejemplo 1: Crear, acceder y slicing

Las operaciones más comunes: crear una lista, acceder por índice y extraer porciones con slicing.

ejemplo_01_acceso.pyPython

# Crear lista de clientes
clientes = ["García", "López", "Martínez", "Pérez", "Fernández", "Sosa", "Luna"]
print(f"Lista completa: {clientes}")
print(f"Cantidad: {len(clientes)}")

# Acceso por índice
print(f"\nPrimero (índice 0): {clientes[0]}")
print(f"Tercero (índice 2): {clientes[2]}")
print(f"Último (índice -1): {clientes[-1]}")
print(f"Anteúltimo (índice -2): {clientes[-2]}")

# Slicing
print(f"\nPrimeros 3: {clientes[:3]}")
print(f"Del 2 al 4: {clientes[2:5]}")
print(f"Últimos 3: {clientes[-3:]}")
print(f"De a 2: {clientes[::2]}")
print(f"Invertida: {clientes[::-1]}")

# Verificar pertenencia
print(f"\n¿'López' está? {'López' in clientes}")
print(f"¿'Rodríguez' está? {'Rodríguez' in clientes}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: Modificar listas — agregar, eliminar, cambiar

La mutabilidad de las listas te permite construir datasets dinámicamente.

ejemplo_02_modificar.pyPython

saldos = [150000, 320000, 45000, 890000]
print(f"Original: {saldos}")

# Agregar al final
saldos.append(72000)
print(f"Después de append: {saldos}")

# Insertar en posición específica
saldos.insert(0, 500000)  # Al inicio
print(f"Después de insert: {saldos}")

# Extender con otra lista
nuevos = [33000, 15000]
saldos.extend(nuevos)
print(f"Después de extend: {saldos}")

# Modificar por índice
saldos[0] = 550000  # Cambiar el primer elemento
print(f"Después de modificar [0]: {saldos}")

# Eliminar
saldos.remove(45000)  # Elimina por VALOR (primera ocurrencia)
print(f"Después de remove(45000): {saldos}")

eliminado = saldos.pop()  # Elimina y devuelve el ÚLTIMO
print(f"pop() devolvió: {eliminado}, lista: {saldos}")

eliminado_2 = saldos.pop(0)  # Elimina y devuelve el de índice 0
print(f"pop(0) devolvió: {eliminado_2}")

print(f"\nFinal: {saldos}")
print(f"Cantidad: {len(saldos)}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Funciones estadísticas con listas

Calculá estadísticas básicas de una cartera de clientes — esto es exactamente lo que harías con pandas, pero primero con listas puras.

ejemplo_03_estadisticas.pyPython

# Cartera de saldos (en pesos)
saldos = [150000, 320000, 45000, 890000, 72000, 210000, 15000, 530000]

print(f"=== Análisis de cartera ===")
print(f"Clientes:  {len(saldos)}")
print(f"Total:     ${sum(saldos):>12,}")
print(f"Promedio:  ${sum(saldos)/len(saldos):>12,.0f}")
print(f"Máximo:    ${max(saldos):>12,}")
print(f"Mínimo:    ${min(saldos):>12,}")
print(f"Rango:     ${max(saldos) - min(saldos):>12,}")

# Ordenar sin modificar la original
ordenados = sorted(saldos)
print(f"\nOrdenados: {ordenados}")

# Top 3 clientes
top_3 = sorted(saldos, reverse=True)[:3]
print(f"Top 3 saldos: {top_3}")

# Porcentaje que representan los top 3
pct_top3 = sum(top_3) / sum(saldos) * 100
print(f"Top 3 = {pct_top3:.1f}% de la cartera")

# Contar cuántos superan el promedio
promedio = sum(saldos) / len(saldos)
sobre_promedio = sum(1 for s in saldos if s > promedio)
print(f"\nSobre promedio ({promedio:,.0f}): {sobre_promedio}/{len(saldos)}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: Recorrer listas con for

Combinar listas con bucles for es el patrón más común en procesamiento de datos.

ejemplo_04_recorrer.pyPython

# Recorrer con for
clientes = ["García", "López", "Martínez", "Pérez", "Fernández"]
saldos = [150000, 320000, 45000, 890000, 72000]

# Con enumerate (índice + valor)
print("=== Cartera de clientes ===")
for i, (nombre, saldo) in enumerate(zip(clientes, saldos), start=1):
    estado = "🟢" if saldo > 100000 else "🔴"
    print(f"  {i}. {estado} {nombre:<12} ${saldo:>10,}")

# Totales
print(f"{'─'*38}")
print(f"  Total: {len(clientes)} clientes, ${sum(saldos):,}")

# Acumulador manual (útil para entender cómo funciona sum)
print(f"\n=== Acumulador manual ===")
total = 0
for saldo in saldos:
    total += saldo
    print(f"  + ${saldo:>8,} → acumulado: ${total:>10,}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: List comprehensions — la herramienta más poderosa

Las list comprehensions son la forma "pythónica" de crear listas transformadas. Reemplazan bucles for completos en una sola línea.

ejemplo_05_comprehensions.pyPython

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

# Sintaxis: [expresión for elemento in iterable if condición]

# Aplicar IVA a todos
con_iva = [p * 1.21 for p in precios]
print(f"Con IVA: {[round(p) for p in con_iva]}")

# Filtrar solo precios > 3000
caros = [p for p in precios if p > 3000]
print(f"Caros (>$3000): {caros}")

# Filtrar Y transformar
caros_con_iva = [round(p * 1.21) for p in precios if p > 3000]
print(f"Caros + IVA: {caros_con_iva}")

# Clasificar con ternario
categorias = ["caro" if p > 5000 else "barato" for p in precios]
print(f"Categorías: {categorias}")

# Trabajar con strings
nombres = ["  ana garcía  ", "LUIS LÓPEZ", "marta   pérez"]
limpios = [n.strip().title() for n in nombres]
print(f"\nNombres limpios: {limpios}")

# Convertir montos texto a números
montos_str = ["$1,500", "$820", "$3,200", "$950"]
montos_num = [float(m.replace("$","").replace(",","")) for m in montos_str]
print(f"Montos numéricos: {montos_num}")
print(f"Total: ${sum(montos_num):,.0f}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Método	Qué hace	Modifica la lista?	Devuelve
`.append(x)`	Agrega x al final	Sí	`None`
`.insert(i, x)`	Inserta x en posición i	Sí	`None`
`.extend(lista)`	Agrega todos los elementos	Sí	`None`
`.remove(x)`	Elimina primera ocurrencia de x	Sí	`None`
`.pop(i)`	Elimina y devuelve elemento en i	Sí	El elemento
`.clear()`	Vacía la lista	Sí	`None`
`.sort()`	Ordena in-place	Sí	`None`
`.reverse()`	Invierte in-place	Sí	`None`
`.index(x)`	Posición de x	No	`int`
`.count(x)`	Cuántas veces aparece x	No	`int`
`.copy()`	Copia superficial	No	Nueva lista

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Crear y acceder

Creá una lista ciudades con 5 ciudades argentinas. Imprimí la primera, la última (con índice negativo) y la cantidad de elementos. Debe incluir Buenos Aires.

ejercicio_01.pyDebe incluir "Buenos Aires"

# Creá la lista e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Slicing

Dada nums = [10, 20, 30, 40, 50, 60, 70, 80], extraé e imprimí: los primeros 3, los últimos 3, y la lista invertida. Debe incluir [60, 70, 80].

ejercicio_02.pyDebe incluir "[60, 70, 80]"

nums = [10, 20, 30, 40, 50, 60, 70, 80]

# Extraé con slicing:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Sum, min, max, len

Dada ventas = [45000, 72000, 38000, 91000, 55000], imprimí: total, promedio, máximo y mínimo. Debe incluir 301000 (el total).

ejercicio_03.pyDebe incluir "301000"

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

# Calculá e imprimí estadísticas:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Append y extend

Empezá con cartera = [100000, 250000]. Agregá 180000 con append, después extendé con [50000, 320000]. Imprimí la lista final y su longitud. Debe incluir la longitud 5.

ejercicio_04.pyDebe incluir "5"

cartera = [100000, 250000]

# append + extend:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Ordenar y top N

Dada scores = [720, 590, 810, 645, 680, 750, 520], imprimí los 3 scores más altos (top 3) usando sorted() con reverse=True y slicing. Debe incluir [810, 750, 720].

ejercicio_05.pyDebe incluir "[810, 750, 720]"

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

# Top 3:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: List comprehension — filtrar

Dada montos = [12000, 3500, 45000, 800, 67000, 2100, 91000], creá una nueva lista grandes con solo los montos > 10000 e imprimí su suma. Debe incluir 215000.

ejercicio_06.pyDebe incluir "215000"

montos = [12000, 3500, 45000, 800, 67000, 2100, 91000]

# List comprehension para filtrar > 10000:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: List comprehension — transformar

Tenés precios_str = ["$2,500", "$1,800", "$4,200", "$950"]. Con una list comprehension, limpiá el $ y la coma, convertí a float y calculá el total. Debe incluir 9450.

ejercicio_07.pyDebe incluir "9450"

precios_str = ["$2,500", "$1,800", "$4,200", "$950"]

# Limpiá, convertí y sumá:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Recorrer dos listas en paralelo

Tenés clientes = ["García", "López", "Pérez"] y saldos = [250000, 80000, 510000]. Recorrelos con zip() e imprimí un reporte. Debe incluir Total: 840000.

ejercicio_08.pyDebe incluir "Total: 840000"

clientes = ["García", "López", "Pérez"]
saldos = [250000, 80000, 510000]

# Recorré con zip e imprimí:

print(f"Total: {sum(saldos)}")

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Clasificar con comprehension y ternario

Dada edades = [15, 22, 17, 30, 12, 45, 16, 28], creá una lista que tenga "Mayor" o "Menor" para cada edad. Contá cuántos son mayores. Debe incluir Mayores: 4.

ejercicio_09.pyDebe incluir "Mayores: 4"

edades = [15, 22, 17, 30, 12, 45, 16, 28]

# Clasificá y contá:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Análisis de cartera completo

Tenés clientes = ["García","López","Martínez","Pérez","Fernández"] y saldos = [150000, 320000, 45000, 890000, 72000]. Imprimí: (1) cada cliente con su saldo y un emoji 🟢 si > promedio, 🔴 si no, (2) el promedio, (3) los nombres de clientes sobre el promedio, (4) el Top 1. Debe incluir Promedio: 295400.

ejercicio_10_desafio.pyDebe incluir "Promedio: 295400"

clientes = ["García", "López", "Martínez", "Pérez", "Fernández"]
saldos = [150000, 320000, 45000, 890000, 72000]

# Análisis completo:

Hacé clic en ▶ Ejecutar

Resumen y conexión

Las listas son colecciones ordenadas y mutables, creadas con [].
Los índices empiezan en 0. Los negativos (-1) cuentan desde el final.
Slicing ([inicio:fin:paso]) extrae sublistas. Nunca da IndexError.
Métodos de modificación: append, insert, extend, remove, pop, sort, reverse.
Funciones estadísticas: len, sum, min, max, sorted.
List comprehensions ([x for x in lista if cond]) son la herramienta más poderosa para transformar datos.

En la siguiente lección (09 · Tuplas) vas a aprender la versión inmutable de las listas: cuándo conviene usar tuplas en vez de listas, y por qué la inmutabilidad es importante en código profesional.

Recursos: Python docs — Lists · List Comprehensions

Hecho con ❤️ por Rodri Gonzalez