📘 Introducción a las Listas en Python

Las listas (list) son una de las estructuras de datos más poderosas y utilizadas en Python. Imagina una lista como una estantería de cajas numeradas, donde cada caja puede contener cualquier tipo de objeto: números, textos, booleanos o incluso otras listas.

Las listas permiten almacenar, acceder, modificar y eliminar elementos de manera muy flexible. Su versatilidad las convierte en la base de la mayoría de los programas en Python, desde simples scripts hasta aplicaciones complejas.

🎯 Objetivos de esta sección

• Comprender qué son las listas y por qué son tan útiles.
• Aprender a crearlas de diferentes maneras.
• Conocer la función list() y su uso para convertir otros tipos de datos.

🛠️ Creación de Listas

Podemos crear listas de varias formas, pero la más común es utilizando corchetes [].

🔹 Lista vacía

# Crear una lista vacía
mi_lista = []
print(mi_lista)  # []

Esto crea una lista sin elementos, útil cuando queremos ir llenándola más adelante con datos dinámicos.

🔹 Lista con elementos

# Lista con elementos de tipo cadena
frutas = ["manzana", "plátano", "naranja"]
print(frutas)  # ['manzana', 'plátano', 'naranja']

En este caso, la lista contiene tres cadenas de texto. Los elementos están separados por comas.

🔹 Lista con tipos de datos mixtos

# Lista con diferentes tipos de datos
mixta = [1, "hola", 3.14, True]
print(mixta)  # [1, 'hola', 3.14, True]

En Python, una lista puede mezclar enteros, cadenas, booleanos e incluso objetos complejos. Esto ofrece una enorme flexibilidad para trabajar con datos heterogéneos.

🧮 Creación de Listas con la función list()

Python también nos permite crear listas a partir de otros objetos iterables (como cadenas, tuplas o rangos) usando la función integrada list().

# Crear una lista vacía con list()
nueva_lista = list()
print(nueva_lista)  # []

# Convertir un rango en lista
numeros = list(range(1, 6))
print(numeros)  # [1, 2, 3, 4, 5]

# Convertir una cadena en lista de caracteres
letras = list("Python")
print(letras)  # ['P', 'y', 't', 'h', 'o', 'n']

La función list() es muy útil cuando queremos convertir datos de otro tipo en una lista manipulable.

💡 Ejemplo práctico: Lista de compras

Veamos un ejemplo realista en el que usamos listas para gestionar una lista de compras:

# Crear una lista de compras
compras = ["leche", "pan", "huevos"]

# Añadir un nuevo elemento
compras.append("frutas")

# Mostrar la lista actualizada
print("Lista de compras:", compras)

Salida esperada:

Lista de compras: ['leche', 'pan', 'huevos', 'frutas']

Este sencillo ejemplo muestra cómo podemos inicializar una lista, agregar nuevos elementos y mostrar su contenido. En próximas partes aprenderemos a acceder, modificar y recorrer los elementos.

📊 Comparativa rápida

🧠 Conclusión

Las listas son una herramienta esencial en Python. Gracias a su flexibilidad, se utilizan en todo tipo de proyectos: desde el almacenamiento de datos simples hasta estructuras más complejas como matrices o colecciones dinámicas. Entender cómo se crean es el primer paso para dominar el manejo de datos en Python.

🎯 Parte 2 — Indexación y Slicing

Una vez que sabemos crear listas, el siguiente paso es aprender a acceder a sus elementos. Python ofrece dos mecanismos potentes para esto: la indexación (para acceder a un solo elemento) y el slicing (para acceder a una porción o sublista).

📍 Indexación — Acceso directo a elementos

Podemos acceder a un elemento individual de una lista utilizando su posición entre corchetes.

tareas = ["estudiar", "hacer ejercicio", "programar", "descansar"]

# Acceder al primer elemento
primera = tareas[0]
print(primera)  # estudiar

# Acceder al tercer elemento
tercera = tareas[2]
print(tercera)  # programar

En este ejemplo, tareas[0] devuelve el primer elemento de la lista, y tareas[2] el tercero.

📉 Índices negativos

En Python también podemos usar índices negativos para acceder a elementos desde el final de la lista.

tareas = ["estudiar", "hacer ejercicio", "programar", "descansar"]

# Último elemento
ultima = tareas[-1]
print(ultima)  # descansar

# Penúltimo elemento
penultima = tareas[-2]
print(penultima)  # programar

Esto es especialmente útil cuando no conocemos el tamaño exacto de la lista y queremos acceder a los últimos elementos.

🍰 Slicing — Extracción de sublistas

El slicing (rebanado) permite extraer una porción de la lista. La sintaxis básica es:

lista[inicio:fin:paso]

Donde:

• inicio: índice donde comienza la selección (incluido).
• fin: índice donde termina la selección (excluido).
• paso: salto entre elementos (opcional).

numeros = [10, 20, 30, 40, 50, 60, 70]

# Elementos desde el índice 0 hasta el 2 (sin incluir el 3)
primeros_tres = numeros[0:3]
print(primeros_tres)  # [10, 20, 30]

# Del índice 1 al 3
segmento = numeros[1:4]
print(segmento)  # [20, 30, 40]

📎 Slicing simplificado

Si omitimos el índice inicio, Python asume que empieza desde el principio. Si omitimos el índice fin, el corte llegará hasta el final.

# Desde el inicio hasta el índice 2
inicio = numeros[:3]
print(inicio)  # [10, 20, 30]

# Desde el índice 2 hasta el final
final = numeros[2:]
print(final)  # [30, 40, 50, 60, 70]

⏩ Slicing con paso (step)

El tercer parámetro paso indica cada cuántos elementos se selecciona uno.

# Cada dos elementos
pares = numeros[::2]
print(pares)  # [10, 30, 50, 70]

# De atrás hacia adelante
inverso = numeros[::-1]
print(inverso)  # [70, 60, 50, 40, 30, 20, 10]

🔢 Ejemplo completo

numeros = [10, 20, 30, 40, 50, 60, 70]

print(numeros[0:4])   # [10, 20, 30, 40]
print(numeros[:5])    # [10, 20, 30, 40, 50]
print(numeros[-3:])   # [50, 60, 70]
print(numeros[::3])   # [10, 40, 70]

Este ejemplo muestra lo fácil que es extraer diferentes porciones de una lista sin necesidad de bucles.

⚠️ Errores comunes al indexar

• Índices fuera de rango: acceder a una posición inexistente produce un IndexError.

numeros = [1, 2, 3]
print(numeros[5])  # IndexError: list index out of range

• Usar índices incorrectos en slicing: no genera error, simplemente devuelve una lista vacía.

print(numeros[5:8])  # []

🧮 Ejemplo práctico: Extrayendo datos de una lista

# Lista de temperaturas semanales
temperaturas = [20, 22, 25, 24, 19, 18, 21]

# Acceder al primer y último día
primero = temperaturas[0]
ultimo = temperaturas[-1]

# Obtener las tres primeras temperaturas
inicio_semana = temperaturas[:3]

# Obtener las temperaturas de mitad de semana
mitad = temperaturas[2:5]

print("Primera temperatura:", primero)
print("Última temperatura:", ultimo)
print("Inicio de semana:", inicio_semana)
print("Mitad de semana:", mitad)

Salida esperada:

Primera temperatura: 20
Última temperatura: 21
Inicio de semana: [20, 22, 25]
Mitad de semana: [25, 24, 19]

🧠 Conclusión

El acceso mediante indexación y slicing es una de las herramientas más potentes y limpias de Python. Permite obtener cualquier dato dentro de una lista con facilidad y sin bucles complejos.

⚙️ Parte 3 — Métodos principales de las listas en Python

Las listas en Python incluyen una amplia gama de métodos integrados que permiten manipular su contenido sin necesidad de escribir código complejo. Estos métodos te facilitan tareas comunes como añadir, eliminar, ordenar o copiar elementos de forma rápida y legible.

🧩 Métodos para añadir elementos

Existen tres formas principales de agregar nuevos elementos a una lista:

1️⃣ append() — Añadir un solo elemento al final

Agrega un nuevo elemento al final de la lista, sin alterar los elementos existentes.

tareas = ["estudiar", "hacer ejercicio"]
tareas.append("programar")
print(tareas)  # ['estudiar', 'hacer ejercicio', 'programar']

Es ideal para ir acumulando datos dinámicamente, como registros de usuarios o resultados de un cálculo.

2️⃣ insert(posición, elemento) — Insertar en una posición específica

Este método te permite colocar un elemento en una posición concreta dentro de la lista.

compras = ["pan", "huevos"]
compras.insert(1, "leche")  # Inserta en la posición 1
print(compras)  # ['pan', 'leche', 'huevos']

Si insertas en una posición mayor al tamaño de la lista, Python lo agregará al final.

3️⃣ extend(iterable) — Añadir varios elementos a la vez

A diferencia de append(), este método permite añadir los elementos de otra lista (o cualquier iterable) de forma individual.

frutas = ["manzana", "plátano"]
mas_frutas = ["naranja", "uva"]
frutas.extend(mas_frutas)
print(frutas)  # ['manzana', 'plátano', 'naranja', 'uva']

Diferencia entre append() y extend():

🗑️ Métodos para eliminar elementos

Python ofrece varias formas de quitar elementos de una lista. Elige el método según lo que necesites: eliminar por valor, por posición o vaciar la lista.

1️⃣ remove(valor) — Eliminar la primera ocurrencia

colores = ["rojo", "verde", "azul", "verde"]
colores.remove("verde")
print(colores)  # ['rojo', 'azul', 'verde']

Si el elemento no existe, se lanzará un ValueError.

2️⃣ pop([índice]) — Eliminar por posición (y devolver el valor)

numeros = [10, 20, 30, 40]
ultimo = numeros.pop()
print(ultimo)   # 40
print(numeros)  # [10, 20, 30]

segundo = numeros.pop(1)
print(segundo)  # 20
print(numeros)  # [10, 30]

Si no se indica índice, elimina el último elemento. Además, devuelve el valor eliminado, lo que permite almacenarlo o mostrarlo.

3️⃣ clear() — Vaciar la lista por completo

mi_lista = [1, 2, 3, 4]
mi_lista.clear()
print(mi_lista)  # []

4️⃣ del — Eliminar usando la palabra clave

letras = ["a", "b", "c", "d"]
del letras[1]
print(letras)  # ['a', 'c', 'd']

numeros = [1, 2, 3, 4, 5]
del numeros[1:3]
print(numeros)  # [1, 4, 5]

También puedes eliminar toda la lista:

del numeros

🔃 Métodos para ordenar y reorganizar listas

1️⃣ sort() — Ordenar la lista en su lugar

numeros = [3, 1, 4, 2]
numeros.sort()
print(numeros)  # [1, 2, 3, 4]

# Orden descendente
numeros.sort(reverse=True)
print(numeros)  # [4, 3, 2, 1]

2️⃣ reverse() — Invertir el orden

letras = ["a", "b", "c"]
letras.reverse()
print(letras)  # ['c', 'b', 'a']

📎 Diferencia entre sort() y sorted()

numeros = [3, 1, 4, 2]

# Método sort() — modifica la lista original
numeros.sort()
print(numeros)  # [1, 2, 3, 4]

# Función sorted() — crea una nueva lista ordenada
numeros = [3, 1, 4, 2]
ordenados = sorted(numeros)
print(numeros)   # [3, 1, 4, 2]
print(ordenados) # [1, 2, 3, 4]

Usa sorted() cuando quieras conservar la lista original.

📋 Métodos para copiar e inspeccionar listas

1️⃣ copy() — Crear una copia independiente

original = [1, 2, 3]
copia = original.copy()
copia.append(4)
print(original)  # [1, 2, 3]
print(copia)     # [1, 2, 3, 4]

2️⃣ count(valor) — Contar ocurrencias

letras = ["a", "b", "a", "c", "a"]
print(letras.count("a"))  # 3

3️⃣ index(valor[, inicio]) — Obtener la posición del primer valor

frutas = ["manzana", "plátano", "naranja", "plátano"]
pos = frutas.index("plátano")
print(pos)  # 1

# Buscar desde otra posición
print(frutas.index("plátano", 2))  # 3

🧠 Ejemplo práctico: Lista de tareas

# Creamos la lista base
tareas = ["Estudiar Python", "Hacer ejercicio"]

# Añadimos nuevas tareas
tareas.append("Comprar víveres")
tareas.insert(0, "Llamar al médico")

# Eliminamos una completada
tareas.remove("Hacer ejercicio")

# Añadimos varias de golpe
tareas.extend(["Lavar ropa", "Preparar cena"])

# Ordenamos alfabéticamente
tareas.sort()

# Mostramos las tareas numeradas
for i, tarea in enumerate(tareas, 1):
    print(f"{i}. {tarea}")

Salida esperada:

1. Comprar víveres
2. Estudiar Python
3. Lavar ropa
4. Llamar al médico
5. Preparar cena

🧾 Tabla resumen de métodos principales

🧠 Conclusión

Estos métodos son el corazón del trabajo con listas en Python. Dominar su uso te permitirá manipular datos de forma eficiente, elegante y sin errores innecesarios.

🔁 Parte 4 — Iteración y búsqueda de elementos en listas

Una de las operaciones más comunes con listas en Python es recorrerlas, es decir, iterar sobre cada elemento para procesarlo, mostrarlo o modificarlo. Además, también podemos buscar elementos para comprobar si existen o conocer su posición.

📜 Recorrido con for

El método más legible y utilizado para recorrer una lista es el bucle for. Este bucle toma automáticamente cada elemento y lo almacena en una variable temporal que podemos usar dentro del bloque.

frutas = ["manzana", "plátano", "naranja", "uva"]

for fruta in frutas:
    print(f"Me gusta comer {fruta}")

Salida esperada:

Me gusta comer manzana
Me gusta comer plátano
Me gusta comer naranja
Me gusta comer uva

Con este tipo de bucle, no necesitas preocuparte por los índices ni por el tamaño de la lista.

📍 Recorrido con índices — enumerate()

Si además del valor necesitas conocer la posición (índice) de cada elemento, utiliza la función enumerate(). Devuelve pares (índice, valor) en cada iteración.

tareas = ["estudiar", "hacer ejercicio", "programar"]

for indice, tarea in enumerate(tareas):
    print(f"Tarea {indice + 1}: {tarea}")

Salida esperada:

Tarea 1: estudiar
Tarea 2: hacer ejercicio
Tarea 3: programar

También puedes cambiar el índice inicial añadiendo un segundo argumento:

for i, tarea in enumerate(tareas, start=100):
    print(f"ID {i}: {tarea}")

📏 Recorrido tradicional con range() y len()

Si prefieres un control más clásico sobre los índices, combina range() con len():

numeros = [10, 20, 30, 40, 50]

for i in range(len(numeros)):
    print(f"Posición {i}: {numeros[i]}")

Este enfoque es útil cuando necesitas:

• Modificar los elementos de la lista durante el recorrido.
• Acceder a elementos anteriores o posteriores (i – 1, i + 1).
• Recorrer en orden inverso.

🔄 Recorrido inverso

Para recorrer una lista de atrás hacia adelante, tienes dos formas:

✅ Usando reversed()

colores = ["rojo", "verde", "azul", "amarillo"]

for color in reversed(colores):
    print(color)

✅ Usando range() con pasos negativos

for i in range(len(colores)-1, -1, -1):
    print(colores[i])

El resultado será el mismo, pero reversed() es más legible y pythonic.

💡 Recorrido con comprensión de listas

Las comprensiones de listas son una forma elegante y rápida de crear nuevas listas basadas en otras.

numeros = [1, 2, 3, 4, 5]

# Crear una lista con los cuadrados
cuadrados = [n * n for n in numeros]
print(cuadrados)  # [1, 4, 9, 16, 25]

# Filtrar solo los pares
pares = [n for n in numeros if n % 2 == 0]
print(pares)  # [2, 4]

Esta técnica es muy utilizada en programación moderna por su claridad y eficiencia.

👥 Recorrer múltiples listas en paralelo — zip()

Cuando necesitas recorrer varias listas a la vez, usa zip(). Esta función agrupa los elementos por posición, deteniéndose cuando se acaba la lista más corta.

nombres = ["Ana", "Carlos", "Elena"]
edades = [28, 32, 25]
ciudades = ["Madrid", "Barcelona", "Sevilla"]

for nombre, edad, ciudad in zip(nombres, edades, ciudades):
    print(f"{nombre} tiene {edad} años y vive en {ciudad}")

Salida esperada:

Ana tiene 28 años y vive en Madrid
Carlos tiene 32 años y vive en Barcelona
Elena tiene 25 años y vive en Sevilla

⏳ Recorrido con while

Aunque es menos común, también puedes recorrer una lista usando while si necesitas más control sobre la variable de iteración.

compras = ["pan", "leche", "huevos", "frutas"]
i = 0

while i < len(compras):
    print(f"Debo comprar: {compras[i]}")
    i += 1

Este método es más manual, pero útil si necesitas detenerte a mitad del recorrido bajo ciertas condiciones.

🔍 Búsqueda de elementos en una lista

✅ Operador in

Para verificar si un elemento existe en una lista, usamos el operador in.

compras = ["leche", "pan", "huevos", "frutas"]

if "pan" in compras:
    print("Pan está en la lista")

if "queso" not in compras:
    print("Falta añadir queso")

Salida esperada:

Pan está en la lista
Falta añadir queso

✅ Método index()

Devuelve la posición del primer elemento que coincide con el valor indicado.

tareas = ["leer", "escribir", "programar", "dormir"]
pos = tareas.index("programar")
print(pos)  # 2

Si el elemento no existe, Python lanzará un ValueError:

try:
    pos = tareas.index("correr")
except ValueError:
    print("Esa tarea no está en la lista")

✅ Método count()

Cuenta cuántas veces aparece un elemento específico en la lista.

letras = ["a", "b", "a", "c", "a", "b"]
print(letras.count("a"))  # 3

📊 Ejemplo práctico: Análisis de calificaciones

calificaciones = [85, 90, 78, 92, 65, 88, 72]

# Calcular promedio, máximo y mínimo
total = 0
maximo = calificaciones[0]
minimo = calificaciones[0]

for nota in calificaciones:
    total += nota
    if nota > maximo:
        maximo = nota
    if nota  promedio]
por_debajo = [n for n in calificaciones if n < promedio]

print(f"Promedio: {promedio:.2f}")
print(f"Mayor nota: {maximo}")
print(f"Menor nota: {minimo}")
print(f"Notas superiores al promedio: {por_encima}")
print(f"Notas inferiores al promedio: {por_debajo}")

Salida esperada:

Promedio: 81.43
Mayor nota: 92
Menor nota: 65
Notas superiores al promedio: [85, 90, 92, 88]
Notas inferiores al promedio: [78, 65, 72]

🧠 Conclusión

La iteración y búsqueda son operaciones fundamentales al trabajar con listas. Gracias a la sintaxis limpia de Python, puedes procesar grandes volúmenes de datos con muy pocas líneas de código.

🧰 Parte 5 — Modificación de Listas en Python

Una de las características más poderosas de las listas en Python es que son mutables, es decir, podemos cambiar su contenido sin necesidad de crear una nueva lista. Esto las convierte en una herramienta extremadamente flexible para manejar y transformar datos en tiempo real.

✏️ Modificación de elementos individuales

Podemos cambiar un elemento directamente usando su índice.

frutas = ["manzana", "plátano", "naranja", "uva"]

# Cambiar el segundo elemento (índice 1)
frutas[1] = "pera"
print(frutas)  # ['manzana', 'pera', 'naranja', 'uva']

También podemos usar índices negativos para modificar desde el final:

colores = ["rojo", "verde", "azul"]
colores[-1] = "amarillo"
print(colores)  # ['rojo', 'verde', 'amarillo']

📏 Modificación múltiple con slicing

El slicing no solo sirve para leer porciones de una lista, sino también para reemplazarlas por nuevos valores.

numeros = [1, 2, 3, 4, 5]
numeros[1:4] = [20, 30, 40]
print(numeros)  # [1, 20, 30, 40, 5]

El tamaño del nuevo fragmento puede ser distinto al original. Esto permite expandir o contraer la lista.

letras = ["a", "b", "c", "d", "e"]
letras[1:4] = ["X", "Y"]
print(letras)  # ['a', 'X', 'Y', 'e']

secuencia = [1, 2, 3]
secuencia[1:2] = [10, 20, 30]
print(secuencia)  # [1, 10, 20, 30, 3]

Esto puede usarse para insertar bloques de datos en cualquier punto de la lista.

🧩 Modificación con métodos integrados

Ya conoces algunos de los métodos que permiten alterar listas. Aquí los usamos en un contexto de modificación:

tareas = ["estudiar", "ejercicio", "programar"]

# Añadir nuevos elementos
tareas.append("leer")
tareas.insert(1, "desayunar")

# Eliminar un elemento existente
tareas.remove("ejercicio")

# Eliminar por posición
tareas.pop(2)

print(tareas)  # ['estudiar', 'desayunar', 'leer']

Estos métodos son ideales cuando el contenido de la lista se va construyendo o reduciendo dinámicamente.

🎯 Modificación condicional de elementos

A veces queremos modificar solo los elementos que cumplan cierta condición. Podemos hacerlo fácilmente con un bucle for.

precios = [19.99, 10.50, 8.75, 22.30, 15.00]

# Aplicar 10% de descuento a precios mayores de 15
for i in range(len(precios)):
    if precios[i] > 15:
        precios[i] = round(precios[i] * 0.9, 2)

print(precios)  # [17.99, 10.5, 8.75, 20.07, 15.0]

Esta técnica es muy usada en operaciones sobre listas numéricas o al procesar datos en masa.

💡 Modificación mediante comprensión de listas

Cuando queremos aplicar una transformación a toda la lista o generar una nueva basada en una existente, las comprensiones de listas son la opción más elegante.

numeros = [1, 2, 3, 4, 5]

# Duplicar los pares, dejar los impares igual
numeros_mod = [n * 2 if n % 2 == 0 else n for n in numeros]
print(numeros_mod)  # [1, 4, 3, 8, 5]

Si deseas modificar la lista original:

numeros = [n * 2 if n % 2 == 0 else n for n in numeros]

🏗️ Modificación de listas anidadas

Las listas pueden contener otras listas, formando estructuras multidimensionales (como matrices). Podemos acceder y modificar cualquier elemento interno usando índices múltiples.

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

# Modificar un elemento concreto (fila 1, columna 2)
matriz[1][2] = 60
print(matriz)  # [[1, 2, 3], [4, 5, 60], [7, 8, 9]]

# Reemplazar una fila completa
matriz[0] = [10, 20, 30]
print(matriz)  # [[10, 20, 30], [4, 5, 60], [7, 8, 9]]

En estructuras de datos más grandes, esto es útil para actualizar tablas o rejillas.

➕ Operaciones de combinación y repetición

Python ofrece operadores para modificar listas rápidamente.

# Concatenar listas
lista1 = [1, 2, 3]
lista2 = [4, 5]
lista_combinada = lista1 + lista2
print(lista_combinada)  # [1, 2, 3, 4, 5]

# Repetir patrones
patrones = ["A", "B"]
repetidos = patrones * 3
print(repetidos)  # ['A', 'B', 'A', 'B', 'A', 'B']

# Agregar con += (equivalente a extend)
numeros = [1, 2, 3]
numeros += [4, 5]
print(numeros)  # [1, 2, 3, 4, 5]

📦 Ejemplo práctico: Sistema de inventario

# Inventario de productos [nombre, cantidad, precio]
inventario = [
    ["Camiseta", 15, 19.99],
    ["Pantalón", 8, 29.99],
    ["Zapatos", 5, 59.99],
    ["Gorra", 12, 12.50]
]

def actualizar_precio(producto, nuevo_precio):
    for item in inventario:
        if item[0] == producto:
            item[2] = nuevo_precio
            print(f"Precio de {producto} actualizado a {nuevo_precio}€")
            return
    print(f"Producto {producto} no encontrado")

def registrar_venta(producto, cantidad):
    for item in inventario:
        if item[0] == producto:
            if item[1] >= cantidad:
                item[1] -= cantidad
                print(f"Venta registrada: {cantidad} unidades de {producto}")
            else:
                print(f"Stock insuficiente de {producto}")
            return
    print(f"Producto {producto} no encontrado")

def añadir_producto(producto, cantidad, precio):
    for item in inventario:
        if item[0] == producto:
            item[1] += cantidad
            print(f"Stock de {producto} aumentado en {cantidad}")
            return
    inventario.append([producto, cantidad, precio])
    print(f"Nuevo producto añadido: {producto}")

# Ejecución
actualizar_precio("Pantalón", 34.99)
registrar_venta("Camiseta", 3)
añadir_producto("Bufanda", 10, 14.99)

# Mostrar inventario actualizado
print("\nInventario actualizado:")
for producto, cantidad, precio in inventario:
    print(f"{producto}: {cantidad} unidades a {precio}€")

Salida esperada:

Precio de Pantalón actualizado a 34.99€
Venta registrada: 3 unidades de Camiseta
Nuevo producto añadido: Bufanda

Inventario actualizado:
Camiseta: 12 unidades a 19.99€
Pantalón: 8 unidades a 34.99€
Zapatos: 5 unidades a 59.99€
Gorra: 12 unidades a 12.5€
Bufanda: 10 unidades a 14.99€

⚠️ Consideraciones importantes

1️⃣ Referencias compartidas

Cuando asignas una lista a otra variable, ambas apuntan al mismo objeto.

lista_a = [1, 2, 3]
lista_b = lista_a

lista_b[0] = 100
print(lista_a)  # [100, 2, 3]

Ambas cambian, porque en realidad son la misma lista en memoria.

2️⃣ Crear copias independientes

original = [1, 2, 3]
copia = original.copy()

copia[0] = 99
print(original)  # [1, 2, 3]
print(copia)     # [99, 2, 3]

3️⃣ Copias profundas (listas anidadas)

En listas con listas internas, usa el módulo copy:

import copy

anidada = [[1, 2], [3, 4]]
copia_profunda = copy.deepcopy(anidada)
copia_profunda[0][0] = 100

print(anidada)        # [[1, 2], [3, 4]]
print(copia_profunda) # [[100, 2], [3, 4]]

📋 Tabla comparativa de técnicas de modificación

🧠 Conclusión

Modificar listas es una habilidad clave en Python. Saber cuándo usar append(), slicing, o comprensiones te permite manipular datos de manera eficaz y con un código más limpio.

💼 Parte 6 — Ejemplos prácticos y casos de uso

Ya has aprendido cómo crear, acceder, modificar y recorrer listas. Ahora llega el momento de aplicar todo ese conocimiento en escenarios reales. Las listas son omnipresentes en la programación con Python: sirven para gestionar datos, analizar información y automatizar tareas cotidianas.

📋 Ejemplo 1 — Gestión de estudiantes

Supongamos que queremos almacenar una lista de nombres de estudiantes, añadir nuevos, eliminar alguno y mostrar el total de inscritos.

# Lista inicial
estudiantes = ["Ana", "Luis", "María", "Carlos"]

# Añadir un nuevo estudiante
estudiantes.append("Sofía")

# Eliminar un estudiante que se dio de baja
estudiantes.remove("Luis")

# Mostrar la lista actualizada y el total
print("Estudiantes inscritos:")
for nombre in estudiantes:
    print("-", nombre)

print("\nTotal de estudiantes:", len(estudiantes))

Salida esperada:

Estudiantes inscritos:
- Ana
- María
- Carlos
- Sofía

Total de estudiantes: 4

🧮 Ejemplo 2 — Cálculo de estadísticas

Queremos analizar una lista de números representando las temperaturas diarias. Usaremos bucles, min(), max() y sum() para calcular estadísticas básicas.

temperaturas = [20, 22, 25, 24, 19, 18, 21]

promedio = sum(temperaturas) / len(temperaturas)
maxima = max(temperaturas)
minima = min(temperaturas)

print(f"Promedio semanal: {promedio:.2f}°C")
print(f"Temperatura máxima: {maxima}°C")
print(f"Temperatura mínima: {minima}°C")

Salida esperada:

Promedio semanal: 21.29°C
Temperatura máxima: 25°C
Temperatura mínima: 18°C

Este ejemplo combina funciones nativas y operaciones con listas, muy común en análisis de datos o IoT.

📊 Ejemplo 3 — Filtrar datos (comprensión de listas)

Queremos filtrar los empleados que ganan más de 2000 € al mes usando una sola línea de código.

sueldos = [1500, 2200, 1800, 2500, 3000, 1900]

# Filtrar los mayores de 2000
altos = [s for s in sueldos if s > 2000]

print("Sueldos altos:", altos)

Salida esperada:

Sueldos altos: [2200, 2500, 3000]

Las comprensiones de listas son una herramienta clave para escribir código más corto, limpio y eficiente.

🧾 Ejemplo 4 — Buscador de palabras clave

Vamos a crear un pequeño programa que busque una palabra dentro de una lista de títulos de artículos.

articulos = [
    "Introducción a Python",
    "Estructuras de datos en Python",
    "Programación orientada a objetos",
    "Listas y tuplas en detalle",
    "Automatización con scripts"
]

busqueda = input("Introduce una palabra clave: ").lower()

resultados = [a for a in articulos if busqueda in a.lower()]

if resultados:
    print("\nCoincidencias encontradas:")
    for r in resultados:
        print("-", r)
else:
    print("No se encontraron coincidencias.")

Este tipo de script es la base de sistemas de búsqueda sencillos, motores de filtrado o menús interactivos.

🧰 Ejemplo 5 — Control de inventario con listas anidadas

Un caso práctico muy habitual: gestionar el inventario de una tienda usando listas anidadas.

inventario = [
    ["Camiseta", 15, 19.99],
    ["Pantalón", 8, 29.99],
    ["Zapatos", 5, 59.99]
]

# Aumentar el stock de un producto
inventario[0][1] += 5  # +5 camisetas

# Cambiar el precio del pantalón
inventario[1][2] = 34.99

# Mostrar inventario
print("Inventario actualizado:")
for producto, cantidad, precio in inventario:
    print(f"{producto}: {cantidad} unidades a {precio}€")

Salida esperada:

Inventario actualizado:
Camiseta: 20 unidades a 19.99€
Pantalón: 8 unidades a 34.99€
Zapatos: 5 unidades a 59.99€

🧮 Ejemplo 6 — Promedio de notas con retroalimentación

Simulemos un sistema básico que calcula la media de notas y clasifica el rendimiento de un estudiante.

notas = [7.5, 8.0, 6.0, 9.0, 8.5]

promedio = sum(notas) / len(notas)

if promedio >= 9:
    estado = "Sobresaliente"
elif promedio >= 7:
    estado = "Notable"
elif promedio >= 5:
    estado = "Aprobado"
else:
    estado = "Suspenso"

print(f"Promedio final: {promedio:.2f}")
print(f"Desempeño: {estado}")

Salida esperada:

Promedio final: 7.80
Desempeño: Notable

⚙️ Ejemplo 7 — Generador de contraseñas

Las listas también se usan en tareas de seguridad, como generar contraseñas aleatorias.

import random

caracteres = list("abcdefghijklmnopqrstuvwxyz0123456789!@#$%&*")

# Crear una contraseña de 10 caracteres
password = "".join(random.choice(caracteres) for i in range(10))

print("Contraseña generada:", password)

Este ejemplo muestra cómo usar listas junto con módulos estándar para automatizar tareas útiles.

🎮 Ejemplo 8 — Ranking de jugadores

En los videojuegos o aplicaciones de puntuaciones, las listas son esenciales para guardar rankings.

jugadores = ["Ana", "Carlos", "Pedro", "Lucía"]
puntuaciones = [250, 320, 180, 400]

# Combinar y ordenar
ranking = list(zip(jugadores, puntuaciones))
ranking.sort(key=lambda x: x[1], reverse=True)

print("🏆 Ranking de jugadores:")
for nombre, puntos in ranking:
    print(f"{nombre}: {puntos} puntos")

Salida esperada:

🏆 Ranking de jugadores:
Lucía: 400 puntos
Carlos: 320 puntos
Ana: 250 puntos
Pedro: 180 puntos

🧠 Ejemplo 9 — Limpieza de datos (preprocesamiento)

En ciencia de datos, las listas se usan para limpiar o transformar información antes de analizarla.

datos = ["  Python ", "JAVA", "   c++", "python", "java "]

# Normalizar los nombres de lenguajes
limpios = [d.strip().capitalize() for d in datos]
print(limpios)

Salida esperada:

['Python', 'Java', 'C++', 'Python', 'Java']

📊 Tabla resumen de casos de uso

🧩 Conclusión

Las listas son uno de los pilares fundamentales del lenguaje Python. En estos ejemplos has visto cómo se aplican en áreas tan diversas como análisis de datos, automatización, videojuegos o gestión de información.

✅ Parte 7 — Buenas prácticas y ejercicios integradores

Las listas son una de las estructuras más usadas en Python, y dominarlas te permitirá escribir código más limpio, eficiente y profesional. En esta parte aprenderás buenas prácticas y pondrás a prueba tus conocimientos con ejercicios reales.

💡 Buenas prácticas con listas

1️⃣ Usa nombres descriptivos

Evita nombres genéricos como lista1 o datos2. Usa nombres que describan el propósito:

# ❌ Malo
lista1 = [10, 20, 30]

# ✅ Bueno
precios_productos = [10, 20, 30]

2️⃣ Usa comprensiones de listas siempre que sean legibles

Las comprensiones son elegantes y potentes, pero deben seguir siendo claras.

# ✅ Correcto (legible)
pares = [n for n in range(10) if n % 2 == 0]

# ⚠️ Evita comprensiones muy largas o anidadas
# ❌ Demasiado compleja
resultado = [f(x) for x in lista if cond(x) and otra_funcion(x) > 10]

3️⃣ No modifiques una lista mientras la recorres

Modificar el tamaño de una lista durante la iteración puede causar errores o resultados inesperados.

# ❌ Incorrecto
numeros = [1, 2, 3, 4, 5]
for n in numeros:
    if n % 2 == 0:
        numeros.remove(n)

print(numeros)  # Resultado impredecible

Solución correcta:

# ✅ Correcto
numeros = [1, 2, 3, 4, 5]
numeros = [n for n in numeros if n % 2 != 0]
print(numeros)  # [1, 3, 5]

4️⃣ Usa copias si necesitas conservar la lista original

original = [1, 2, 3]
modificada = original.copy()

modificada.append(4)
print(original)   # [1, 2, 3]
print(modificada) # [1, 2, 3, 4]

5️⃣ Elige el método adecuado para cada operación

6️⃣ Prefiere funciones integradas sobre bucles manuales

Python ofrece funciones como sum(), max(), min() o any(), que son más rápidas y legibles.

# ❌ Lento y verboso
total = 0
for n in numeros:
    total += n

# ✅ Simple y eficiente
total = sum(numeros)

7️⃣ Evita duplicar código: usa funciones

def mostrar_lista(lista):
    for e in lista:
        print("-", e)

tareas = ["Estudiar", "Leer", "Ejercitarse"]
mostrar_lista(tareas)

Definir funciones te permitirá reutilizar código en todo tu proyecto.

⚙️ Errores comunes a evitar

• Usar índices fuera del rango (IndexError).
• Olvidar que los índices empiezan en 0.
• Usar = en lugar de == al comparar valores.
• Olvidar copiar listas cuando se necesita independencia.

🧩 Ejercicios integradores

💪 Ejercicio 1 — Lista de tareas dinámica

Crea un programa que permita al usuario:

• Añadir una tarea.
• Eliminar una tarea completada.
• Ver la lista de tareas actual.

tareas = []

while True:
    print("\n1. Añadir tarea")
    print("2. Eliminar tarea")
    print("3. Ver tareas")
    print("4. Salir")
    opcion = input("Selecciona una opción: ")

    if opcion == "1":
        nueva = input("Tarea nueva: ")
        tareas.append(nueva)
    elif opcion == "2":
        eliminar = input("Tarea completada: ")
        if eliminar in tareas:
            tareas.remove(eliminar)
            print("Tarea eliminada.")
        else:
            print("No encontrada.")
    elif opcion == "3":
        print("\nTareas actuales:")
        for t in tareas:
            print("-", t)
    elif opcion == "4":
        break
    else:
        print("Opción inválida.")

💪 Ejercicio 2 — Promedio de calificaciones

Pide al usuario un número de notas, guárdalas en una lista y calcula su promedio.

n = int(input("¿Cuántas notas vas a ingresar?: "))
notas = []

for i in range(n):
    nota = float(input(f"Nota {i+1}: "))
    notas.append(nota)

promedio = sum(notas) / len(notas)
print(f"\nPromedio final: {promedio:.2f}")

💪 Ejercicio 3 — Filtrar productos con descuento

Usa comprensión de listas para obtener solo los productos que superan los 50 €.

precios = [25, 60, 40, 75, 15, 120]
caros = [p for p in precios if p > 50]
print("Productos con descuento:", caros)

💪 Ejercicio 4 — Combinar datos de listas

Combina dos listas (nombres y edades) y muéstralas ordenadas por edad.

nombres = ["Ana", "Carlos", "Elena", "Pablo"]
edades = [28, 19, 32, 25]

personas = list(zip(nombres, edades))
personas.sort(key=lambda x: x[1])

print("Personas ordenadas por edad:")
for nombre, edad in personas:
    print(f"{nombre} ({edad} años)")

💪 Ejercicio 5 — Análisis de notas

Crea un programa que analice las notas de un curso y muestre:

• Promedio.
• Nota más alta y más baja.
• Porcentaje de aprobados (nota ≥ 5).

notas = [8, 6, 4, 9, 5, 3, 7]

promedio = sum(notas) / len(notas)
maximo = max(notas)
minimo = min(notas)
aprobados = len([n for n in notas if n >= 5])
porcentaje = (aprobados / len(notas)) * 100

print(f"Promedio: {promedio:.2f}")
print(f"Máxima: {maximo}")
print(f"Mínima: {minimo}")
print(f"Aprobados: {porcentaje:.1f}%")

📊 Ejercicio final — Simulador de inventario avanzado

Combina todo lo aprendido creando un programa que gestione un inventario de productos:

# Estructura: [nombre, cantidad, precio]
inventario = [
    ["Camiseta", 15, 19.99],
    ["Pantalón", 10, 29.99],
    ["Zapatos", 5, 59.99]
]

def mostrar():
    print("\nInventario actual:")
    for nombre, cantidad, precio in inventario:
        print(f"{nombre}: {cantidad} uds a {precio}€")

def añadir():
    nombre = input("Producto nuevo: ")
    cantidad = int(input("Cantidad inicial: "))
    precio = float(input("Precio (€): "))
    inventario.append([nombre, cantidad, precio])
    print("Producto añadido correctamente.")

def vender():
    nombre = input("Producto vendido: ")
    cantidad = int(input("Cantidad vendida: "))
    for item in inventario:
        if item[0] == nombre:
            if item[1] >= cantidad:
                item[1] -= cantidad
                print("Venta realizada.")
            else:
                print("Stock insuficiente.")
            return
    print("Producto no encontrado.")

while True:
    print("\n1. Mostrar inventario")
    print("2. Añadir producto")
    print("3. Registrar venta")
    print("4. Salir")

    opcion = input("Opción: ")
    if opcion == "1": mostrar()
    elif opcion == "2": añadir()
    elif opcion == "3": vender()
    elif opcion == "4": break
    else: print("Opción inválida.")

Con este ejercicio se integran todos los conocimientos del módulo: creación, acceso, modificación, iteración, búsqueda y eliminación en listas.

🏁 Conclusión del módulo: Estructuras de datos (Listas)

Has aprendido a dominar las listas, una herramienta esencial del lenguaje Python. Con ellas puedes:

• Almacenar colecciones de datos.
• Modificar y transformar información fácilmente.
• Procesar, filtrar y analizar datos en tiempo real.

El dominio de las listas es un pilar fundamental para continuar hacia estructuras más complejas como tuplas, diccionarios y conjuntos.

¡Excelente trabajo! 👏 Ahora estás preparado para avanzar hacia las siguientes estructuras de datos del curso.