Listas y tuplas} dek="Hasta ahora cada variable guardaba un solo valor. Llegó el momento de guardar colecciones enteras en una sola variable." />

Hasta ahora, cada variable que has visto guarda un valor: un número, un texto, un booleano. Eso funciona para programas pequeños, pero la realidad casi nunca se deja modelar con valores sueltos.

Piensa en los amigos de tu lista de cumpleaños, los productos de un carrito de compra, las temperaturas de cada día del mes. Todo eso son colecciones de datos: muchos valores que pertenecen a una misma idea y queremos manejar juntos.

Python tiene varios tipos de colecciones. En este módulo aprenderás los dos más esenciales: las listas y las tuplas.

Crear una lista

Una lista es una secuencia ordenada de valores. Se escribe entre corchetes, con los elementos separados por comas:

{`['manzana', 'pera', 'uva'] []`} La función len que viste con cadenas también funciona con listas: len(["a", "b", "c"]) da 3. Vas a usarla todo el tiempo.

Acceder a los elementos: indexación

Cada elemento de una lista tiene una posición (en inglés, index). Para obtener un elemento, usa corchetes con el número de su posición:

{`manzana pera kiwi`}

El primer elemento es frutas[0], no frutas[1]. El último de una lista de 4 elementos es frutas[3], no frutas[4].

Esto es así en casi todos los lenguajes y al principio confunde. Después de un par de semanas se vuelve natural y empiezas a contar todo desde 0 incluso fuera del código (te lo aviso de antemano).

Índices negativos: contar desde el final

Python tiene un truco bonito que pocos lenguajes tienen: si usas un número negativo, Python cuenta desde el final hacia atrás:

{`kiwi uva`}

Esto es muy útil cuando solo te interesa el último elemento y no quieres preocuparte por cuántos haya en total.

Si pides un índice que no existe (frutas[10] en una lista de 4), Python lanza IndexError: list index out of range. Antes de acceder a un índice grande, comprueba con len.

Modificar la lista

Las listas son mutables, lo que significa que puedes cambiar su contenido:

{`['manzana', 'plátano', 'uva'] ['manzana', 'plátano', 'uva', 'kiwi'] ['fresa', 'manzana', 'plátano', 'uva', 'kiwi'] ['fresa', 'plátano', 'uva', 'kiwi'] Saqué: kiwi ['fresa', 'plátano', 'uva']`}

Observa la sintaxis nueva: frutas.append("kiwi"). El punto significa "este es un método de este objeto". append es un método de la lista — una función que vive dentro de la lista y opera sobre ella. Los métodos los verás muchísimo.

Los métodos esenciales de las listas

Método	Qué hace	Ejemplo

Fíjate: append, sort, reverse modifican la lista y devuelven None. pop, count, index devuelven un valor. Si escribes nueva = lista.sort(), nueva valdrá None: la lista se ordenó, pero el método no devolvió nada.

Recorrer una lista: `for` + lista

Ya viste el bucle for en el Módulo 4. Recorrer una lista es su uso más natural:

{`Me gusta la manzana. Me gusta la pera. Me gusta la uva.`}

Para cada vuelta, la variable fruta toma el valor de uno de los elementos. No necesitas índices.

Cuando sí necesitas el índice: `enumerate`

A veces, recorriendo la lista, también te interesa la posición de cada elemento. Python tiene una función ideal para eso: enumerate.

{`0: manzana 1: pera 2: uva`} Mucha gente que viene de otros lenguajes escribe for i in range(len(frutas)): y luego accede con frutas[i]. No lo hagas en Python. enumerate es la forma idiomática: más limpia, más rápida, y dice explícitamente qué quieres.

Slicing: trocear listas

Los slices (rebanadas) te permiten sacar un trozo de una lista — un sub-lista contigua. La sintaxis es lista[inicio:fin], y como con range, el final no se incluye.

{`[20, 30, 40] [10, 20, 30] [50, 60, 70] [50, 60, 70] [10, 30, 50, 70] [70, 60, 50, 40, 30, 20, 10]`} Al cortar una lista, obtienes una nueva lista; la original sigue igual. Esto es una diferencia importante con métodos como sort o append que sí modifican.

Operadores con listas

{`[1, 2, 3, 4, 5] [0, 0, 0, 0, 0] True False False`}

El operador in es uno de los más útiles de Python. Lee literalmente como "está en" y devuelve un booleano. Lo usarás en cada otro if que escribas.

Funciones útiles con listas

Además de los métodos, hay funciones built-in que reciben listas como argumento:

{`5 25.3 18.0 106.6 21.32 [18.0, 19.7, 21.1, 22.5, 25.3] [22.5, 18.0, 25.3, 19.7, 21.1]`} Dos formas de ordenar, sutilmente distintas:

lista.sort(): modifica la lista en su sitio, no devuelve nada.
sorted(lista): NO modifica, devuelve una nueva lista ordenada.

Usa sorted si necesitas la original intacta; usa .sort() si no.

Listas dentro de listas (matrices)

Una lista puede contener cualquier cosa, incluso otras listas. Es la forma de representar tablas, matrices, tableros de juego:

{`[' ', 'X', ' '] O O X O X X O X`} Por defecto print añade un salto de línea al final. Con el argumento end=" " le dices a Python que termine con un espacio en lugar del salto. Es perfecto para imprimir una fila completa en una sola línea.

Tuplas: como listas, pero a prueba de cambios

Una tupla es prácticamente igual que una lista, con una diferencia fundamental: no se puede modificar después de crearla. Se dice que es inmutable.

Las tuplas se escriben con paréntesis (en lugar de corchetes), o sin nada:

{`(40.4168, -3.7038) 40.4168 azul TypeError: 'tuple' object does not support item assignment`}

¿Para qué sirve algo "que no se puede modificar"?

Para datos que conceptualmente no deben cambiar. Las coordenadas de Madrid son las coordenadas de Madrid — no tiene sentido tener un método para cambiarlas. Una tupla deja claro: "esto es un paquete cerrado".
Para devolver varias cosas desde una función. Cuando hiciste return cociente, resto en el módulo anterior, en realidad estabas devolviendo una tupla.
Para usar como clave en diccionarios (lo verás en el Libro 2). Las listas no se pueden, las tuplas sí.

Desempaquetar tuplas (y listas)

Python te deja "desempaquetar" una tupla — o una lista — en varias variables de una vez. Es elegantísimo:

{`10 20 Luis Ana`} El intercambio a, b = b, a es Python en su máxima expresión: hace algo sencillo de forma sencilla, sin trucos crípticos. Memorízalo.

Listas vs tuplas: cuándo usar cada una

[ Lista ]

Cuando la colección puede cambiar: añadir, quitar, reordenar.

Carrito de compra
Lista de tareas
Resultados de un sensor

( Tupla )

Cuando la colección no debe cambiar: representa un dato cerrado.

Coordenadas (lat, lng)
Resolución (ancho, alto)
Valores devueltos por una función

Un patrón completísimo: filtrar y transformar

Antes de pasar a los ejercicios, mira este patrón clásico que combina casi todo lo del módulo. Lo vas a usar miles de veces en tu vida:

= 25°), # en grados Fahrenheit. calurosos_f = [] for t in temperaturas: if t >= 25: f = t * 9 / 5 + 32 calurosos_f.append(f) print("Días calurosos (F):", calurosos_f) print(f"Total de días calurosos: {len(calurosos_f)}") print(f"Promedio: {sum(calurosos_f) / len(calurosos_f):.1f}°F")`} /> {`Días calurosos (F): [87.8, 96.44000000000001, 81.32, 84.38] Total de días calurosos: 4 Promedio: 87.5°F`}

El patrón se repite así de aquí en adelante: una lista vacía + un bucle + un if + un append. Más adelante (en el Libro 2) veremos una forma todavía más compacta llamada list comprehensions, pero esta versión es perfecta para entender qué pasa.

Ejercicios

Cinco ejercicios que cubren los usos más típicos de listas. El último es un mini-proyecto que junta todo el libro hasta ahora.

Estadísticas básicas con funciones built-in.

El patrón fundamental: lista vacía + bucle + append.

5 + append. Recuerda: len() también funciona con cadenas.', solution: { code: `palabras = ["sol", "tarde", "elefante", "luna", "computadora", "agua", "Python"] largas = [] for palabra in palabras: if len(palabra) > 5: largas.append(palabra) print(largas)`, explanation: 'El patrón "filtrar": recorrer una lista y meter en otra solo lo que cumple cierta condición. Junto con "transformar" (modificar antes de guardar), son los dos patrones más usados al trabajar con datos.', }, }} >

Tu primer filtro. Patrón clave del módulo.

Toca pensar un poquito. Sin usar atajos.

Un mini-proyecto interactivo. Junta listas, bucles e input.

Resumen del módulo

// lo importante en una página

Lista: secuencia ordenada y mutable. {`["a", "b"]`}.
Acceso: lista[0] es el primero. Se empieza en 0. lista[-1] es el último.
Métodos clave: .append, .insert, .remove, .pop, .sort, .reverse, .count, .index.
Slicing: lista[1:4], lista[:3], lista[::-1]. El fin no se incluye.
Recorrer: for x in lista:. Con índice: for i, x in enumerate(lista):.
Operadores: + concatena, * repite, in comprueba pertenencia.
Funciones: len, max, min, sum, sorted (no modifica).
Listas dentro de listas para representar matrices: tablero[fila][columna].
Tupla: como una lista pero inmutable. (a, b).
Desempaquetar: x, y = punto. Intercambiar: a, b = b, a.

En el próximo módulo nos centramos en un tipo de dato que has visto desde el primer día, pero al que todavía no le habíamos prestado atención: las cadenas de texto. Vas a descubrir que esconden más de lo que parecía.