Làm thế nào tôi có thể so sánh hai danh sách trong python và trả lại trận đấu

Tôi muốn lấy hai danh sách và tìm các giá trị xuất hiện trong cả hai.

a = [1, 2, 3, 4, 5]
b = [9, 8, 7, 6, 5]

returnMatches(a, b)

sẽ trở lại [5], ví dụ.

Không phải là cách hiệu quả nhất, nhưng cho đến nay, cách rõ ràng nhất để làm điều đó là:

>>> a = [1, 2, 3, 4, 5]
>>> b = [9, 8, 7, 6, 5]
>>> set(a) & set(b)
{5}

Nếu thứ tự là quan trọng, bạn có thể làm điều đó với việc hiểu danh sách như thế này:

>>> [i for i, j in zip(a, b) if i == j]
[5]

(chỉ hoạt động cho các danh sách có kích thước bằng nhau, có ý nghĩa theo thứ tự).

Sử dụng set.intersection () , nó nhanh và dễ đọc.

>>> set(a).intersection(b)
set([5])

Một thử nghiệm hiệu suất nhanh cho thấy giải pháp của Lutz là tốt nhất:

import time

def speed_test(func):
    def wrapper(*args, **kwargs):
        t1 = time.time()
        for x in xrange(5000):
            results = func(*args, **kwargs)
        t2 = time.time()
        print '%s took %0.3f ms' % (func.func_name, (t2-t1)*1000.0)
        return results
    return wrapper

@speed_test
def compare_bitwise(x, y):
    set_x = frozenset(x)
    set_y = frozenset(y)
    return set_x & set_y

@speed_test
def compare_listcomp(x, y):
    return [i for i, j in zip(x, y) if i == j]

@speed_test
def compare_intersect(x, y):
    return frozenset(x).intersection(y)

# Comparing short lists
a = [1, 2, 3, 4, 5]
b = [9, 8, 7, 6, 5]
compare_bitwise(a, b)
compare_listcomp(a, b)
compare_intersect(a, b)

# Comparing longer lists
import random
a = random.sample(xrange(100000), 10000)
b = random.sample(xrange(100000), 10000)
compare_bitwise(a, b)
compare_listcomp(a, b)
compare_intersect(a, b)

Đây là kết quả trên máy của tôi:

# Short list:
compare_bitwise took 10.145 ms
compare_listcomp took 11.157 ms
compare_intersect took 7.461 ms

# Long list:
compare_bitwise took 11203.709 ms
compare_listcomp took 17361.736 ms
compare_intersect took 6833.768 ms

Rõ ràng, bất kỳ thử nghiệm hiệu suất nhân tạo nào cũng nên được thực hiện bằng một hạt muối, nhưng vì set().intersection()câu trả lời ít nhất là nhanh như các giải pháp khác, và cũng dễ đọc nhất, nên nó là giải pháp chuẩn cho vấn đề phổ biến này.

Tôi thích các câu trả lời dựa trên tập hợp, nhưng đây là câu trả lời hoạt động

[x for x in a if x in b]

Cách dễ nhất để làm điều đó là sử dụng các bộ :

>>> a = [1, 2, 3, 4, 5]
>>> b = [9, 8, 7, 6, 5]
>>> set(a) & set(b)
set([5])

Đường tắt:

list(set(a).intersection(set(b)))

>>> s = ['a','b','c']   
>>> f = ['a','b','d','c']  
>>> ss= set(s)  
>>> fs =set(f)  
>>> print ss.intersection(fs)   
   **set(['a', 'c', 'b'])**  
>>> print ss.union(fs)        
   **set(['a', 'c', 'b', 'd'])**  
>>> print ss.union(fs)  - ss.intersection(fs)   
   **set(['d'])**

Ngoài ra, bạn có thể thử điều này, bằng cách giữ các yếu tố phổ biến trong một danh sách mới.

new_list = []
for element in a:
    if element in b:
        new_list.append(element)

Bạn có muốn trùng lặp? Nếu không có lẽ bạn nên sử dụng bộ thay thế:

>>> set([1, 2, 3, 4, 5]).intersection(set([9, 8, 7, 6, 5]))
set([5])

một cách khác có chức năng hơn một chút để kiểm tra sự bình đẳng danh sách cho danh sách 1 (lst1) và danh sách 2 (lst2) trong đó các đối tượng có độ sâu một và giữ trật tự là:

all(i == j for i, j in zip(lst1, lst2))   

a = [1, 2, 3, 4, 5]
b = [9, 8, 7, 6, 5]

lista =set(a)
listb =set(b)   
print listb.intersection(lista)   
returnMatches = set(['5']) #output 

print " ".join(str(return) for return in returnMatches ) # remove the set()   

 5        #final output 

Có thể sử dụng itertools.product quá.

>>> common_elements=[]
>>> for i in list(itertools.product(a,b)):
...     if i[0] == i[1]:
...         common_elements.append(i[0])

Bạn có thể dùng

def returnMatches(a,b):
       return list(set(a) & set(b))

Bạn có thể dùng:

a = [1, 3, 4, 5, 9, 6, 7, 8]
b = [1, 7, 0, 9]
same_values = set(a) & set(b)
print same_values

Đầu ra:

set([1, 7, 9])

Nếu bạn muốn một giá trị boolean:

>>> a = [1, 2, 3, 4, 5]
>>> b = [9, 8, 7, 6, 5]
>>> set(b) == set(a)  & set(b) and set(a) == set(a) & set(b)
False
>>> a = [3,1,2]
>>> b = [1,2,3]
>>> set(b) == set(a)  & set(b) and set(a) == set(a) & set(b)
True

Giải pháp sau đây hoạt động cho mọi thứ tự của danh sách và cũng hỗ trợ cả hai danh sách có độ dài khác nhau.

import numpy as np
def getMatches(a, b):
    matches = []
    unique_a = np.unique(a)
    unique_b = np.unique(b)
    for a in unique_a:
        for b in unique_b:
            if a == b:
                matches.append(a)
    return matches
print(getMatches([1, 2, 3, 4, 5], [9, 8, 7, 6, 5, 9])) # displays [5]
print(getMatches([1, 2, 3], [3, 4, 5, 1])) # displays [1, 3]

Sử dụng __and__phương pháp thuộc tính cũng hoạt động.

>>> a = [1, 2, 3, 4, 5]
>>> b = [9, 8, 7, 6, 5]
>>> set(a).__and__(set(b))
set([5])

hoặc đơn giản

>>> set([1, 2, 3, 4, 5]).__and__(set([9, 8, 7, 6, 5]))
set([5])
>>>    

you can | for set union and & for set intersection.
for example:

    set1={1,2,3}
    set2={3,4,5}
    print(set1&set2)
    output=3

    set1={1,2,3}
    set2={3,4,5}
    print(set1|set2)
    output=1,2,3,4,5

curly braces in the answer.

Tôi chỉ sử dụng như sau và nó làm việc cho tôi:

group1 = [1, 2, 3, 4, 5]
group2 = [9, 8, 7, 6, 5]

for k in group1:
    for v in group2:
        if k == v:
            print(k)

Điều này sau đó sẽ in 5 trong trường hợp của bạn. Có lẽ không phải là hiệu suất tuyệt vời khôn ngoan mặc dù.