# Listas en Python (list): métodos, cortes, ordenación, append, tuplas y conjuntos URL: https://skillaria.top/es/guides/python/listas-python Una lista en Python (list) es una colección ordenada y modificable de valores entre corchetes, por ejemplo [250, 1200, 99]: se pueden añadir elementos con append, insertarlos, eliminarlos, tomar partes con cortes y ordenarlos. El método sort ordena la lista en su lugar y devuelve None, mientras que la función sorted devuelve una lista nueva ordenada. 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`. | Método | Qué hace | | --- | --- | | `append(x)` | añade x al final | | `extend(iter)` | añade todos los elementos de una secuencia | | `insert(i, x)` | inserta x antes del índice i | | `remove(x)` | elimina la primera aparición de x (ValueError si no existe) | | `pop(i=-1)` | elimina y devuelve el elemento del índice i | | `index(x)` | índice de la primera aparición | | `count(x)` | cuántas veces aparece x | | `sort()` | ordena en su lugar | | `reverse()` | invierte en su lugar | | `copy()` | copia superficial | | `clear()` | vacía la lista | 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 | Tarea | Colección | | --- | --- | | Orden y modificaciones | `list` | | Registro de campos fijos | `tuple` | | Búsqueda por clave | `dict` | | Unicidad, comprobar si existe | `set` | | Configuración inmutable | `frozendict` (Python 3.15) | 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». ## FAQ **¿En qué se diferencia una lista de un array en Python?** Python no tiene un array integrado en el sentido de otros lenguajes; su papel lo cumple la lista, que puede guardar valores de tipos distintos. Para arrays numéricos compactos existen el módulo array y la biblioteca NumPy. **¿Cómo encontrar el índice de un elemento en una lista?** El método a.index(x) devuelve el índice de la primera aparición y provoca ValueError si el elemento no existe. Por eso conviene comprobar antes x in a. **¿Cómo eliminar duplicados de una lista manteniendo el orden?** Use list(dict.fromkeys(a)): el diccionario guarda las claves sin repetir y en orden de inserción. La variante list(set(a)) también elimina duplicados, pero no conserva el orden. **¿Cómo unir una lista de cadenas en una sola cadena?** Con el método join de las cadenas: ", ".join(["a", "b", "c"]) da "a, b, c". Todos los elementos deben ser cadenas; los números se convierten antes con map(str, a). **¿Se pueden guardar en una lista elementos de tipos distintos?** Sí, una lista puede contener números, cadenas, otras listas y objetos a la vez. Pero ordenar una lista así sin el parámetro key normalmente no es posible: comparar un número con una cadena provoca TypeError. --- Source: Skillaria.Top (https://skillaria.top)