Listas en Python (list): métodos, cortes, ordenación, append, tuplas y conjuntos

Una lista en Python (list) es un conjunto ordenado de valores cualesquiera entre corchetes que se puede modificar: añadir elementos al final, insertarlos en medio, eliminarlos, ordenarlos. Es la colección más utilizada del lenguaje: las líneas de un archivo, los gastos del mes, las respuestas de una API; casi todo empieza en una lista. En este artículo repasamos las listas en Python de principio a fin: creación, métodos, cortes, ordenación, comprensiones de listas y copias, y al final, las tuplas y los conjuntos.

Qué es una lista en Python

Una lista guarda los elementos en el orden en que se definieron y se accede a ellos por su índice, que empieza en cero. Una misma lista puede contener valores de distintos tipos, aunque en la práctica se suelen guardar datos del mismo tipo.

importes = [250, 1200, 99]
print(importes[0])     # 250 — primer elemento
print(importes[-1])    # 99 — último
importes[1] = 1300     # la lista es modificable
print(len(importes))   # 3 — longitud de la lista

El tamaño de una lista lo devuelve la función len(). Si se pide un índice que no existe, se produce IndexError: list index out of range.

Cómo crear una lista

vacia = []                       # lista vacía
tambien_vacia = list()           # lo mismo con la función list
numeros = [1, 2, 3]
letras = list("abc")             # ['a', 'b', 'c']
digitos = list(range(5))         # [0, 1, 2, 3, 4]
ceros = [0] * 4                  # [0, 0, 0, 0]

La función list() convierte en lista cualquier objeto iterable: una cadena, un range, un conjunto, las claves de un diccionario.

append y otros métodos de las listas

El método append añade un elemento al final de la lista; es el método más usado en Python. Modifica la lista en su lugar y devuelve None.

importes = [250, 1200]
importes.append(450)          # [250, 1200, 450]
importes.extend([10, 20])     # [250, 1200, 450, 10, 20]
importes.insert(0, 5)         # [5, 250, 1200, 450, 10, 20]
importes.remove(1200)         # elimina el primer valor 1200
ultimo = importes.pop()       # 20 — elimina y devuelve el último

Error frecuente: a.append([10, 20]) añade un único elemento, que es una lista anidada, y no dos números. Para añadir varios elementos se usa extend.

También se puede eliminar un elemento por su índice, o un rango completo, con la sentencia del: del a[0], del a[1:3]. Otras funciones integradas útiles con listas son len, sum, min, max, sorted, reversed, enumerate y zip.

Cortes de listas en Python

Un corte toma una parte de la lista con la forma a[inicio:fin:paso]: desde inicio incluido hasta fin excluido, con el paso paso. Cualquier parte puede omitirse. Un corte siempre devuelve una lista nueva.

a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — los dos primeros
print(a[-2:])     # [4, 5] — los dos últimos
print(a[::2])     # [0, 2, 4] — uno de cada dos
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — invertida
print(a[:])       # copia de toda la lista

A diferencia del índice, un corte fuera de la lista no provoca error: a[10:20] devuelve simplemente []. A un corte se le puede asignar un valor para reemplazar un trozo de la lista: a[1:3] = ["x", "y", "z"].

Corte de una cadena

Los cortes funcionan igual con cualquier secuencia, también con cadenas y tuplas:

s = "Python 3.15"
print(s[:6])      # Python
print(s[-4:])     # 3.15
print(s[::-1])    # 51.3 nohtyP

Una cadena no se puede modificar con un corte: las cadenas son inmutables, y el corte crea una cadena nueva.

Ordenar una lista: sort y sorted

Aquí es donde más se equivocan los principiantes. El método sort reordena los elementos de la propia lista y devuelve None. La función sorted no toca la lista original y devuelve una nueva ya ordenada.

importes = [250, 1200, 99]
importes.append(450)
print(sorted(importes))    # [99, 250, 450, 1200] — copia nueva
print(importes)            # [250, 1200, 99, 450] — la original sigue igual

resultado = importes.sort()   # ordena en su lugar
print(resultado, importes)    # None [99, 250, 450, 1200]

De aquí sale el clásico «¿por qué me sale None?»: a = a.sort() sustituye la lista por el valor None. Escriba a.sort() o bien a = sorted(a).

Clave y orden inverso

Ambos admiten los parámetros key y reverse. key es una función cuyo resultado se usa para comparar los elementos.

palabras = ["café", "Taxi", "suscripción"]
print(sorted(palabras, key=len))               # ['café', 'Taxi', 'suscripción']
print(sorted(palabras, key=str.lower))         # sin distinguir mayúsculas
print(sorted([3, 1, 2], reverse=True))         # [3, 2, 1]

gastos = [("Comida", 650), ("Cine", 120), ("Taxi", 300)]
gastos.sort(key=lambda g: g[1])                # por importe

La ordenación en Python es estable: los elementos con la misma clave conservan su orden original. Además, sorted acepta cualquier secuencia (una cadena, un diccionario, un conjunto), mientras que sort solo existe en las listas.

Invertir una lista

Hay tres formas, con comportamientos distintos:

• a.reverse() — invierte en su lugar y devuelve None;
• a[::-1] — crea una lista nueva invertida;
• reversed(a) — un iterador perezoso, cómodo en un bucle: for x in reversed(a):.

Recorrer una lista

productos = ["café", "metro", "cine"]
for producto in productos:
    print(producto)

for i, producto in enumerate(productos, start=1):
    print(i, producto)          # 1 café, 2 metro, 3 cine

print("cine" in productos)      # True — comprobación de pertenencia

No elimine elementos de la lista que se está recorriendo en un bucle: algunos se saltarán. Construya una lista nueva con una comprensión o recorra una copia a[:].

Comprensiones de listas (list comprehension)

Una comprensión de lista construye una lista nueva en una sola línea: una expresión, un bucle y una condición opcional.

cuadrados = [n * n for n in range(6)]              # [0, 1, 4, 9, 16, 25]
grandes = [a for a in [250, 1200, 99] if a > 200]  # [250, 1200]
nombres = [s.strip().title() for s in [" ana ", "oscar"]]

Las comprensiones suelen ser más rápidas y legibles que un bucle con append. Pero si la lógica no cabe en una línea clara, es mejor un bucle normal.

Unir, sumar y restar listas

a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — lista nueva
a += b             # equivale a a.extend(b)
print([*a, *b])    # desempaquetado en una lista nueva

No existe el operador - para restar listas. Para quitar de una lista los elementos de otra, use una comprensión: [x for x in a if x not in set(b)]. Los elementos comunes de dos listas se obtienen cómodamente con conjuntos: set(a) & set(b) (así se pierden el orden y los duplicados).

Listas anidadas y bidimensionales

Una lista de listas es una forma sencilla de guardar una tabla o una matriz:

matriz = [[1, 2, 3], [4, 5, 6]]
print(matriz[1][2])     # 6
cuadricula = [[0] * 3 for _ in range(2)]   # correcto
mal = [[0] * 3] * 2                        # trampa: dos referencias a la misma lista
mal[0][0] = 9
print(mal)              # [[9, 0, 0], [9, 0, 0]]

Desempaquetar una lista

primero, segundo, tercero = [10, 20, 30]
cabeza, *resto = [1, 2, 3, 4]      # cabeza=1, resto=[2, 3, 4]
print(*["a", "b"], sep=", ")       # a, b — print de una lista sin corchetes

Si el número de variables no coincide con la longitud de la lista, se produce un ValueError; en ese caso ayuda el asterisco.

Copiar una lista

b = a no copia la lista: pone una segunda etiqueta sobre el mismo objeto, y los cambios hechos a través de b se ven en a. Una copia independiente se hace de forma explícita: a.copy(), list(a) o a[:]. Con datos anidados no basta: las listas internas siguen compartidas, y hace falta copy.deepcopy(a).

import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — la lista anidada es común
c = copy.deepcopy(a)     # copia totalmente independiente

Tuplas: una lista inmutable

Una tupla (tuple) se parece a una lista, pero no se puede modificar tras crearla. Es una señal clara para quien lee el código: aquí hay un registro de campos fijos, no un conjunto que crece. Las tuplas se desempaquetan con facilidad, y las funciones devuelven varios valores precisamente como tuplas.

gasto = (250, "Café")
importe, producto = gasto
gasto[0] = 300
# TypeError: 'tuple' object does not support item assignment

Una tupla formada solo por valores inmutables es hashable, así que puede servir como clave de un diccionario. Una tupla de un solo elemento se escribe con coma: (5,).

Conjuntos: solo valores únicos

Un conjunto (set) guarda únicamente valores distintos y no conserva el orden. Es la forma más rápida de eliminar duplicados y de comprobar si un elemento existe, y además permite calcular intersecciones, uniones y diferencias.

enero = {"Comida", "Taxi", "Cine"}
febrero = {"Comida", "Suscripciones"}
print(enero & febrero)    # {'Comida'}
print(febrero - enero)    # {'Suscripciones'}
unicos = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — sin duplicados, orden conservado
vacio = set()             # {} daría un dict vacío, no un conjunto

Qué colección elegir

La comprobación x in lista recorre los elementos uno a uno, mientras que x in conjunto es casi instantánea. Si dentro de un bucle se busca muchas veces en una lista grande, conviértala en un conjunto.

Resumen

La lista de Python es una colección ordenada y modificable: append y extend añaden, pop y remove eliminan, los cortes a[inicio:fin:paso] toman partes, sort ordena en su lugar y devuelve None, y sorted devuelve una lista nueva. Haga las copias de forma explícita; para registros fijos use una tupla y para valores únicos, un conjunto. Las listas, las tuplas, los diccionarios y los conjuntos se practican en el curso «Python 3.15: de principiante a profesional».