Python tìm các phần tử trong một danh sách không nằm trong một danh sách khác

Question

Tôi đang làm việc với các danh sách và tôi cần phải so sánh chúng để tạo danh sách các phần tử cụ thể mới. Ví dụ:

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

Tôi cần phải xếp vào danh sách_1 và nối thêm vào main_list = [] tất cả các yếu tố không khớp trong danh sách_2.

Kết quả sẽ là thế này:

main_list=["f", "m"] 

Làm thế nào tôi có thể làm điều đó với python?

Answer 1

(1) Bạn có thể sử dụng số setdiff1d của NumPy. Từ response of Chinny84, nếu bạn đang quan tâm đến yếu tố độc đáo, sau đó:

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) 

(2) Nếu không, sử dụng main_list = np.setdiff1d(list_2,list_1, assume_unique=True)

Cả hai câu trả lời sẽ cung cấp cho bạn ["f", "m"]. Tuy nhiên, nếu list_2 = ["a", "f", "c", "m", "m"], câu trả lời (1) sản lượng ["f", "m"] Câu trả lời BUT (2) cho ["f", "m", "m"] (vì tính duy nhất của mỗi phần tử trong list_2 là không quan trọng).

pythonnumpy

Answer 2

Tôi sẽ zip các danh sách với nhau để so sánh chúng với phần tử theo phần tử.

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

Answer 3

Bạn có thể sử dụng bộ:

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

Output:

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

mỗi comment @JonClements', đây là một phiên bản ngăn nắp:

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

Answer 4

Sử dụng một list comprehension như thế này:

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

Output:

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

Answer 5

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) 

đầu ra:

['f', 'm'] 

Answer 6

Nếu số lần xuất hiện nên được đưa vào tài khoản của bạn có thể cần phải sử dụng một cái gì đó giống như 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'] 

Như đã hứa điều này cũng có thể xử lý số lần xuất hiện khác nhau như "sự khác biệt":

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

Answer 7

Nếu bạn muốn có một giải pháp một liner (bỏ qua nhập khẩu) mà chỉ yêu cầu O(max(n, m)) làm việc cho các đầu vào có độ dài n và m, không O(n * m) làm việc, bạn có thể làm như vậy với the itertools module:

from itertools import filterfalse 

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

này có lợi thế trong những chức năng chức năng tham gia một hàm callback về xây dựng ion, cho phép nó tạo ra các cuộc gọi lại một lần và tái sử dụng nó cho mọi phần tử mà không cần lưu trữ nó ở đâu đó (vì filterfalse lưu trữ nó trong nội bộ); danh sách hiểu và biểu thức máy phát điện có thể làm điều này, nhưng nó xấu xí.†

Đó được kết quả tương tự trong một dòng duy nhất là:

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

với tốc độ:

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

Tất nhiên, nếu so sánh được dự định được vị trí, vì vậy:

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

phải xuất:

main_list = [2, 3, 4] 

(vì giá trị trong list_2 có một trận đấu ở các chỉ số tương tự trong list_1), bạn nên chắc chắn đi với Patrick's answer, trong đó bao gồm không list s tạm thời hoặc set s (ngay cả với set s là khoảng O(1), họ có một cao hơn "hằng số" yếu tố trên mỗi séc so với kiểm tra bình đẳng đơn giản) và liên quan đến công việc O(min(n, m)), ít hơn bất kỳ câu trả lời nào khác và nếu vấn đề của bạn nhạy cảm vị trí, chỉ là giải pháp đúng khi các yếu tố phù hợp xuất hiện ở vị trí không khớp.

†: Các cách để làm điều tương tự với một sự hiểu biết danh sách như một lớp lót sẽ được lạm dụng lồng looping để tạo và giá trị bộ nhớ cache (s) trong vòng lặp "ngoài cùng", ví dụ:

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

cũng cung cấp một lợi ích hiệu suất nhỏ trên Python 3 (vì bây giờ set_1 được kiểm tra cục bộ trong mã hiểu, thay vì tra cứu từ phạm vi lồng nhau cho mỗi kiểm tra; trên Python 2 không quan trọng, vì Python 2 không sử dụng các bao đóng để hiểu danh sách; chúng hoạt động trong cùng phạm vi mà chúng được sử dụng).

Answer 8

Không chắc tại sao những lời giải thích trên là quá phức tạp khi bạn có phương pháp tự nhiên có sẵn:

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