Como comparar listas em Python

Para comparar duas listas Python, primeiro decida se a ordem e as contagens de duplicatas têm significado. Use == para igualdade exata e ordenada, Counter para igualdade que ignora a ordem mas preserva as contagens, set() para interseções ou diferenças de valores únicos e uma compreensão de lista quando o resultado precisar seguir a ordem de uma lista de entrada.

Todos os exemplos abaixo usam somente a biblioteca padrão do Python e foram verificados com Python 3.14.7. Os mesmos métodos funcionam em versões anteriores compatíveis do Python 3, salvo se o projeto exigir outra compatibilidade.

Essas escolhas respondem a perguntas diferentes, em vez de disputar um único método universalmente mais rápido. A igualdade retorna um Boolean, operações de conjunto e Counter criam resultados semelhantes a coleções, e uma compreensão controla a forma e a ordem de uma nova lista. Decida a semântica necessária antes de pensar em desempenho; mudar a representação apenas para acelerar uma comparação também pode mudar a resposta.

Comparar listas ordenadas exatas com ==

A igualdade de listas do Python compara elementos correspondentes da esquerda para a direita. Duas listas só são iguais quando têm o mesmo tamanho, valores iguais em cada posição e, portanto, a mesma ordem. É a escolha mais clara quando uma lista representa uma sequência, como etapas de processamento, resultados classificados ou eventos ordenados.

"""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

A segunda comparação é False mesmo que ambas as listas contenham os mesmos valores únicos. A igualdade direta também funciona com elementos não hashable, como listas aninhadas, pois não constrói uma tabela de hash.

As comparações de elementos ainda seguem as regras de igualdade de cada valor. Por exemplo, comparar listas de objetos personalizados pode invocar as implementações de __eq__ desses objetos. Esse método não informa recursivamente onde duas estruturas aninhadas diferem; ele apenas retorna o Boolean final.

Comparar listas sem ordem mantendo duplicatas com Counter

Use collections.Counter quando a ordem puder ser ignorada, mas a frequência de cada valor ainda for importante. Um Counter associa cada item hashable à sua contagem, portanto dois contadores só são iguais quando as listas contêm os mesmos valores com as mesmas multiplicidades.

"""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

As duas últimas linhas mostram um limite importante: Counter detecta o segundo 2 ausente, enquanto uma comparação de conjuntos informa igualdade porque conjuntos descartam duplicatas. Não use set(left) == set(right) como substituto quando valores repetidos têm significado.

A função interna sorted() oferece outra opção que considera duplicatas por meio de sorted(left) == sorted(right), mas somente quando todos os valores das listas podem ser ordenados entre si. Ela também aloca listas ordenadas e executa a ordenação; por isso Counter normalmente expressa a igualdade de frequências sem ordem de modo mais direto. Ordenar continua útil quando as sequências ordenadas serão necessárias depois.

Comparar valores únicos, interseções e diferenças com set()

Converta listas em conjuntos quando apenas valores distintos importarem. A interseção de conjuntos (&) retorna valores presentes nas duas entradas. A diferença (-) tem direção, enquanto a diferença simétrica (^) retorna valores presentes em apenas um dos lados.

O exemplo verificado a seguir ordena apenas os resultados de conjuntos exibidos para que a saída seja determinística. A comparação em si não atribui uma ordem a um conjunto.

A conversão em conjunto pode ser atraente em tarefas com muitas verificações de pertencimento porque cria uma estrutura de consulta uma vez, mas não serve quando a saída precisa manter posição ou multiplicidade. Também não dependa da ordem impressa de um conjunto; ordene explicitamente apenas quando os valores puderem ser ordenados entre si e for necessária uma apresentação estável.

"""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]

As três primeiras linhas da saída mostram a interseção de valores únicos e diferenças direcionais. Se você também precisar de valores que ocorrem em exatamente um conjunto, use left_set ^ right_set; com estas entradas, ele produz os valores únicos 1, 4 e 5 em ordem não especificada.

Preservar a ordem do resultado com uma compreensão de lista

O resultado de um conjunto não preserva a ordem da primeira lista. Quando a ordem de saída for importante, crie um conjunto de pertencimento uma vez e percorra a lista cuja ordem deseja preservar. No exemplo anterior, right_members é criado uma vez antes da compreensão, em vez de recriar ou percorrer linearmente a segunda lista para cada elemento.

A quarta linha da saída, [2, 2, 3], preserva a ordem e as ocorrências repetidas de left. O resultado é intencionalmente assimétrico: percorrer right preservaria a ordem e as duplicatas de right. Se os valores de pertencimento não forem hashable, use pertencimento baseado em igualdade direta na outra lista, entendendo que varreduras repetidas podem custar mais em entradas grandes.

Preservar multiplicidades em interseções e diferenças com Counter

As operações de conjunto respondem a perguntas sobre valores únicos. As operações de Counter respondem aos mesmos tipos de pergunta preservando as contagens.

• left_counts & right_counts mantém a menor contagem positiva de cada valor compartilhado.
• left_counts - right_counts subtrai contagens e mantém somente os restos positivos.
• right_counts - left_counts fornece a diferença na outra direção.
• .elements() expande as contagens resultantes novamente em valores individuais.

No exemplo verificado, a interseção multiconjunto é [2, 3], não [2, 2, 3]: 2 ocorre duas vezes à esquerda, mas apenas uma à direita, portanto a contagem mínima é um. O resto direcional à esquerda é [1, 2, 4], e o resto à direita é [3, 5].

Escolha esse método para estoques, votos, tags com repetições ou outros dados em que a quantidade importa. Um conjunto simples apagaria silenciosamente essa informação.

A aritmética de Counter remove contagens zero e negativas desses resultados multiconjunto. Esse comportamento ajuda em perguntas sobre itens restantes, mas difere da subtração numérica comum sobre todas as chaves possíveis. Inspecione os contadores diretamente se a aplicação precisar manter saldos zero ou negativos.

Lidar com valores não hasháveis e escolher o método correto

Tanto set() quanto Counter exigem elementos hashable. Listas são mutáveis e não hashable; por isso listas aninhadas provocam TypeError, enquanto a igualdade direta de listas continua funcionando.

"""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'

A mensagem de diagnóstico exata de set pode variar entre versões do Python; trate o tipo da exceção e a causa — o elemento não ser hashable — como o comportamento estável. Se sequências aninhadas puderem ser representadas de forma imutável, converta cada lista interna em uma tupla antes de usar um conjunto ou Counter; caso contrário, mantenha uma comparação baseada em igualdade adequada ao resultado necessário.

Em resumo, escolha a representação que corresponde ao significado dos dados: == para sequências ordenadas, Counter para multiconjuntos sem ordem, set() para valores únicos e uma compreensão que preserva a ordem para saída filtrada. Tornar explícitas as regras de ordem e duplicatas evita comparações que parecem corretas, mas respondem à pergunta errada.