Cómo comparar tuplas en Python

Cuando se trabaja con Python, es posible que a menudo necesite comparar tuplas. Las tuplas son secuencias inmutables, lo que significa que una vez creadas, no se pueden modificar. Esta característica las hace particularmente útiles para almacenar colecciones fijas de elementos. Comparar tuplas puede ayudarle a determinar su igualdad, su orden e incluso su contenido.

En este artículo, exploraremos cómo compara Python las tuplas, desde simples comprobaciones de igualdad hasta el ordenamiento lexicográfico, y cómo se comportan las comparaciones cuando las tuplas difieren en tipo, longitud o anidamiento.

Cómo compara Python las tuplas

Python compara las tuplas lexicográficamente, de la misma manera en que se ordenan las palabras en un diccionario. Compara los primeros elementos de cada tupla; si difieren, esa primera diferencia decide la comparación, y los elementos restantes nunca se examinan. Si los primeros elementos son iguales, pasa al siguiente par, y así sucesivamente, hasta que encuentra una diferencia o se queda sin elementos. Si una tupla es un prefijo de la otra — todos sus elementos coinciden con el comienzo de la tupla más larga — la tupla más corta se considera menor que la más larga.

El operador de igualdad (==) comprueba si ambas tuplas tienen los mismos elementos en el mismo orden, y el operador de desigualdad (!=) es su opuesto exacto:

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 3)
tuple3 = (1, 2, 4)

print(tuple1 == tuple2)
print(tuple1 == tuple3)
print(tuple1 != tuple3)

Resultado:

True
False
True

Los operadores de orden (<, <=, >, >=) aplican el mismo recorrido elemento por elemento, utilizando el orden propio de cada par para decidir:

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 4)
tuple3 = (1, 2)

print(tuple1 < tuple2)
print(tuple1 > tuple3)

Resultado:

True
True

Aquí tuple1 es menor que tuple2 porque los dos primeros elementos son iguales y 3 < 4. Y tuple1 es mayor que tuple3 porque tuple3 es un prefijo de tuple1, por lo que la tupla más larga se ordena después de la más corta.

Manejar diferentes tipos, longitudes y tuplas anidadas

La igualdad y el orden no tratan los tipos mixtos de la misma manera, y confundirlos es una fuente común de expectativas erróneas.

La igualdad nunca produce un error por los tipos. Dos elementos de tipos diferentes son simplemente desiguales — con la excepción numérica habitual de que valores como 1 y 1.0 se consideran iguales —, por lo que una comparación de tuplas con == devuelve False, y con != devuelve True, sin que nadie compruebe los tipos primero:

tuple1 = (1, "a", 3)
tuple2 = (1, 2, 3)

print(tuple1 == tuple2)
print(tuple1 != tuple2)

Resultado:

False
True

El orden es más estricto. En el momento en que una comparación de orden alcanza un par de elementos que no pueden ordenarse entre sí, como una cadena frente a un entero, produce un TypeError en lugar de devolver un resultado:

tuple1 = (1, "a", 3)
tuple2 = (1, 2, 3)

print(tuple1 < tuple2)

Resultado:

TypeError: '<' not supported between instances of 'str' and 'int'

Los primeros elementos son iguales, por lo que la comparación pasa a "a" frente a 2 — y las cadenas y los enteros no tienen ningún orden entre ellos, de ahí el error. Tenga en cuenta que esto solo ocurre si la comparación llega realmente al par que no coincide: (0, "a") < (1, 2) devuelve False sin error, porque los primeros elementos ya lo deciden.

Las diferentes longitudes interactúan con una popular comprobación de igualdad elemento por elemento de una manera que es fácil pasar por alto. Combinar all() con zip() compara los pares que zip() produce, y zip() se detiene en la tupla más corta — por lo que los elementos finales sin pareja se ignoran silenciosamente:

tuple1 = (1, 2, 3)
tuple2 = (1, 2)

print(all(a == b for a, b in zip(tuple1, tuple2)))
print(len(tuple1) == len(tuple2) and all(a == b for a, b in zip(tuple1, tuple2)))

Resultado:

True
False

La primera línea informa True a pesar de que las tuplas no son iguales, porque el 3 final nunca se compara. Si utiliza este patrón — es útil para tuplas grandes o para una lógica personalizada por elemento — combínelo siempre con una comprobación de longitud, como en la segunda línea.

Las tuplas anidadas no necesitan ningún tratamiento especial: un elemento tupla se compara con las mismas reglas que cualquier otro elemento, de forma recursiva. (1, 2) dentro de una tupla se ordena antes que (3, 5) dentro de otra, porque sus propios primeros elementos diferentes lo deciden:

tuple1 = ((1, 2), (3, 4))
tuple2 = ((1, 2), (3, 5))

print(tuple1 < tuple2)
print(tuple1 == tuple2)

Resultado:

True
False

En resumen: recurra a == y != cuando solo necesite saber si dos tuplas son iguales — funcionan con cualquier contenido. Utilice los operadores de orden cuando necesite el orden relativo, y asegúrese de que los elementos a los que la comparación llegará realmente puedan ordenarse entre sí.