Listas y tuplas en Python

Una lista conserva valores en un orden elegido. Escribe los elementos entre corchetes, separados por comas. Cada elemento tiene una posición, por lo que los valores repetidos siguen ocupando lugares distintos.

Construye y mide una lista

scores = [88, 92, 75]
print(scores)
print(len(scores))

Salida:

[88, 92, 75]
3

len() cuenta elementos, no el valor más alto ni la posición final. Las listas pueden contener tipos mixtos, como en [3, "three", 3.0, True], aunque agrupar datos relacionados suele facilitar su procesamiento. Tanto [] como list() crean una lista vacía. Su longitud es 0, y puede crecer a medida que el programa recopila valores.

list() también puede reunir los elementos de un iterable, un objeto que un bucle for puede recorrer. list(range(4)) da [0, 1, 2, 3]. list("cat") da ['c', 'a', 't']: la cadena aporta un carácter cada vez. El resultado es una lista nueva.

Cuenta posiciones desde cero

Un índice identifica una posición. Python empieza en 0, por lo que las tres puntuaciones tienen los índices 0, 1 y 2.

Los índices negativos cuentan hacia atrás desde el final. Para una lista de longitud n, los índices válidos van de -n a n - 1. El último elemento es scores[len(scores) - 1] o, más sencillamente, scores[-1]. -0 sigue siendo 0; no significa la última posición.

Reconoce un índice no válido

scores[3] lanza IndexError porque no existe un cuarto elemento. scores[len(scores)] comete el mismo error: el número de elementos es uno mayor que el último índice no negativo. Una lista vacía no tiene ningún índice de elemento válido, incluido -1.

Un índice de lista debe ser un entero, no un número de coma flotante. scores[1.0] lanza TypeError, aunque 1,0 tenga un valor entero. / produce un número de coma flotante, por lo que scores[len(scores) / 2] también falla. Con esta lista de tres elementos, len(scores) // 2 produce el entero 1, y scores[1] es 92.

Comprueba si aparece un valor

La pertenencia comprueba valores, no posiciones:

colors = ["red", "green"]
print("green" in colors)
print("Green" in colors)
print("blue" not in colors)

Salida:

True
False
True

in y not in devuelven valores booleanos y también funcionan con listas vacías. Las comparaciones de cadenas distinguen entre mayúsculas y minúsculas, por lo que "Green" y "green" no coinciden. Una comprobación de pertenencia es útil antes de una operación que requiera que un valor esté presente, como eliminarlo o encontrar su posición.

Un segmento selecciona una secuencia de elementos y devuelve una secuencia nueva. Para una lista, el resultado es otra lista, incluso cuando contiene un solo elemento o ninguno.

Incluye el inicio y excluye el límite final

letters = ["a", "b", "c", "d", "e", "f"]
print(letters[1:4])

Salida:

['b', 'c', 'd']

Las posiciones seleccionadas son 1, 2 y 3. La posición 4 es el límite de parada, por lo que 'e' queda fuera. Con un paso de 1 y límites que cumplan 0 <= start <= stop <= len(letters), el número de elementos seleccionados es stop - start. Aquí es 3. letters[4:2] da [] porque un segmento que avanza no puede alcanzar un límite final anterior.

Omite un límite

Los límites negativos cuentan desde el final igual que los índices negativos. letters[:n] y letters[n:] dividen la lista en un mismo límite. Unir esos dos segmentos reconstruye su contenido en el orden original.

Controla el paso

La forma completa es values[start:stop:step]. Un paso de 2 selecciona una posición, omite una y selecciona la siguiente. letters[::2] da ['a', 'c', 'e'], mientras que letters[1::2] da ['b', 'd', 'f'].

Un paso negativo retrocede. letters[::-1] empieza en el último elemento y produce ['f', 'e', 'd', 'c', 'b', 'a']. Para un segmento hacia atrás con límites, letters[4:1:-1] recorre los índices 4, 3 y 2, dando ['e', 'd', 'c']; el límite final sigue excluido. Un paso de 0 lanza ValueError porque no puede desplazarse a otra posición.

Distingue un límite de una posición

Los límites de los segmentos pueden sobrepasar cualquiera de los extremos. Python los ajusta: letters[4:100] es ['e', 'f'], y letters[10:] es []. Estos segmentos no lanzan IndexError. Leer el elemento individual letters[10] sí lo hace.

letters[2] es la cadena 'c'. letters[2:3] es la lista ['c']. Los dos puntos cambian el tipo de resultado, lo que importa cuando el código posterior espera una cadena o una lista.

Trabaja con el resultado

Tras first_three = letters[:3], asignar first_three[0] = "z" modifica solo esa lista externa nueva; letters[0] sigue siendo 'a'. Un segmento completo es una copia superficial, por lo que los elementos mutables anidados pueden seguir compartidos.

Las cadenas y las tuplas siguen las mismas reglas de límites y paso. El resultado conserva el tipo de la secuencia original: "python"[1:4] da 'yth', y (10, 20, 30)[1:] da (20, 30).

Las listas admiten operadores para construir secuencias y funciones para resumir sus valores. Comprueba si una operación crea una lista nueva, produce un número o devuelve texto: esos resultados sirven para tareas distintas.

Une o repite listas

+ une dos listas y crea una lista nueva. [1, 2] + [3] da [1, 2, 3] sin modificar ninguna de las entradas. Ambos operandos deben ser listas: [1, 2] + 3 lanza TypeError. Coloca un único valor adicional en una lista de un elemento al usar +.

* repite la secuencia. [0] * 4 da [0, 0, 0, 0], y ["ab", "cd"] * 2 da ['ab', 'cd', 'ab', 'cd']. Repite elementos, no los caracteres de cada cadena. Una cantidad de repeticiones de cero o negativa da []. counts = [0] * 7 proporciona siete contadores iniciales. Repetir una lista interna hace que se comparta entre posiciones, lo que importa cuando esas filas se modifican después.

Suma, extremos y media

sum() suma números. No une cadenas; sum(["a", "b"]) lanza TypeError. min() y max() encuentran los elementos menor y mayor, por lo que los elementos deben admitir comparaciones entre sí. Las listas formadas solo por cadenas funcionan: max(["pear", "apple"]) da 'pear' mediante el orden carácter a carácter. Una lista vacía no tiene mínimo ni máximo y lanza ValueError con cualquiera de las dos llamadas.

La media es la suma dividida entre el número de elementos:

temps = [18.5, 21.0, 19.5, 23.0]
if temps:
    total = sum(temps)
    mean = total / len(temps)
    print(total, mean)

Salida:

82.0 20.5

La condición funciona porque las listas vacías se consideran falsas y las no vacías, verdaderas. Sin la condición de protección, calcular la media de [] dividiría entre cero y lanzaría ZeroDivisionError. Elige qué debe hacer el programa cuando no haya lecturas, como devolver None.

Compara secuencias en orden

== comprueba que coincidan los elementos en las mismas posiciones. [1, 2, 3] == [1, 2, 3] es True; [1, 2, 3] == [3, 2, 1] es False.

Para < y >, compara desde la izquierda y detente en el primer par desigual. [2, 9] < [3, 0] es True porque 2 es menor que 3. El 9 y el 0 no deciden nada. Cuando una lista es el comienzo de otra, la más corta va primero: [2] < [2, 0] es True.

Pasa entre texto y listas

colors = "red,green,blue".split(",")
print(colors)
print(", ".join(["red", "green"]))

Salida:

['red', 'green', 'blue']
red, green

split() divide una cadena por su separador. join() se llama sobre el separador y lo coloca entre las cadenas recibidas. Cada elemento debe ser una cadena. Para unir números, construye primero una lista de los resultados de aplicarles str(); pasar [1, 2] directamente a join() lanza TypeError.

Las listas son mutables: un programa puede modificar su contenido después de crearlas. Un método pertenece a un objeto y se llama con un punto, como en cart.append("eggs"). Su efecto sobre la lista y su valor de retorno son dos cosas distintas.

Añade un elemento o varios

cart = ["milk"]
cart.append("eggs")
cart.extend(["tea", "jam"])
print(cart)

Salida:

['milk', 'eggs', 'tea', 'jam']

append(x) añade exactamente un elemento al final. Si x es una lista, toda esa lista se convierte en un único elemento anidado. Partiendo de ['milk', 'eggs'], cart.append(["tea", "jam"]) produce ['milk', 'eggs', ['tea', 'jam']], de longitud 3.

extend(iterable) añade por separado los elementos que aporta el iterable. Ampliar con ["tea", "jam"] hace que la longitud de la lista de compras sea 4. Ampliar con "ab" añade 'a' y 'b' por separado; usa append con la cadena para conservar 'ab' como un único elemento.

insert(i, x) añade un elemento antes de la posición actual i. Tras nums = [10, 30] y nums.insert(1, 20), la lista es [10, 20, 30]. Los elementos posteriores se desplazan a la derecha. insert(0, x) añade al principio; un índice más allá del final añade al final sin un error de índice.

Elimina por posición o por valor

Con nums = [10, 20, 30], last = nums.pop() guarda 30 y deja [10, 20]. Después, nums.pop(0) devuelve 10 y deja [20]. Una lista vacía o una posición no válida hace que pop() lance IndexError.

remove() recibe un valor. Con pets = ["cat", "dog", "cat"], pets.remove("cat") deja ['dog', 'cat']. Solo desaparece la primera coincidencia. Si el valor está ausente, remove() lanza ValueError. Usa una comprobación de pertenencia cuando pueda faltar. Para eliminar todos los elementos 'cat', usa:

while "cat" in pets:
    pets.remove("cat")

Con [5, 0, 7], remove(0) elimina el valor 0 y deja [5, 7]; pop(0) elimina el valor de la posición 0 y da [0, 7]. El significado del argumento determina el método.

del puede eliminar un rango: partiendo de [5, 6, 7, 8], del nums[1] deja [5, 7, 8], y después del nums[0:2] deja [8]. clear() deja vacía la lista existente.

Ten claro el valor de retorno

append, extend, insert, remove y clear devuelven None. Escribe cart.append("tea") en una línea independiente. Escribir cart = cart.append("tea") hace que cart se refiera a None; una llamada posterior a cart.append("jam") lanza AttributeError. Guarda el resultado de un método solo cuando aporte un valor que el programa necesite, como hace last = cart.pop().

Encontrar un valor, contarlo y sustituirlo son operaciones distintas. Usa una comprobación de pertenencia cuando necesites una respuesta de sí o no, un método de búsqueda cuando necesites una posición y una asignación cuando quieras modificar la lista.

Encuentra la primera posición coincidente

days = ["Mon", "Tue", "Wed", "Tue"]
print(days.index("Tue"))
print(days.index("Tue", 2))
print(days.count("Tue"))
print(days.count("Sun"))

Salida:

1
3
2
0

index(x) devuelve la primera posición que contiene un valor igual a x. Su argumento de inicio opcional indica a Python dónde empezar a buscar. days.index("Tue", 2) omite la coincidencia de la posición 1 y encuentra la de la posición 3. La respuesta sigue siendo un índice de la lista completa, no un recuento desde el nuevo punto de inicio.

index() lanza ValueError cuando el valor está ausente. Las listas no tienen un método find() que devuelva -1. Si se prevé que un valor pueda faltar, comprueba primero la pertenencia:

if "Sun" in days:
    position = days.index("Sun")
    print(position)

Este código no muestra nada porque 'Sun' está ausente. count(x) puede usarse sin esa protección: devuelve 0 cuando no hay coincidencias. Estas operaciones usan la igualdad, por lo que [1, 2.0].count(2) es 1. El texto sigue distinguiendo mayúsculas de minúsculas: 'tue' no es igual a 'Tue'.

Sustituye un elemento existente

prices = [4.5, 3.0, 7.25]
prices[1] = 3.5
print(prices)

Salida:

[4.5, 3.5, 7.25]

El segundo valor anterior se sobrescribe y la longitud sigue siendo 3. El índice debe existir: prices[3] = 1.0 lanza IndexError. Para añadir al final, usa append().

La sustitución usa una posición existente. La inserción crea una posición adicional antes de la posición seleccionada.

Sustituye un rango mediante asignación a un segmento

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

Salida:

[1, 20, 30, 40, 4, 5]
[30, 40, 4, 5]

La primera asignación sustituye los dos elementos de los índices 1 y 2 por tres elementos nuevos, aumentando la longitud de la lista en uno. Un segmento contiguo ordinario puede sustituirse por una secuencia más corta o más larga. Asignar [] elimina el rango seleccionado. Esto modifica la lista original; es distinto de leer un segmento y guardarlo en una variable nueva.

Edita texto construyendo texto nuevo

Una cadena es inmutable, por lo que word = "cat" seguido de word[0] = "b" lanza TypeError. Construye una cadena nueva con word = "b" + word[1:], o crea una lista de caracteres, modifícala y únela:

letters = list("cat")
letters[0] = "b"
word = "".join(letters)
print(word)

Salida:

bat

Un bucle puede usar los valores de una lista, sus posiciones o ambos. Elige la forma que aporte lo que necesita el cuerpo del bucle. Para modificar la lista, comprueba también si la sentencia cambia un elemento o solo revincula un nombre local.

Usa los elementos directamente

for name in ["Ana", "Ben"]:
    print("Hi", name)

Salida:

Hi Ana
Hi Ben

El bucle recorre cada elemento en orden. En cada iteración, name hace referencia al elemento actual. Asignar un valor diferente a name no sustituye ese elemento en la lista. En for r in readings: r = 0, solo cambia el nombre r.

Usa posiciones para sustituir elementos

readings = [3, -1, 4, -5]
for i in range(len(readings)):
    if readings[i] < 0:
        readings[i] = 0
print(readings)

Salida:

[3, 0, 4, 0]

range(len(readings)) proporciona 0, 1, 2 y 3. En el índice 1, la condición es verdadera, por lo que la asignación al elemento sustituye -1. En el índice 3, sustituye -5. Las lecturas positivas conservan sus valores. Usar range(len(readings) + 1) también llegaría al índice 4, que no existe.

Obtén una posición y un elemento juntos

enumerate() proporciona pares. Desempaqueta cada par en la cabecera del bucle:

for i, name in enumerate(["Ana", "Ben"]):
    print(i, name)

Salida:

0 Ana
1 Ben

enumerate(names, start=1) proporciona etiquetas que empiezan en 1 para una presentación numerada. Esas etiquetas ya no son los índices de la lista basados en cero. Para recorrer del último al primero sin modificar la lista, usa for item in reversed(names):. Para índices hacia atrás, usa range(len(names) - 1, -1, -1); una lista de tres elementos da 2, 1, 0.

Empareja dos listas

names = ["Ana", "Ben"]
scores = [90, 85]
for name, score in zip(names, scores):
    print(name, score)

Salida:

Ana 90
Ben 85

zip() empareja elementos de las mismas posiciones y se detiene en la entrada más corta. Si todos los registros importan, comprueba las longitudes antes de usarlo; de lo contrario, se omitirá un nombre final sin pareja.

Controla un índice con while

Un bucle while necesita un índice inicial, una comprobación de límites y un paso:

i = 0
while i < len(readings):
    print(readings[i])
    i += 1

Olvidar el incremento impide que este bucle termine. Usar <= llega a len(readings) y provoca IndexError.

Evita desplazar elementos durante un bucle for

Eliminar elementos cambia las posiciones de los que vienen después. Con [1, 2, 2, 3], eliminar cada 2 encontrado mientras se recorre esa misma lista deja [1, 2, 3]: el segundo 2 se desplaza a la posición recién visitada. Recorre nums[:] si las eliminaciones deben afectar a la original, o construye una lista nueva con los elementos que quieras conservar. Añadir elementos a la lista que se está recorriendo también puede hacer que el bucle se comporte de forma inesperada.

Muchos problemas con listas usan unos pocos patrones de bucle reutilizables. Decide qué resultado necesita el programa, inicialízalo antes del bucle y actualízalo a medida que llegue cada elemento.

Acumula una suma o un recuento

sales = [120, 75, 205, 50]
total = 0
for sale in sales:
    total += sale
print(total)

Salida:

450

La suma acumulada pasa a ser 120, 195, 400 y 450. Establecer total = 0 dentro del bucle borraría el trabajo anterior en cada iteración. sum(sales) realiza esta suma directamente.

Un contador suma 1 por cada elemento que cumple la condición, no el valor del elemento:

scores = [72, 45, 60, 88, 59]
passed = 0
for score in scores:
    if score >= 60:
        passed += 1
print(passed)

La salida es 3: 72, 60 y 88 cumplen la condición. > 60 daría 2 porque excluye exactamente 60. Mantén la redacción del umbral y la comparación en consonancia.

Encuentra un extremo

Para una lista no vacía, inicializa el máximo hasta el momento a partir de un elemento real:

temps = [-3, -8, -1, -5]
highest = temps[0]
for temp in temps[1:]:
    if temp > highest:
        highest = temp
print(highest)

La salida es -1. Empezar en 0 mantendría incorrectamente 0 porque todas las lecturas son menores. Usa < para encontrar el mínimo, o usa las funciones incorporadas min() y max(). Comprueba si la lista está vacía antes de acceder a su primer elemento.

Detente en la primera coincidencia

values = [4, 0, -2, 5, -7]
position = -1
for i, value in enumerate(values):
    if value < 0:
        position = i
        break
print(position)

La salida es 2. -1 es una señal elegida para indicar que no hay coincidencia; no la uses como índice salvo que la búsqueda haya tenido éxito, porque también es un índice válido para el último elemento. break conserva la primera posición coincidente. Sin él, las coincidencias posteriores sobrescribirían el resultado.

x in values comprueba un valor exacto, y values.index(x) encuentra su primera posición. Una condición como «es negativo» necesita una búsqueda basada en una condición, como el bucle anterior.

Filtra o transforma

Un filtro conserva elementos originales seleccionados:

passing = []
for score in scores:
    if score >= 60:
        passing.append(score)
print(passing)

La salida es [72, 60, 88]; scores conserva los cinco elementos. Una transformación calcula un elemento nuevo a partir de cada original:

nums = []
for text in ["3", "14", "15"]:
    nums.append(int(text))
print(nums, sum(nums))

La salida es [3, 14, 15] 32. La conversión ocurre antes de la suma; sumar las cadenas originales falla.

Devuelve un resultado reutilizable

def average(values):
    if not values:
        return None
    return sum(values) / len(values)

average([18.5, 21.0, 19.5, 23.0]) devuelve 20.5. El caso vacío devuelve None sin dividir entre cero, y la función deja la lista de entrada sin cambios.

Una lista anidada es una lista que contiene otras listas. Una tabla suele usar una lista interna por fila. Cada acceso selecciona un nivel, por lo que leer una celda requiere dos índices.

Selecciona la fila y después la celda

grid = [[1, 2, 3], [4, 5, 6]]
print(grid[1])
print(grid[1][2])
print(len(grid), len(grid[0]))

Salida:

[4, 5, 6]
6
2 3

grid[1] selecciona la segunda fila; después, [2] selecciona el tercer elemento de esa fila. len(grid) cuenta filas, mientras que len(grid[0]) cuenta celdas de la primera fila. Esta tabla rectangular tiene seis celdas. grid[2][1] falla en el primer acceso porque la fila 2 no existe. Intercambiar las posiciones de fila y columna puede seleccionar la celda equivocada o lanzar IndexError.

Modifica una celda o una fila completa

grid[0][1] = 20 modifica la segunda celda de la primera fila y da [[1, 20, 3], [4, 5, 6]]. grid[0] = [0, 0, 0] sustituye toda la primera fila. El número de accesos indica qué nivel se está sustituyendo.

Recorre todos los valores

grid = [[1, 2, 3], [4, 5, 6]]
total = 0
for row in grid:
    for value in row:
        total += value
print(total)

Salida:

21

El bucle interno completa la primera fila antes de que el externo proporcione la segunda. Suma 1, 2, 3 y después 4, 5, 6. La suma de una columna usa una posición fija de cada fila:

column_total = 0
for row in grid:
    column_total += row[1]
print(column_total)

La salida es 7, a partir de 2 y 5. Este código requiere que cada fila tenga un segundo elemento.

Las filas no tienen por qué tener la misma longitud. [[1], [2, 3]] es una lista anidada válida. Los bucles anidados directos siguen recorriendo todos los valores porque cada bucle interno sigue su propia fila. Suponer que todas las filas tienen len(grid[0]) elementos omitiría valores aquí. Para contar las celdas de una tabla así, suma len(row) para cada fila.

Construye filas independientes

table = []
for r in range(3):
    table.append([0] * 4)
table[0][0] = 1
print(table)

Salida:

[[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Cada iteración crea una lista nueva de cuatro elementos. El atajo [[0] * 4] * 3 repite una referencia a una fila; modificar su primera celda se reflejaría en las tres filas.

Almacena registros

Una fila puede describir un registro en lugar de una fila de números. Con students = [["Ana", 90], ["Ben", 85]], students[1][0] es 'Ben' y students[1][1] es 85. Cuando cada registro tiene dos elementos, for name, score in students: los desempaqueta en nombres útiles. Las listas de tuplas pueden representar el mismo tipo de registros.

Una tupla almacena elementos en orden, como una lista, pero sus posiciones no pueden sustituirse, añadirse ni eliminarse. Esto es la inmutabilidad. Las tuplas son adecuadas para grupos fijos, como coordenadas, fechas y registros; las listas, para colecciones que crecen o cambian.

Crea y lee una tupla

point = (3, 4)
date = (2024, 7, 15)
print(date[0])
print(date[1:])
print(len(date))

Salida:

2024
(7, 15)
3

El acceso por índice, los índices negativos, los segmentos y la pertenencia en tuplas siguen las mismas reglas que en listas. Un segmento de tupla devuelve una tupla. Puedes recorrer una tupla con un bucle o usar +, *, min, max, sum, count e index cuando sus elementos sean adecuados para la operación.

La coma crea una tupla no vacía. t = 3, 4 crea (3, 4) incluso sin paréntesis. Una tupla de un elemento necesita una coma final:

list(t) convierte los elementos de una tupla en una lista modificable.

Comprende qué no puede cambiar

point[0] = 5 lanza TypeError porque una tupla no admite la asignación a un elemento. Las tuplas no tienen métodos append, remove ni sort; point.append(5) lanza AttributeError.

Un nombre sí puede revincularse a una tupla nueva:

point = (3, 4)
point = (5,) + point[1:]
print(point)

La salida es (5, 4). La expresión crea una tupla nueva; no edita la anterior.

Una tupla puede contener un elemento mutable

t = ([1, 2], "x")
t[0].append(3)
print(t)

Salida:

([1, 2, 3], 'x')

La primera posición sigue conteniendo la misma lista. El contenido de esa lista ha cambiado. t[0] = [9] sustituiría el objeto de la posición y no está permitido. La inmutabilidad de la tupla externa no inmoviliza una lista interna.

Ajusta la estructura a su tarea

Usa (x, y) para unas coordenadas, (255, 128, 0) para un color RGB o ("Ana", 90) para un registro de dos campos. Cada posición tiene un significado concreto. Usa una lista para todas las puntuaciones de la clase o los artículos de una lista de compras, que pueden aumentar y reordenarse. Una lista de tuplas, como [("Ana", 90), ("Ben", 85)], combina una colección modificable con posiciones fijas en los registros.

Una tupla de números o cadenas puede servir como clave de diccionario, como en {(0, 0): "origin"}. Las claves deben ser aptas para hash (hashable), lo que significa que admiten las reglas estables de consulta por clave de Python. Una lista no es apta para hash, y una tupla que contiene una lista tampoco lo es.

Compara tuplas

La comparación empieza por la izquierda y se detiene en el primer par desigual. (1, 2, 5) < (1, 3, 0) es True: los primeros valores empatan y 2 es menor que 3. Esta misma regla ordena una lista de registros en forma de tupla cuando no se proporciona una función de clave de ordenación.

El empaquetado reúne valores en una tupla. El desempaquetado asigna los elementos de un iterable a nombres en orden. Juntos permiten dar nombres claros a los campos de un registro y recibir varios resultados de una función.

Asocia nombres con valores

record = "Ana", 34, "Lima"
name, age, city = record
print(name, age, city)

Salida:

Ana 34 Lima

El primer elemento pasa a ser name, el segundo age y el tercero city. El desempaquetado también funciona con listas y cadenas: first, second = [10, 20] y a, b, c = "xyz" asignan sus elementos en orden. user, domain = "ana@example.com".split("@") da 'ana' y 'example.com' porque la división produce dos partes.

Sin un nombre precedido de asterisco, las cantidades deben coincidir exactamente. x, y = (1, 2, 3) lanza ValueError por exceso de valores; x, y, z = (1, 2) lanza ValueError porque faltan valores. Python no descarta los elementos sobrantes sin avisar.

Intercambia valores de forma segura

a = 1
b = 2
a, b = b, a
print(a, b)

La salida es 2 1. Python evalúa todo el lado derecho con los valores anteriores antes de asignar cualquiera de los nombres de la izquierda. El intento con dos sentencias, a = b seguido de b = a, pierde el valor anterior de a y hace que ambos nombres valgan 2.

Recoge los elementos restantes

Un nombre precedido de asterisco recibe una lista con los valores sobrantes:

first, *rest = [5, 6, 7, 8]
print(first, rest)
*init, last = [5, 6, 7, 8]
print(init, last)

Salida:

5 [6, 7, 8]
[5, 6, 7] 8

El asterisco también puede aparecer entre nombres sin asterisco: first, *middle, last = (5, 6, 7, 8) da a middle la lista [6, 7]. El objeto recogido siempre es una lista, incluso al desempaquetar una tupla. head, *rest = [5] deja rest como []. Debe haber suficientes elementos para los nombres sin asterisco, y solo se permite un nombre con asterisco en el mismo patrón de desempaquetado.

Desempaqueta durante un bucle

for name, score in [("Ana", 90), ("Ben", 85)]:
    print(name, score)

Salida:

Ana 90
Ben 85

La cabecera desempaqueta cada registro a medida que llega. Así funcionan también for i, item in enumerate(values): y for a, b in zip(left, right):: cada iteración proporciona un par.

Devuelve varios resultados

def min_max(values):
    return min(values), max(values)

low, high = min_max([7, 2, 9])
result = min_max([7, 2, 9])
print(low, high)
print(result)

Salida:

2 9
(2, 9)

La función devuelve una tupla. El código que la llama puede desempaquetarla o conservar el objeto completo. Por convención, un guion bajo da nombre a un valor que el código no necesita: _, month, day = (2024, 7, 15) conserva el mes y el día bajo nombres descriptivos. _ sigue siendo una variable normal, no una operación especial de descarte.

Una variable es un nombre que hace referencia a un objeto. La asignación cambia a qué se refiere un nombre; no copia automáticamente el objeto. Por tanto, con una lista mutable, dos nombres pueden observar los mismos cambios.

Sigue las referencias

a = [1, 2, 3]
b = a
b.append(4)
print(a)
print(b)

Salida:

[1, 2, 3, 4]
[1, 2, 3, 4]

Hay una lista y dos nombres para ella. b es un alias de a. La operación append modifica el objeto compartido, por lo que leerlo mediante cualquiera de los nombres muestra el elemento añadido. Dibuja dos flechas, una desde cada nombre, hacia la misma lista al seguir este código.

Distingue la igualdad de la identidad

a = [1, 2]
b = a
c = [1, 2]
print(a == b, a == c)
print(a is b, a is c)

Salida:

True True
True False

== compara contenidos; is comprueba si los objetos son el mismo objeto. c tiene el mismo contenido, pero es una lista independiente. id(x) da el número de identidad de un objeto, por lo que id(a) == id(b) coincide con a is b. Los números de identidad no indican qué elementos contiene una lista.

Usa == para comprobar si los contenidos coinciden. Usa is para comprobar si se comparte un objeto o si se trata de un objeto especial como None. Un literal de lista nuevo crea una lista independiente, por lo que a is [1, 2] es falso para una lista existente a, aunque su contenido coincida.

La mutación y la revinculación tienen distinto alcance

Tras la última sentencia, b apunta a una lista nueva. a sigue haciendo referencia al objeto original. Revincular un nombre no redirige todos los nombres que antes se referían a ese objeto.

Sigue += y + por separado

Para las listas, += amplía la lista existente:

a = [1]
b = a
a += [2]
print(a, b)

La salida es [1, 2] [1, 2]. En cambio:

a = [1]
b = a
a = a + [2]
print(a, b)

La salida es [1, 2] [1]. + crea una lista nueva, y la asignación hace que a se refiera a ella. b sigue refiriéndose a la lista original de un elemento.

Busca alias menos visibles

row = [0, 0] seguido de table = [row, row] almacena la misma fila dos veces. table[0][0] = 5 produce [[5, 0], [5, 0]] porque ambas posiciones acceden a la misma lista interna.

Los números y las cadenas no pueden modificarse sobre el objeto original. Tras x = 5, y = x, x += 1, y sigue siendo 5; x se ha revinculado. Las posiciones de los elementos de una tupla también permanecen fijas, pero una lista interna puede cambiar. Tras t = ([1], 2), u = t y t[0].append(3), u muestra ([1, 3], 2): ambos nombres siguen accediendo a la misma tupla y a su misma lista mutable.

Copiar crea un objeto nuevo, pero la profundidad de esa copia importa. Una lista externa nueva puede seguir conteniendo referencias a las listas internas originales.

Crea una lista externa nueva

a = [1, 2, 3]
b = a.copy()
b.append(4)
print(a)
print(b)
print(a is b)

Salida:

[1, 2, 3]
[1, 2, 3, 4]
False

a[:], list(a) y a.copy() crean una copia superficial de una lista. Su contenedor externo es nuevo y se copian las referencias a sus elementos. Con números o cadenas inmutables, sustituir o añadir un elemento en una lista externa deja la otra sin cambios.

Observa qué comparte una copia superficial

a = [[1, 2], [3, 4]]
b = a.copy()
b[0].append(99)
print(a)
print(b is a, b[0] is a[0])

Salida:

[[1, 2, 99], [3, 4]]
False True

Las dos listas externas son distintas, pero sus primeros elementos hacen referencia a la misma lista interna. append() modifica ese objeto interno.

Sustituir una posición de b es diferente. Tras b[1] = [0], b tiene una segunda fila diferente, mientras que a[1] sigue siendo [3, 4]. La asignación cambia una referencia de la lista externa de b; no modifica la segunda fila anterior.

Copia también las listas anidadas

import copy

a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)
b[0].append(99)
print(a)
print(b)

Salida:

[[1, 2], [3, 4]]
[[1, 2, 99], [3, 4]]

import copy hace que el módulo de copias esté disponible. copy.deepcopy() copia de forma recursiva la estructura de listas anidadas, por lo que las modificaciones de las listas internas copiadas no llegan a la original. Úsalo cuando los cambios en esos niveles internos deban ser independientes. Una copia superficial basta si solo van a cambiar el orden de la lista externa o sus referencias a elementos.

Evita referencias repetidas al construir filas

table = [[0] * 3] * 2
table[0][0] = 7
print(table)

La salida es [[7, 0, 0], [7, 0, 0]]. La multiplicación repitió la referencia a una fila. No construyó dos filas.

Construye cada fila dentro del bucle:

table = []
for r in range(2):
    table.append([0] * 3)
table[0][0] = 7
print(table)

La salida es [[7, 0, 0], [0, 0, 0]]. [0] * 3 por sí solo es seguro para contadores independientes: los enteros no pueden modificarse y la asignación a un elemento sustituye solo una posición.

Elige una copia por una razón

Conservar el orden original antes de ordenar requiere una lista externa nueva. Conservar las mediciones anidadas originales mientras se modifican celdas copiadas requiere también listas internas independientes. El procesamiento de solo lectura no necesita copias, y la edición compartida intencionada puede usar alias. Para investigar un error de programación en una estructura anidada, comprueba tanto b is a como b[0] is a[0]; comprobar solo las listas externas no detecta los objetos internos compartidos.

Un parámetro de función es otro nombre para el objeto que proporciona el código que la llama. Un argumento de tipo lista no se copia automáticamente. La función puede modificar ese objeto, revincular su parámetro local o devolver un resultado nuevo; estas acciones afectan de formas distintas al código que realiza la llamada.

La mutación afecta al código que llama

def add_bonus(scores):
    scores.append(5)

marks = [80]
result = add_bonus(marks)
print(marks)
print(result)

Salida:

[80, 5]
None

scores y marks hacen referencia inicialmente a la misma lista. Añadir un elemento mediante scores la modifica. Como la función no tiene una sentencia de retorno explícita, su resultado es None.

En cambio, def reset(scores): scores = [] revincula solo el parámetro local. La variable marks del código que llama sigue haciendo referencia a su lista anterior. Usa scores.clear() para vaciar esa lista compartida.

Conserva una lista devuelta cuando la necesites

Dos diseños habituales son modificar la lista original y devolver None, o dejarla intacta y devolver una lista nueva:

def drop_first(values):
    del values[0]

def tail(values):
    return values[1:]

Para nums = [1, 2, 3], llamar a drop_first(nums) deja nums como [2, 3]. En cambio, escribir nums = drop_first(nums) vincularía nums a None. Empezando de nuevo con [1, 2, 3], shorter = tail(nums) da a shorter la lista [2, 3], mientras que nums queda sin cambios. Llamar a tail(nums) sin conservar su resultado descarta la lista nueva.

Otros diseños también son útiles: sum() devuelve un resumen, y pop() modifica una lista y devuelve un elemento. Deja claros el efecto y el valor de retorno en el nombre o la cadena de documentación de la función.

Construye un resultado sin modificar la entrada

def without_negatives(values):
    kept = []
    for value in values:
        if value >= 0:
            kept.append(value)
    return kept

original = [3, -2, 0, 7]
print(without_negatives(original))
print(original)

Salida:

[3, 0, 7]
[3, -2, 0, 7]

El código que llama también puede proteger su lista externa pasando una copia superficial, como drop_first(original[:]). Una operación que edite listas internas necesitaría copiar también esos niveles.

Evita un valor predeterminado mutable compartido

def add_item(item, basket=[]):
    basket.append(item)
    return basket

La lista predeterminada se crea una vez, cuando se ejecuta la sentencia def. add_item("a") devuelve ['a'], y la siguiente llamada que usa el valor predeterminado, add_item("b"), devuelve ['a', 'b']. Usa None para solicitar una lista nueva:

def add_item(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    return basket

Ahora cada llamada sin una cesta crea su propia lista. Pasar una cesta existente sigue permitiendo cambios compartidos intencionados. Una función no puede modificar un número o una cadena, ni sustituir las posiciones de una tupla, pero sí puede modificar una lista almacenada en una tupla, por ejemplo, llamando a pair[0].append(9).

Ordenar coloca los elementos según su orden de comparación. Invertir da la vuelta a su orden actual. Decide también si el programa debe modificar la lista existente o conservarla y recibir una lista nueva.

Ordena la lista original o conserva una nueva

nums = [3, 1, 2]
new = sorted(nums)
print(nums)
print(new)
nums.sort()
print(nums)

Salida:

[3, 1, 2]
[1, 2, 3]
[1, 2, 3]

sorted() crea una lista nueva. sort() es un método de lista que reorganiza la lista existente y devuelve None. nums = nums.sort() pierde la referencia del nombre a la lista y lo vincula a None. Escribe nums.sort() en una línea independiente o usa nums = sorted(nums). print(nums.sort()) muestra None aunque la lista se haya reordenado.

sorted() acepta cualquier iterable y siempre devuelve una lista. sorted((3, 1, 2)) da [1, 2, 3], y sorted("cab") da ['a', 'b', 'c']. Las cadenas y las tuplas no tienen un método sort() que modifique el objeto original.

Orden descendente y orden inverso

Cada fila parte de la lista original. reverse=True solicita un orden de comparación descendente y debe indicarse por nombre; sorted(nums, True) lanza TypeError. Invertir simplemente recorre las posiciones existentes hacia atrás, por lo que no produce necesariamente valores descendentes.

Comprueba los valores que se comparan

Los números se ordenan por su valor numérico, incluso al mezclar enteros y números de coma flotante: sorted([2.5, -1, 2]) da [-1, 2, 2.5].

El texto se compara carácter a carácter. sorted(["10", "9", "100"]) da ['10', '100', '9']. El primer carácter '1' se ordena antes que '9', y un prefijo de cadena va antes que una cadena más larga que empieza por él. Convierte las cadenas numéricas con int() o float() cuando quieras un orden numérico.

Las letras mayúsculas A–Z se ordenan antes que las minúsculas a–z. sorted(["b", "B", "a"]) da ['B', 'a', 'b']. El orden predeterminado de cadenas se basa en los códigos de los caracteres; no es un orden de diccionario sin distinción entre mayúsculas y minúsculas.

Todos los elementos comparados deben admitir < entre sí. sorted([3, "two", 1]) lanza TypeError. Limpia o convierte los datos antes de ordenar.

Usa las posiciones ordenadas

Para una cantidad impar de puntuaciones, ordenar permite leer fácilmente el valor central:

scores = [72, 95, 64, 88, 79]
ordered = sorted(scores)
median = ordered[len(ordered) // 2]
print(ordered)
print(median)

La salida es [64, 72, 79, 88, 95] seguida de 79. La lista original sigue registrando el orden en que llegaron las puntuaciones. Este cálculo basado en un único elemento central se aplica a listas no vacías de longitud impar.

Una función de clave de ordenación calcula el valor de comparación de cada elemento. Los elementos originales permanecen intactos en el resultado ordenado. Esto permite ordenar texto por longitud o registros por un campo seleccionado.

Pasa una función, no una llamada a función

words = ["kiwi", "fig", "banana"]
print(sorted(words, key=len))

Salida:

['fig', 'kiwi', 'banana']

Python llama a len una vez por cada elemento y compara las longitudes resultantes, 4, 3 y 6. Pasa key=len, sin paréntesis. key=len() intenta llamar a len inmediatamente sin argumento y falla.

Para comparar en minúsculas, usa key=str.lower. Con ["banana", "apple", "Cherry"], el orden predeterminado es ['Cherry', 'apple', 'banana']. Con key=str.lower, el resultado es ['apple', 'banana', 'Cherry']. La C mayúscula original permanece en el resultado; solo las claves de comparación están en minúsculas.

Selecciona un campo del registro

results = [("Ana", 90), ("Ben", 72), ("Cy", 85)]

def by_score(record):
    return record[1]

print(sorted(results, key=by_score))

Salida:

[('Ben', 72), ('Cy', 85), ('Ana', 90)]

La función recibe un registro cada vez. record[1] selecciona su puntuación. Añade reverse=True para colocar primero la puntuación más alta. results.sort(key=by_score, reverse=True) usa la misma regla, pero modifica la propia results.

key=by_score(results) es diferente: llama a la función sobre toda la lista y pasa su resultado como argumento de clave. Aquí ese resultado es la tupla ('Ben', 72), que no puede llamarse como función, por lo que la ordenación lanza TypeError.

Usa varios campos

Sin una clave, las tuplas comparan sus primeros elementos y después sus segundos elementos para deshacer empates entre los primeros. Ordenar [("Ben", 72), ("Ana", 90), ("Ana", 85)] da [('Ana', 85), ('Ana', 90), ('Ben', 72)].

Una clave puede devolver una tupla para elegir un orden de campos diferente:

def rank_key(record):
    return (-record[1], record[0])

results = [("Dee", 85), ("Ana", 90), ("Cy", 85)]
print(sorted(results, key=rank_key))

Salida:

[('Ana', 90), ('Cy', 85), ('Dee', 85)]

Cambiar el signo de la puntuación hace que las puntuaciones mayores tengan claves menores. Después, los nombres deshacen los empates de puntuación en orden ascendente. reverse=True con una clave positiva (score, name) invertiría ambos campos, incluidos los nombres, por lo que no cumpliría esta regla de direcciones mixtas.

Conserva el orden de los elementos con claves iguales

La ordenación de Python es estable: los elementos con claves iguales conservan su orden de entrada. Ordenar ["bb", "a", "cc", "d"] por len da ['a', 'd', 'bb', 'cc']. El empate entre las dos palabras de una letra mantiene 'a' primero; el empate de dos letras mantiene 'bb' primero. La estabilidad también permite ordenar primero por un campo secundario y después por el principal.

min() y max() también aceptan funciones de clave de ordenación. max(words, key=len) devuelve 'banana', no su longitud. Cuando las claves empatan, estas funciones devuelven el primer elemento coincidente que encuentran.