Hoe kan ik twee lijsten in python vergelijken en overeenkomsten retourneren

Ik wil twee lijsten nemen en de waarden vinden die in beide voorkomen.

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

zou bijvoorbeeld [5]teruggeven.


Antwoord 1, autoriteit 100%

Niet de meest efficiënte, maar verreweg de meest voor de hand liggende manier om het te doen is:

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

als de volgorde belangrijk is, kunt u dit doen met lijstbegrippen zoals deze:

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

(werkt alleen voor lijsten van gelijke grootte, wat de volgorde-betekenis impliceert).


Antwoord 2, autoriteit 80%

Gebruik set.intersection(), het is snel en leesbaar.

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

Antwoord 3, autoriteit 21%

Een snelle prestatietest die de oplossing van Lutz laat zien, is de beste:

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)

Dit zijn de resultaten op mijn machine:

# 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

Uiteraard moet elke kunstmatige prestatietest worden genomen met een korrel zout, maar sinds de set().intersection()antwoord is ten minste net zo snel als de Andere oplossingen, en ook de meest leesbare, zou het de standaardoplossing voor dit gemeenschappelijk probleem moeten zijn.


Antwoord 4, Autoriteit 13%

Ik geef de voorkeur aan de op basis gebaseerde antwoorden, maar hier is er een die toch werkt

[x for x in a if x in b]

Antwoord 5, Autoriteit 4%

Snelle manier:

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

Antwoord 6, Autoriteit 3%

De eenvoudigste manier om dat te doen is om sets :

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

Antwoord 7, Autoriteit 3%

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

Antwoord 8, Autoriteit 2%

Ook kunt u dit proberen, door gemeenschappelijke elementen in een nieuwe lijst te houden.

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

Antwoord 9

Wilt u duplicaten? Zo niet, dan moet u in plaats daarvan sets gebruiken:

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

Antwoord 10

Nog een beetje een beetje functionele manier om lijstgelijkheid te controleren voor lijst 1 (LST1) en lijst 2 (LST2) waar objecten diepte hebben en die de bestelling behoudt is:

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

Antwoord 11

Kan itertools.product ook gebruiken.

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

Antwoord 12

U kunt

gebruiken

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

Antwoord 13

U kunt gebruiken:

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

Uitvoer:

set([1, 7, 9])

Antwoord 14

Als u een booleaanse waarde wilt:

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

Antwoord 15

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 

Antwoord 16

Ik heb zojuist het volgende gebruikt en het werkte voor mij:

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)

dit zou dan in uw geval 5 afdrukken. Waarschijnlijk niet geweldig qua prestaties.


Antwoord 17

De volgende oplossing werkt voor elke volgorde van lijstitems en ondersteunt ook dat beide lijsten een verschillende lengte hebben.

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]

Antwoord 18

Het gebruik van de kenmerkmethode __and__werkt ook.

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

of gewoon

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

Antwoord 19

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.

Other episodes