Preciso comparar duas listas para criar uma nova lista de elementos específicos encontrados em uma lista, mas não na outra. Por exemplo:

main_list=[]
list_1=["a", "b", "c", "d", "e"]
list_2=["a", "f", "c", "m"] 

Desejo percorrer a lista_1 e acrescentar à main_list todos os elementos da lista_2 que não foram encontrados na lista_1.

O resultado deve ser:

main_list=["f", "m"]

Como posso fazer isso com python?

TL; DR:
SOLUÇÃO (1)

import numpy as np
main_list = np.setdiff1d(list_2,list_1)
# yields the elements in `list_2` that are NOT in `list_1`

SOLUÇÃO (2) Você deseja uma lista ordenada

def setdiff_sorted(array1,array2,assume_unique=False):
    ans = np.setdiff1d(array1,array2,assume_unique).tolist()
    if assume_unique:
        return sorted(ans)
    return ans
main_list = setdiff_sorted(list_2,list_1)

EXPLICAÇÕES:
(1) Você pode usar NumPy do setdiff1d( array1, array2, assume_unique= False).

assume_uniquepergunta ao usuário se as matrizes já são únicas.
Se False, então os elementos exclusivos são determinados primeiro.
Se True, a função assumirá que os elementos já são exclusivos E a função ignorará a determinação dos elementos exclusivos.

Isso resulta os valores exclusivos em array1que não são nos array2. assume_uniqueé Falsepor padrão.

Se você está preocupado com os elementos exclusivos (com base na resposta de Chinny84 ), basta usar (onde assume_unique=False=> o valor padrão):

import numpy as np
list_1 = ["a", "b", "c", "d", "e"]
list_2 = ["a", "f", "c", "m"] 
main_list = np.setdiff1d(list_2,list_1)
# yields the elements in `list_2` that are NOT in `list_1`

(2) Para quem deseja que as respostas sejam classificadas, criei uma função personalizada:

import numpy as np
def setdiff_sorted(array1,array2,assume_unique=False):
    ans = np.setdiff1d(array1,array2,assume_unique).tolist()
    if assume_unique:
        return sorted(ans)
    return ans

Para obter a resposta, execute:

main_list = setdiff_sorted(list_2,list_1)

NOTAS LATERAIS:
(a) A solução 2 (função personalizada setdiff_sorted) retorna uma lista (comparada a uma matriz na solução 1).

(b) Se você não tem certeza se os elementos são únicos, use a configuração padrão de NumPy setdiff1dnas soluções A e B. O que pode ser um exemplo de complicação? Veja a nota (c).

(c) As coisas serão diferentes se uma das duas listas não for única.
Diga list_2não é único: list2 = ["a", "f", "c", "m", "m"]. Manter list1como está:list_1 = ["a", "b", "c", "d", "e"]
configurando o valor padrão dos assume_uniquerendimentos ["f", "m"](em ambas as soluções). No entanto, se você definir assume_unique=True, as duas soluções dão ["f", "m", "m"]. Por quê? Isso ocorre porque o usuário ASSUME que os elementos são únicos). Por isso, é melhor manterassume_uniqueao seu valor padrão. Observe que as duas respostas estão classificadas.

Pitãoentorpecido

Você pode usar conjuntos:

main_list = list(set(list_2) - set(list_1))

Resultado:

>>> list_1=["a", "b", "c", "d", "e"]
>>> list_2=["a", "f", "c", "m"]
>>> set(list_2) - set(list_1)
set(['m', 'f'])
>>> list(set(list_2) - set(list_1))
['m', 'f']

De acordo com o comentário do @JonClements, aqui está uma versão mais organizada:

>>> list_1=["a", "b", "c", "d", "e"]
>>> list_2=["a", "f", "c", "m"]
>>> list(set(list_2).difference(list_1))
['m', 'f']

Não sei por que as explicações acima são tão complicadas quando você tem métodos nativos disponíveis:

main_list = list(set(list_2)-set(list_1))

Use uma compreensão de lista como esta:

main_list = [item for item in list_2 if item not in list_1]

Resultado:

>>> list_1 = ["a", "b", "c", "d", "e"]
>>> list_2 = ["a", "f", "c", "m"] 
>>> 
>>> main_list = [item for item in list_2 if item not in list_1]
>>> main_list
['f', 'm']

Editar:

Como mencionado nos comentários abaixo, com grandes listas, o acima não é a solução ideal. Nesse caso, uma opção melhor seria a conversão list_1para uma setprimeira:

set_1 = set(list_1)  # this reduces the lookup time from O(n) to O(1)
main_list = [item for item in list_2 if item not in set_1]

Se você deseja uma solução de uma linha (ignorando importações) que requer apenas O(max(n, m))trabalho para entradas de comprimento ne m, não O(n * m)trabalho, você pode fazê-lo com o itertoolsmódulo :

from itertools import filterfalse

main_list = list(filterfalse(set(list_1).__contains__, list_2))

Isso tira proveito das funções funcionais que utilizam uma função de retorno de chamada na construção, permitindo que ele crie o retorno de chamada uma vez e reutilize-o para cada elemento sem precisar armazená-lo em algum lugar (porque o filterfalsearmazena internamente); compreensões de lista e expressões geradoras podem fazer isso, mas é feio. †

Isso obtém os mesmos resultados em uma única linha que:

main_list = [x for x in list_2 if x not in list_1]

com a velocidade de:

set_1 = set(list_1)
main_list = [x for x in list_2 if x not in set_1]

Obviamente, se as comparações pretendem ser posicionais, então:

list_1 = [1, 2, 3]
list_2 = [2, 3, 4]

deve produzir:

main_list = [2, 3, 4]

(como o valor in list_2tem uma correspondência no mesmo índice em list_1), você deve definitivamente seguir a resposta de Patrick , que não envolve lists ou s temporários set(mesmo com sets sendo mais ou menos O(1), eles têm um fator "constante" mais alto por verificação do que simples verificações de igualdade ) e envolveO(min(n, m)) trabalho, menos do que qualquer outra resposta e, se o seu problema for sensível à posição, é a única solução correta quando os elementos correspondentes aparecerem em desvios incompatíveis.

†: A maneira de fazer o mesmo com a compreensão de uma lista como uma linha seria abusar do loop aninhado para criar e armazenar em cache valores no loop "mais externo", por exemplo:

main_list = [x for set_1 in (set(list_1),) for x in list_2 if x not in set_1]

que também oferece um benefício de desempenho menor no Python 3 (porque agora set_1é escopo localmente no código de compreensão, em vez de ser pesquisado no escopo aninhado de cada verificação; no Python 2 isso não importa, porque o Python 2 não usa fechamentos para compreensão da lista; eles operam no mesmo escopo em que são usados).

main_list=[]
list_1=["a", "b", "c", "d", "e"]
list_2=["a", "f", "c", "m"]

for i in list_2:
    if i not in list_1:
        main_list.append(i)

print(main_list)

resultado:

['f', 'm']

Eu faria zipas listas juntas para compará-las elemento a elemento.

main_list = [b for a, b in zip(list1, list2) if a!= b]

Eu usei dois métodos e achei um método útil sobre outro. Aqui está a minha resposta:

Meus dados de entrada:

crkmod_mpp = ['M13','M18','M19','M24']
testmod_mpp = ['M13','M14','M15','M16','M17','M18','M19','M20','M21','M22','M23','M24']

Método1: np.setdiff1dEu gosto dessa abordagem em detrimento de outras, porque preserva a posição

test= list(np.setdiff1d(testmod_mpp,crkmod_mpp))
print(test)
['M15', 'M16', 'M22', 'M23', 'M20', 'M14', 'M17', 'M21']

Método2: Embora dê a mesma resposta que no Método1, mas perturbe a ordem

test = list(set(testmod_mpp).difference(set(crkmod_mpp)))
print(test)
['POA23', 'POA15', 'POA17', 'POA16', 'POA22', 'POA18', 'POA24', 'POA21']

O Method1 np.setdiff1datende perfeitamente aos meus requisitos. Esta resposta para informações.

Se o número de ocorrências deve ser levado em consideração, você provavelmente precisará usar algo como collections.Counter:

list_1=["a", "b", "c", "d", "e"]
list_2=["a", "f", "c", "m"] 
from collections import Counter
cnt1 = Counter(list_1)
cnt2 = Counter(list_2)
final = [key for key, counts in cnt2.items() if cnt1.get(key, 0) != counts]

>>> final
['f', 'm']

Como prometido, isso também pode lidar com diferentes números de ocorrências como "diferença":

list_1=["a", "b", "c", "d", "e", 'a']
cnt1 = Counter(list_1)
cnt2 = Counter(list_2)
final = [key for key, counts in cnt2.items() if cnt1.get(key, 0) != counts]

>>> final
['a', 'f', 'm']

No ser1 remova os itens presentes no ser2.

Entrada

ser1 = pd.Series ([1, 2, 3, 4, 5]) ser2 = pd.Series ([4, 5, 6, 7, 8])

Solução

ser1 [~ ser1.isin (ser2)]