Café y Código

7. Listas y Tuplas: Estructuras de Datos Ordenadas 📦

1. Listas: Colecciones Elásticas y Mutables

Una lista es una secuencia ordenada de elementos que se define utilizando corchetes []. Las listas en Python son mutables, lo que significa que puedes añadir, quitar o modificar sus elementos después de haberlas creado.

creacion_acceso.py
PYTHON
1 # Creación de una lista de compras
2 compras = ["café", "pan", "leche"]
3
4 # Acceso mediante índices (comienzan en 0)
5 primero = compras[0] # "café"
6 ultimo = compras[-1] # "leche" (índice negativo cuenta desde el final)

Operaciones y Métodos Esenciales de las Listas

Python ofrece un set de herramientas integradas muy potente para manipular listas:

🛠️ Catálogo de Métodos

  • .append(item): Añade un elemento al final de la lista.
  • .insert(posicion, item): Inserta un elemento en un índice específico.
  • .remove(valor): Busca y elimina el primer elemento que coincida con el valor especificado.
  • .pop(indice): Elimina y retorna el elemento en el índice indicado (si no pasas índice, elimina el último).
  • .sort(): Ordena los elementos de la lista (alfabéticamente o de menor a mayor).
  • .reverse(): Invierte el orden actual de la lista.
metodos_listas.py
PYTHON
1 ingredientes = ["harina", "agua"]
2
3 # 1. Agregar elementos
4 ingredientes.append("sal") # ["harina", "agua", "sal"]
5 ingredientes.insert(1, "levadura") # ["harina", "levadura", "agua", "sal"]
6
7 # 2. Eliminar elementos
8 eliminado = ingredientes.pop() # Quita "sal" y lo guarda en la variable
9 ingredientes.remove("agua") # ["harina", "levadura"]
10
11 # 3. Ordenar e invertir
12 numeros = [5, 2, 9, 1]
13 numeros.sort() # [1, 2, 5, 9]
14 numeros.reverse() # [9, 5, 2, 1]

2. Slicing Avanzado: Recortes de Listas

El slicing (rebanado) te permite extraer fragmentos de una lista utilizando la sintaxis lista[inicio:fin:paso].

  • inicio: El índice donde arranca el recorte (incluido).
  • fin: El índice donde termina el recorte (excluido).
  • paso: El intervalo de saltos (por defecto es 1).
slicing_pro.py
PYTHON
1 letras = ["a", "b", "c", "d", "e", "f", "g"]
2
3 # Obtener desde el índice 1 al 4 (excluyendo el 4)
4 sub_letras = letras[1:4] # ["b", "c", "d"]
5
6 # Si omites el inicio, arranca desde 0
7 primeras_tres = letras[:3] # ["a", "b", "c"]
8
9 # Si omites el fin, va hasta el final de la lista
10 desde_tercera = letras[2:] # ["c", "d", "e", "f", "g"]
11
12 # Usando el "paso" para saltar elementos
13 saltando = letras[::2] # ["a", "c", "e", "g"] (uno por medio)
14
15 # Truco premium: Invertir una lista completa usando paso negativo
16 invertida = letras[::-1] # ["g", "f", "e", "d", "c", "b", "a"]

3. Tuplas: Inmutabilidad y Desempaquetado

Una tupla se define utilizando paréntesis (). Su característica principal es que es inmutable: una vez que se crea, no puedes modificar, añadir ni remover ningún elemento.

¿Por qué usar tuplas en lugar de listas? Son más rápidas en memoria y protegen los datos contra modificaciones accidentales (ej. coordenadas geográficas, días de la semana, configuraciones fijas).

tuplas_inmutables.py
PYTHON
1 # Creación de una tupla
2 gps = (40.7128, -74.0060)
3
4 # gps[0] = 34.05 # ¡ERROR! Python lanzará un TypeError
5
6 # OJO: Si quieres crear una tupla de un solo elemento, debes poner una coma al final
7 tupla_un_elemento = (42,)

Desempaquetado de Tuplas (Tuple Unpacking)

Python permite extraer los valores de una tupla directamente en variables individuales en una sola línea de código:

desempaquetado.py
PYTHON
1 coordenadas = (-33.4489, -70.6693)
2
3 # Desempaquetando la tupla
4 latitud, longitud = coordenadas
5
6 print(f"Latitud: {latitud}") # -33.4489
7 print(f"Longitud: {longitud}") # -70.6693

4. Tabla Comparativa: Listas vs. Tuplas

Característica Lista [] Tupla ()
Mutabilidad Mutable (se puede modificar) Inmutable (fija)
Rendimiento Más lenta (reserva espacio extra) Más rápida y ligera
Casos comunes Listas dinámicas (Ej. carrito de compras) Datos estructurados fijos (Ej. coordenadas GPS)

5. Caso de Estudio: Análisis de un Mantenedor de Productos 🐘

En el mundo real, las listas y las tuplas suelen combinarse para representar bases de datos en memoria. A continuación, representaremos un catálogo de productos como una lista de tuplas, donde cada tupla representa un producto con la estructura: (código, nombre, precio, categoría, stock).

catalogo_productos.py
PYTHON
1 productos = [
2 # (code, name, price, category, stock)
3 ("PROD01", "Laptop", 850.00, "Electrónica", 15),
4 ("PROD02", "Silla Ergonómica", 150.00, "Oficina", 25),
5 ("PROD03", "Teclado Mecánico", 80.00, "Electrónica", 50),
6 ("PROD04", "Escritorio de Madera", 250.00, "Oficina", 10),
7 ("PROD05", "Audífonos Bluetooth", 120.00, "Electrónica", 40),
8 ("PROD06", "Cafetera de Goteo", 60.00, "Cocina", 12)
9 ]

Operación 1: Encontrar el producto más caro y el más barato

Para buscar extremos de valores en una lista de tuplas, podemos inicializar variables acumuladoras con el primer elemento de la lista e iterar comparando los precios (índice 2 de la tupla):

extremos.py
PYTHON
1 mas_caro = productos[0]
2 mas_barato = productos[0]
3
4 for p in productos:
5 # Comparar precios (p[2])
6 if p[2] > mas_caro[2]:
7 mas_caro = p
8 if p[2] < mas_barato[2]:
9 mas_barato = p
10
11 print(f"Más caro: {mas_caro[1]} (${mas_caro[2]} USD)") # Laptop ($850.00 USD)
12 print(f"Más barato: {mas_barato[1]} (${mas_barato[2]} USD)") # Cafetera de Goteo ($60.00 USD)

Operación 2: Sumar el total de productos en inventario

Para saber la cantidad total de unidades físicas que tenemos almacenadas, sumamos el stock de cada tupla (índice 4):

total_stock.py
PYTHON
1 total_unidades = 0
2
3 for p in productos:
4 total_unidades += p[4] # p[4] representa el stock
5
6 print(f"Total de unidades en stock: {total_unidades}") # 152 unidades

Operación 3: Filtrar y contar productos de una categoría

Para saber cuántos productos diferentes pertenecen a la categoría "Electrónica" (índice 3), usamos un contador condicional:

conteo_categoria.py
PYTHON
1 contador_electronica = 0
2
3 for p in productos:
4 if p[3] == "Electrónica":
5 contador_electronica += 1
6
7 print(f"Productos de categoría Electrónica: {contador_electronica}") # 3

🐍 Desafío: Gestión de Cafetería

Crea una lista llamada pedido con tres bebidas. Luego:
1. Añade "latte" al final.
2. Reemplaza la segunda bebida por "espresso".
3. Elimina y guarda la primera bebida del pedido.
4. Imprime el pedido restante y la bebida que eliminaste al revés.

👁️ Ver solución sugerida
Solución
PYTHON
1 # 1. Crear y añadir
2 pedido = ["capuccino", "americano", "mocaccino"]
3 pedido.append("latte") # ["capuccino", "americano", "mocaccino", "latte"]
4
5 # 2. Reemplazar
6 pedido[1] = "espresso" # ["capuccino", "espresso", "mocaccino", "latte"]
7
8 # 3. Eliminar primera
9 bebida_eliminada = pedido.pop(0) # ["espresso", "mocaccino", "latte"]
10
11 # 4. Imprimir resultados
12 print("Pedido restante:", pedido)
13 print("Eliminada al revés:", bebida_eliminada[::-1]) # "onicupac"

Prueba tus conocimientos

Responde las preguntas rápidas para validar que dominas la diferencia entre listas, tuplas y técnicas de corte.

Dato curioso: Primera versión pública en 1991; Guido van Rossum. Wikipedia

Ko-fi
Donaciones
Apoyá cafeycodigo con un café en Ko-fi. Colaboradores: insignia, muro y zona exclusiva.
Ir a Ko-fi → Programa sponsors