Bagaimana saya bisa membandingkan dua daftar dalam python dan mengembalikan kecocokan

Saya ingin mengambil dua daftar dan menemukan nilai yang muncul di keduanya.

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

returnMatches(a, b)

akan kembali [5], misalnya.

Bukan yang paling efisien, tetapi sejauh ini cara yang paling jelas untuk melakukannya adalah:

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

jika pesanan signifikan, Anda dapat melakukannya dengan daftar pemahaman seperti ini:

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

(hanya berfungsi untuk daftar berukuran sama, yang menyiratkan signifikansi pesanan).

Gunakan set.intersection () , cepat dan mudah dibaca.

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

Tes kinerja cepat yang menunjukkan solusi Lutz adalah yang terbaik:

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)

Ini adalah hasil di mesin saya:

# 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

Jelas, setiap tes kinerja buatan harus diambil dengan sebutir garam, tetapi karena set().intersection()jawabannya setidaknya secepat solusi lain, dan juga yang paling mudah dibaca, itu harus menjadi solusi standar untuk masalah umum ini.

Saya lebih suka jawaban berdasarkan set, tapi tetap saja ada yang berhasil

[x for x in a if x in b]

Cara termudah untuk melakukannya adalah dengan menggunakan set :

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

Cara cepat:

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

Anda juga dapat mencoba ini, dengan menyimpan elemen umum dalam daftar baru.

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

Apakah Anda ingin duplikat? Jika tidak, Anda sebaiknya menggunakan set sebagai gantinya:

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

cara lain yang sedikit lebih fungsional untuk memeriksa daftar persamaan untuk daftar 1 (lst1) dan daftar 2 (lst2) di mana objek memiliki kedalaman satu dan yang menjaga urutannya adalah:

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 

Dapat menggunakan itertools.product juga.

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

Kamu bisa menggunakan

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

Kamu bisa menggunakan:

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

Keluaran:

set([1, 7, 9])

Jika Anda menginginkan nilai 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

Solusi berikut berfungsi untuk setiap urutan item daftar dan juga mendukung kedua daftar dengan panjang yang berbeda.

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]

Menggunakan __and__metode atribut juga berfungsi.

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

atau sederhana

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

Saya hanya menggunakan yang berikut ini dan itu berhasil untuk saya:

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)

ini kemudian akan mencetak 5 dalam kasus Anda. Mungkin kinerja yang tidak bijaksana.