Tutorial Python: Listas

Creación y acceso

Las listas en Python son una de las estructuras de datos más versátiles y utilizadas. Podemos imaginarlas como una colección ordenada de elementos, similar a una fila de cajones numerados donde podemos guardar cualquier tipo de objeto.

Creación de listas

Existen varias formas de crear listas en Python. La más común es utilizando corchetes []:

# Lista vacía
mi_lista = []

# Lista con elementos
frutas = ["manzana", "plátano", "naranja"]

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

También podemos crear listas utilizando la función list():

# Crear una lista vacía
nueva_lista = list()

# Convertir otros tipos de datos en listas
numeros = list(range(1, 6))  # Crea [1, 2, 3, 4, 5]
letras = list("Python")      # Crea ['P', 'y', 't', 'h', 'o', 'n']

Acceso a elementos

Para acceder a los elementos de una lista, utilizamos índices numéricos. En Python, los índices comienzan en 0:

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

primera_tarea = tareas[0]  # "estudiar"
segunda_tarea = tareas[1]  # "hacer ejercicio"

Python también permite utilizar índices negativos para acceder a los elementos desde el final de la lista:

ultima_tarea = tareas[-1]    # "descansar"
penultima_tarea = tareas[-2] # "programar"

Este diagrama muestra cómo funcionan los índices en una lista:

 ["estudiar", "hacer ejercicio", "programar", "descansar"]
    ↑            ↑                 ↑            ↑
    0            1                 2            3
   -4           -3                -2           -1

Acceso a sublistas (slicing)

Python permite extraer porciones de una lista mediante la técnica de "slicing" (rebanado):

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

# Sintaxis: lista[inicio:fin:paso]
# Obtiene elementos desde el índice 'inicio' hasta 'fin-1'

primeros_tres = numeros[0:3]     # [10, 20, 30]
del_segundo_al_cuarto = numeros[1:4]  # [20, 30, 40]

# Si omitimos el inicio, comienza desde el principio
hasta_el_tercero = numeros[:3]   # [10, 20, 30]

# Si omitimos el fin, llega hasta el final
desde_el_tercero = numeros[2:]   # [30, 40, 50, 60, 70]

# Podemos usar un tercer parámetro para definir el paso
pares = numeros[::2]             # [10, 30, 50, 70]

# Índices negativos también funcionan en slicing
ultimos_tres = numeros[-3:]      # [50, 60, 70]

Verificación de elementos

Podemos comprobar si un elemento existe en una lista utilizando el operador in:

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

if "pan" in compras:
    print("Pan está en la lista de compras")
    
if "queso" not in compras:
    print("Necesito añadir queso a la lista")

Obtener información de la lista

Para conocer la longitud de una lista (número de elementos), utilizamos la función len():

tareas = ["estudiar", "hacer ejercicio", "programar", "descansar"]
cantidad_tareas = len(tareas)  # 4

También podemos encontrar la posición de un elemento con el método index():

posicion = tareas.index("programar")  # 2

Si el elemento aparece varias veces, index() devuelve la posición de la primera ocurrencia:

numeros = [5, 10, 15, 10, 25]
posicion_10 = numeros.index(10)  # 1 (primera ocurrencia)

Si intentamos buscar un elemento que no existe, Python lanzará un error:

try:
    posicion = tareas.index("dormir")  # ValueError: 'dormir' is not in list
except ValueError:
    print("Esa tarea no está en la lista")

Para contar cuántas veces aparece un elemento en la lista, usamos el método count():

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

Las listas en Python son mutables, lo que significa que podemos modificar sus elementos después de crearlas. Esto las diferencia de otras estructuras de datos como las tuplas o las cadenas de texto, que son inmutables. En la siguiente sección veremos los métodos principales para manipular listas.

Métodos principales

Las listas en Python incluyen una variedad de métodos integrados que nos permiten manipular su contenido de forma eficiente. Estos métodos son funciones que pertenecen a los objetos de tipo lista y nos ayudan a realizar operaciones comunes sin tener que escribir código desde cero.

Métodos para añadir elementos

Para agregar elementos a una lista, disponemos de varios métodos:

• append(): Añade un elemento al final de la lista.

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

• insert(): Inserta un elemento en una posición específica.

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

• extend(): Añade los elementos de otra lista (u otro iterable) al final.

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

La diferencia entre append() y extend() es importante:

lista1 = [1, 2, 3]
lista2 = [4, 5]

# Con append, añade la lista completa como un único elemento
lista1.append(lista2)
print(lista1)  # [1, 2, 3, [4, 5]]

# Con extend, añade cada elemento individualmente
lista1 = [1, 2, 3]  # Reiniciamos la lista
lista1.extend(lista2)
print(lista1)  # [1, 2, 3, 4, 5]

Métodos para eliminar elementos

Para eliminar elementos de una lista, tenemos estas opciones:

• remove(): Elimina la primera ocurrencia de un valor específico.

colores = ["rojo", "verde", "azul", "verde"]
colores.remove("verde")  # Elimina solo el primer "verde"
print(colores)  # ["rojo", "azul", "verde"]

• pop(): Elimina y devuelve el elemento en la posición indicada (o el último si no se especifica).

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

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

• clear(): Elimina todos los elementos de la lista.

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

• del: No es un método sino una instrucción que puede eliminar elementos o la lista completa.

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

# También puede eliminar secciones
numeros = [1, 2, 3, 4, 5]
del numeros[1:3]  # Elimina elementos en posiciones 1 y 2
print(numeros)  # [1, 4, 5]

Métodos para ordenar y reorganizar

• sort(): Ordena los elementos de la lista in-place (modifica la lista original).

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]

# Ordenar cadenas
palabras = ["zebra", "avión", "casa"]
palabras.sort()
print(palabras)  # ["avión", "casa", "zebra"]

• reverse(): Invierte el orden de los elementos.

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

Métodos para copiar listas

• copy(): Crea una copia superficial de la lista.

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

Métodos para obtener información

• count(): Cuenta cuántas veces aparece un elemento.

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

• index(): Encuentra la posición de la primera ocurrencia de un elemento.

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

# Podemos especificar desde dónde empezar a buscar
posicion = frutas.index("plátano", 2)  # Busca desde posición 2
print(posicion)  # 3 (segunda ocurrencia)

Ejemplo práctico: Lista de tareas

Veamos cómo podemos utilizar estos métodos en un ejemplo práctico de una lista de tareas:

# Inicializamos nuestra lista de tareas
tareas = ["Estudiar Python", "Hacer ejercicio"]

# Añadimos una nueva tarea
tareas.append("Comprar víveres")

# Insertamos una tarea urgente al principio
tareas.insert(0, "Llamar al médico")

# Marcamos una tarea como completada (la eliminamos)
tareas.remove("Hacer ejercicio")

# Añadimos varias tareas de una vez
mas_tareas = ["Lavar ropa", "Preparar cena"]
tareas.extend(mas_tareas)

# Ordenamos las tareas alfabéticamente
tareas.sort()

print("Lista de tareas:")
for i, tarea in enumerate(tareas, 1):
    print(f"{i}. {tarea}")

Este código generaría una salida como:

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

Métodos vs. funciones integradas

Algunos métodos de lista tienen equivalentes como funciones integradas de Python:

numeros = [3, 1, 4, 2]

# Usando el método sort()
numeros.sort()
print(numeros)  # [1, 2, 3, 4] - La lista original se modifica

# Usando la función sorted()
numeros = [3, 1, 4, 2]  # Reiniciamos la lista
numeros_ordenados = sorted(numeros)
print(numeros)           # [3, 1, 4, 2] - La lista original no cambia
print(numeros_ordenados) # [1, 2, 3, 4] - Nueva lista ordenada

La principal diferencia es que los métodos modifican la lista original (operaciones in-place), mientras que las funciones generalmente crean y devuelven nuevos objetos sin alterar los originales.

Estos métodos principales de las listas nos proporcionan herramientas potentes para manipular datos de forma eficiente, lo que hace que las listas sean una de las estructuras de datos más versátiles en Python.

Recorrido

Recorrer una lista en Python significa acceder a cada uno de sus elementos de forma secuencial. Esta operación es fundamental cuando necesitamos procesar, analizar o transformar los datos almacenados en una lista. Python ofrece varias técnicas para recorrer listas, cada una con sus propias ventajas según el contexto.

Recorrido con bucle for

El método más común y legible para recorrer una lista es utilizando un bucle for. Este enfoque nos permite procesar cada elemento de manera secuencial:

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

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

Este código imprimirá cada fruta precedida por el texto "Me gusta comer". El bucle for en Python es muy intuitivo porque nos permite trabajar directamente con los elementos, sin preocuparnos por los índices.

Recorrido con índices

En ocasiones necesitamos conocer la posición (índice) de cada elemento mientras recorremos la lista. Para esto, podemos utilizar la función enumerate():

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

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

La función enumerate() devuelve pares de (índice, elemento), lo que resulta muy útil cuando necesitamos tanto el valor como su posición. Por defecto, los índices comienzan en 0, pero podemos modificar esto:

# Comenzando desde 1 para una numeración más natural
for num, tarea in enumerate(tareas, 1):
    print(f"Tarea {num}: {tarea}")

Recorrido con range y len

Si necesitamos un control más tradicional sobre los índices, podemos combinar range() y len():

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

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

Este método es especialmente útil cuando necesitamos:

• Modificar elementos de la lista original durante el recorrido
• Acceder a elementos en posiciones relativas (anterior o siguiente)
• Recorrer la lista en un orden específico (por ejemplo, de atrás hacia adelante)

Recorrido inverso

Para recorrer una lista en orden inverso, tenemos varias opciones:

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

# Opción 1: usando reversed()
for color in reversed(colores):
    print(color)

# Opción 2: usando índices negativos con range
for i in range(len(colores)-1, -1, -1):
    print(colores[i])

La función reversed() es más legible y eficiente, mientras que el enfoque con range() nos da más control sobre los índices.

Recorrido con comprensión de listas

Las comprensiones de listas nos permiten recorrer y transformar elementos en una sola línea de código:

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

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

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

Esta técnica es muy expresiva y eficiente para operaciones de transformación y filtrado.

Recorrido de múltiples listas en paralelo

Para recorrer varias listas simultáneamente, podemos usar la función zip():

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}")

La función zip() combina elementos de múltiples iterables, deteniéndose cuando se agota la lista más corta.

Recorrido con while

Aunque menos común para listas, el bucle while puede ser útil en ciertos escenarios:

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

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

Este enfoque es más verboso que un bucle for, pero ofrece mayor flexibilidad para controlar el flujo de la iteración.

Ejemplo práctico: Análisis de calificaciones

Veamos un ejemplo que combina varias técnicas de recorrido para analizar calificaciones:

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

# Calcular estadísticas básicas
total = 0
maximo = calificaciones[0]
minimo = calificaciones[0]

for nota in calificaciones:
    total += nota
    if nota > maximo:
        maximo = nota
    if nota < minimo:
        minimo = nota

promedio = total / len(calificaciones)

# Identificar calificaciones por encima y debajo del promedio
por_encima = [nota for nota in calificaciones if nota > promedio]
por_debajo = [nota for nota in calificaciones if nota < promedio]

print(f"Calificaciones: {calificaciones}")
print(f"Promedio: {promedio:.2f}")
print(f"Calificación más alta: {maximo}")
print(f"Calificación más baja: {minimo}")
print(f"Notas por encima del promedio: {por_encima}")
print(f"Notas por debajo del promedio: {por_debajo}")

Este código analiza una lista de calificaciones, calculando estadísticas y clasificando las notas en relación al promedio.

Consideraciones de rendimiento

Al recorrer listas grandes, es importante considerar el rendimiento:

• El recorrido directo con for elemento in lista es generalmente el más eficiente
• Las comprensiones de listas suelen ser más rápidas que los bucles equivalentes
• Evita modificar el tamaño de la lista mientras la recorres (puede causar comportamientos inesperados)

# Forma incorrecta: modificar la lista mientras se recorre
numeros = [1, 2, 3, 4, 5]
for num in numeros:
    if num % 2 == 0:
        numeros.remove(num)  # ¡Esto puede causar problemas!

# Forma correcta: crear una nueva lista
numeros = [1, 2, 3, 4, 5]
impares = [num for num in numeros if num % 2 != 0]

El recorrido de listas es una operación fundamental en Python que nos permite procesar datos de forma eficiente. Dominar las diferentes técnicas de recorrido nos ayuda a escribir código más limpio, expresivo y eficiente para una amplia variedad de tareas de programación.

Modificación

La modificación de listas en Python es una de las características que las hace extremadamente versátiles. A diferencia de otras estructuras de datos inmutables como las tuplas o las cadenas, las listas pueden alterarse después de su creación, lo que nos permite adaptarlas a las necesidades cambiantes de nuestros programas.

Modificación de elementos individuales

La forma más directa de modificar una lista es asignando un nuevo valor a una posición específica mediante su índice:

frutas = ["manzana", "plátano", "naranja", "uva"]
frutas[1] = "pera"  # Reemplaza "plátano" por "pera"
print(frutas)  # ["manzana", "pera", "naranja", "uva"]

Este enfoque es sencillo y directo cuando conocemos exactamente qué posición queremos modificar. También podemos usar índices negativos:

colores = ["rojo", "verde", "azul"]
colores[-1] = "amarillo"  # Modifica el último elemento
print(colores)  # ["rojo", "verde", "amarillo"]

Modificación de múltiples elementos con slicing

El slicing no solo nos permite acceder a porciones de una lista, sino también modificarlas:

numeros = [1, 2, 3, 4, 5]
numeros[1:4] = [20, 30, 40]  # Reemplaza los elementos en posiciones 1, 2 y 3
print(numeros)  # [1, 20, 30, 40, 5]

Una característica interesante es que el tamaño del reemplazo no tiene que coincidir con el tamaño del slice:

letras = ["a", "b", "c", "d", "e"]
letras[1:4] = ["X", "Y"]  # Reemplaza tres elementos con dos
print(letras)  # ["a", "X", "Y", "e"]

secuencia = [1, 2, 3]
secuencia[1:2] = [10, 20, 30]  # Reemplaza un elemento con tres
print(secuencia)  # [1, 10, 20, 30, 3]

Esta flexibilidad nos permite expandir o contraer la lista durante la modificación.

Modificación mediante métodos de lista

Aunque ya vimos los métodos principales en una sección anterior, es importante entender cómo se utilizan específicamente para modificar listas:

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

# Modificar añadiendo al final
tareas.append("leer")

# Modificar insertando en una posición específica
tareas.insert(1, "desayunar")

# Modificar eliminando elementos
tareas.remove("ejercicio")

# Modificar eliminando por posición
tarea_eliminada = tareas.pop(2)

Modificación condicional de elementos

A menudo necesitamos modificar elementos basándonos en alguna condición. Podemos hacerlo con un bucle:

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

# Aplicar un descuento del 10% a todos los productos que cuesten más de 15
for i in range(len(precios)):
    if precios[i] > 15:
        precios[i] = round(precios[i] * 0.9, 2)  # 10% de descuento

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

Modificación con comprensión de listas

Para modificaciones más complejas, podemos crear una nueva lista con los cambios aplicados:

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

# Crear una nueva lista con los valores modificados
numeros_modificados = [num * 2 if num % 2 == 0 else num for num in numeros]
print(numeros_modificados)  # [1, 4, 3, 8, 5]

Si necesitamos modificar la lista original, podemos reasignarla:

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

Modificación de listas anidadas

Las listas pueden contener otras listas, creando estructuras multidimensionales:

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

# Modificar un elemento específico
matriz[1][2] = 60  # Modifica el valor en la fila 1, columna 2
print(matriz)  # [[1, 2, 3], [4, 5, 60], [7, 8, 9]]

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

Modificación mediante operaciones de lista

Python ofrece operadores que facilitan ciertas modificaciones:

# Concatenación con el operador +
lista1 = [1, 2, 3]
lista2 = [4, 5]
lista_combinada = lista1 + lista2  # Crea una nueva lista
print(lista_combinada)  # [1, 2, 3, 4, 5]

# Multiplicación con el operador *
patrones = ["A", "B"]
patron_repetido = patrones * 3
print(patron_repetido)  # ["A", "B", "A", "B", "A", "B"]

# Modificar la lista original con +=
numeros = [1, 2, 3]
numeros += [4, 5]  # Equivalente a numeros.extend([4, 5])
print(numeros)  # [1, 2, 3, 4, 5]

Ejemplo práctico: Gestión de inventario

Veamos un ejemplo práctico de modificación de listas para gestionar un inventario simple:

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

# 1. Actualizar el precio de un producto
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")

# 2. Actualizar el stock después de una venta
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")

# 3. Añadir nuevo producto al inventario
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} unidades")
            return
    # Si el producto no existe, lo añadimos
    inventario.append([producto, cantidad, precio])
    print(f"Nuevo producto añadido: {producto}")

# Ejemplo de uso
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}€")

Consideraciones importantes

Al modificar listas, debemos tener en cuenta algunas consideraciones:

• Referencias compartidas: Cuando asignamos una lista a otra variable, ambas referencias apuntan al mismo objeto:

lista_a = [1, 2, 3]
lista_b = lista_a  # No crea una copia, ambas variables apuntan a la misma lista

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

• Creación de copias: Para modificar una lista sin afectar la original, necesitamos crear una copia:

original = [1, 2, 3]
copia = original.copy()  # Alternativas: list(original) o original[:]

copia[0] = 100  # Solo modifica la copia
print(original)  # [1, 2, 3]
print(copia)     # [100, 2, 3]

• Copias profundas: Para listas anidadas, necesitamos copias profundas:

import copy

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

copia_superficial[0][0] = 100  # Afecta a anidada también
copia_profunda[1][0] = 200     # No afecta a anidada

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

La capacidad de modificar listas de manera flexible es una de las características más potentes de Python, permitiéndonos adaptar nuestras estructuras de datos a medida que nuestros programas evolucionan. Dominar estas técnicas de modificación nos ayuda a escribir código más eficiente y expresivo para manipular datos.