Cómo comparar listas en Python

Para comparar dos listas de Python, decida primero si importan el orden y el número de duplicados. Use == para igualdad ordenada exacta, Counter para ignorar el orden conservando frecuencias, set() para valores únicos y una comprensión si el resultado debe conservar el orden de una lista.

Los ejemplos usan la biblioteca estándar y fueron verificados con Python 3.14.7. Cada método responde a una pregunta distinta; escoger la semántica correcta evita obtener una respuesta aparentemente rápida pero incorrecta.

Estas opciones responden a preguntas diferentes, no compiten por ser un único método universalmente más rápido. La igualdad devuelve un booleano, las operaciones con conjuntos y Counter crean resultados similares a colecciones, y una comprensión controla la forma y el orden de una lista nueva. Decida la semántica necesaria antes de pensar en el rendimiento: cambiar la representación para acelerar la comparación también puede cambiar la respuesta.

Comparar listas ordenadas exactas con ==

La igualdad de listas compara elementos correspondientes de izquierda a derecha: requiere la misma longitud, los mismos valores en cada posición y el mismo orden. Es apropiada para pasos, resultados clasificados o eventos secuenciales.

"""Verify that list equality considers both values and order."""

first = [1, 2, 3]
same = [1, 2, 3]
reordered = [3, 2, 1]

print(first == same)
print(first == reordered)

True
False

El segundo resultado es False aunque coincidan los valores únicos; == también admite listas anidadas no hashables porque no crea una tabla hash.

Las comparaciones siguen las reglas de igualdad de cada objeto, por ejemplo la implementación de __eq__ de objetos personalizados, y no muestran la posición exacta de una diferencia en datos anidados: solo devuelven el resultado booleano final.

Comparar listas sin orden y con duplicados mediante Counter

Use collections.Counter si el orden no importa pero sí la frecuencia de cada valor hashable. Un contador asigna a cada elemento su número de apariciones, por lo que ambos contadores solo son iguales si las multiplicidades coinciden.

"""Compare unordered lists with and without duplicate multiplicity."""

from collections import Counter

left = [1, 2, 2, 3]
reordered = [3, 2, 1, 2]
fewer_duplicates = [3, 2, 1]

print(Counter(left) == Counter(reordered))
print(Counter(left) == Counter(fewer_duplicates))
print(set(left) == set(fewer_duplicates))

True
False
True

Las dos últimas líneas muestran un límite importante: Counter detecta el segundo 2 que falta, mientras que un conjunto descarta duplicados y por eso considera iguales las listas. No sustituya Counter por set(left) == set(right) cuando las repeticiones tengan significado.

sorted(left) == sorted(right) también conserva duplicados, pero exige valores ordenables, crea listas ordenadas y realiza el trabajo de ordenarlas. Counter suele expresar la igualdad de frecuencias con mayor claridad; sorted() sigue siendo útil si también necesita las secuencias ordenadas.

Comparar valores únicos, intersecciones y diferencias con set()

Convierta a conjuntos cuando solo importen valores distintos: & calcula la intersección, - la diferencia dirigida y ^ la diferencia simétrica.

El ejemplo verificado ordena únicamente los conjuntos que se muestran para que la salida sea determinista. La comparación no asigna ningún orden a un conjunto.

La conversión a conjunto puede ser útil para tareas con muchas consultas de pertenencia porque crea una estructura de búsqueda una vez, pero no sirve cuando la salida debe conservar posición o multiplicidad. Tampoco dependa del orden impreso de un conjunto; ordénelo explícitamente solo si los valores son ordenables entre sí y necesita una presentación estable.

"""Verify unique-value, order-preserving, and multiplicity-aware differences."""

from collections import Counter

left = [1, 2, 2, 3, 4]
right = [2, 3, 3, 5]
left_set = set(left)
right_set = set(right)

print(sorted(left_set & right_set))
print(sorted(left_set - right_set))
print(sorted(right_set - left_set))

right_members = set(right)
print([item for item in left if item in right_members])

left_counts = Counter(left)
right_counts = Counter(right)
print(sorted((left_counts & right_counts).elements()))
print(sorted((left_counts - right_counts).elements()))
print(sorted((right_counts - left_counts).elements()))

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

Las tres primeras líneas muestran valores únicos y diferencias dirigidas. Si también necesita valores que aparezcan en exactamente un conjunto, use left_set ^ right_set; con estas entradas produce 1, 4 y 5 en un orden no definido.

Conservar el orden del resultado con una comprensión de listas

Un resultado de conjunto no conserva el orden de la primera lista. Cuando el orden de salida importa, cree una vez un conjunto de pertenencia y recorra la lista cuyo orden desea retener. En el ejemplo anterior, right_members se crea una vez antes de la comprensión en lugar de reconstruirlo o de recorrer linealmente la segunda lista para cada elemento.

La cuarta salida, [2, 2, 3], conserva el orden y las repeticiones de left. El resultado es intencionadamente asimétrico: recorrer right conservaría sus repeticiones y su orden, no los de left. Con valores de pertenencia no hashables, use pertenencia basada en igualdad contra la otra lista, teniendo en cuenta que los recorridos repetidos pueden costar más en entradas grandes.

Conservar multiplicidades en intersecciones y diferencias con Counter

Counter conserva cantidades al calcular solapamientos y diferencias, a diferencia de un conjunto.

• left_counts & right_counts conserva el mínimo positivo de cada valor común.
• left_counts - right_counts deja solo los restos positivos.
• La resta inversa obtiene el resto del lado derecho.
• .elements() vuelve a expandir las cantidades en valores individuales.

La intersección multiconjunto es [2, 3], pues el 2 aparece una vez a la derecha; los restos son [1, 2, 4] y [3, 5].

Este enfoque sirve para inventarios, votos o etiquetas repetidas; un conjunto borraría silenciosamente esa información.

La aritmética de Counter elimina cuentas cero y negativas; inspeccione los contadores si necesita conservar esos saldos.

Manejar valores no hashables y elegir el método correcto

set() y Counter requieren elementos hashables; las listas anidadas provocan TypeError, pero la igualdad directa funciona.

"""Show the unhashable-item boundary of set and Counter comparisons."""

from collections import Counter

left = [[1], [2]]
right = [[1], [2]]

print(left == right)
for name, operation in (("set", set), ("Counter", Counter)):
    try:
        operation(left)
    except TypeError as error:
        print(f"{name}: {error}")

True
set: cannot use 'list' as a set element (unhashable type: 'list')
Counter: unhashable type: 'list'

El texto exacto del diagnóstico de set puede variar entre versiones; el tipo de excepción y su causa son el comportamiento estable.

Convierta listas internas a tuplas cuando sea correcto, o mantenga una comparación basada en igualdad; elija la representación que conserve orden y duplicados.