Je sais comment obtenir une intersection de deux listes plates:

b1 = [1,2,3,4,5,9,11,15]
b2 = [4,5,6,7,8]
b3 = [val for val in b1 if val in b2]

ou

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

print intersect(b1, b2)

Mais quand je dois trouver une intersection pour des listes imbriquées, mes problèmes commencent:

c1 = [1, 6, 7, 10, 13, 28, 32, 41, 58, 63]
c2 = [[13, 17, 18, 21, 32], [7, 11, 13, 14, 28], [1, 5, 6, 8, 15, 16]]

Au final, j'aimerais recevoir:

c3 = [[13,32],[7,13,28],[1,6]]

Pouvez-vous me donner un coup de main avec ça?

en relation

• Aplatir une liste peu profonde en python

Si tu veux:

c1 = [1, 6, 7, 10, 13, 28, 32, 41, 58, 63]
c2 = [[13, 17, 18, 21, 32], [7, 11, 13, 14, 28], [1, 5, 6, 8, 15, 16]]
c3 = [[13, 32], [7, 13, 28], [1,6]]

Alors voici votre solution pour Python 2:

c3 = [filter(lambda x: x in c1, sublist) for sublist in c2]

En Python 3 filterretourne un itérable au lieu de list, vous devez donc encapsuler les filterappels avec list():

c3 = [list(filter(lambda x: x in c1, sublist)) for sublist in c2]

Explication:

La partie filtre prend l'élément de chaque sous-liste et vérifie s'il se trouve dans la liste source c1. La compréhension de la liste est exécutée pour chaque sous-liste en c2.

Vous n'avez pas besoin de définir l'intersection. C'est déjà une partie de première classe de l'ensemble.

>>> b1 = [1,2,3,4,5,9,11,15]
>>> b2 = [4,5,6,7,8]
>>> set(b1).intersection(b2)
set([4, 5])

Pour les personnes cherchant simplement à trouver l'intersection de deux listes, l'Asker a fourni deux méthodes:

b1 = [1,2,3,4,5,9,11,15]
b2 = [4,5,6,7,8]
b3 = [val for val in b1 if val in b2]

et

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

print intersect(b1, b2)

Mais il existe une méthode hybride plus efficace, car vous n'avez qu'à effectuer une conversion entre liste / ensemble, par opposition à trois:

b1 = [1,2,3,4,5]
b2 = [3,4,5,6]
s2 = set(b2)
b3 = [val for val in b1 if val in s2]

Cela fonctionnera en O (n), alors que sa méthode originale impliquant la compréhension de liste fonctionnera en O (n ^ 2)

L'approche fonctionnelle:

input_list = [[1, 2, 3, 4, 5], [2, 3, 4, 5, 6], [3, 4, 5, 6, 7]]

result = reduce(set.intersection, map(set, input_list))

et il peut être appliqué au cas plus général de 1+ listes

Version de compréhension de liste pure

>>> c1 = [1, 6, 7, 10, 13, 28, 32, 41, 58, 63]
>>> c2 = [[13, 17, 18, 21, 32], [7, 11, 13, 14, 28], [1, 5, 6, 8, 15, 16]]
>>> c1set = frozenset(c1)

Aplatir la variante:

>>> [n for lst in c2 for n in lst if n in c1set]
[13, 32, 7, 13, 28, 1, 6]

Variante imbriquée:

>>> [[n for n in lst if n in c1set] for lst in c2]
[[13, 32], [7, 13, 28], [1, 6]]

L'opérateur & prend l'intersection de deux ensembles.

{1, 2, 3} & {2, 3, 4}
Out[1]: {2, 3}

Une façon pythonique de prendre l'intersection de 2 listes est:

[x for x in list1 if x in list2]

Vous devriez aplatir en utilisant ce code (extrait de http://kogs-www.informatik.uni-hamburg.de/~meine/python_tricks ), le code n'est pas testé, mais je suis presque sûr que cela fonctionne:

def flatten(x):
    """flatten(sequence) -> list

    Returns a single, flat list which contains all elements retrieved
    from the sequence and all recursively contained sub-sequences
    (iterables).

    Examples:
    >>> [1, 2, [3,4], (5,6)]
    [1, 2, [3, 4], (5, 6)]
    >>> flatten([[[1,2,3], (42,None)], [4,5], [6], 7, MyVector(8,9,10)])
    [1, 2, 3, 42, None, 4, 5, 6, 7, 8, 9, 10]"""

    result = []
    for el in x:
        #if isinstance(el, (list, tuple)):
        if hasattr(el, "__iter__") and not isinstance(el, basestring):
            result.extend(flatten(el))
        else:
            result.append(el)
    return result

Après avoir aplati la liste, vous effectuez l'intersection de la manière habituelle:

c1 = [1, 6, 7, 10, 13, 28, 32, 41, 58, 63]
c2 = [[13, 17, 18, 21, 32], [7, 11, 13, 14, 28], [1, 5, 6, 8, 15, 16]]

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

print intersect(flatten(c1), flatten(c2))

Depuis intersectsa définition, une compréhension de base des listes suffit:

>>> c3 = [intersect(c1, i) for i in c2]
>>> c3
[[32, 13], [28, 13, 7], [1, 6]]

Amélioration grâce à la remarque de S. Lott et à la remarque associée de TM:

>>> c3 = [list(set(c1).intersection(i)) for i in c2]
>>> c3
[[32, 13], [28, 13, 7], [1, 6]]

Donné:

> c1 = [1, 6, 7, 10, 13, 28, 32, 41, 58, 63]

> c2 = [[13, 17, 18, 21, 32], [7, 11, 13, 14, 28], [1, 5, 6, 8, 15, 16]]

Je trouve que le code suivant fonctionne bien et peut-être plus concis si vous utilisez l'opération set:

> c3 = [list(set(f)&set(c1)) for f in c2] 

Il a obtenu:

> [[32, 13], [28, 13, 7], [1, 6]]

Si commande nécessaire:

> c3 = [sorted(list(set(f)&set(c1))) for f in c2] 

nous avons:

> [[13, 32], [7, 13, 28], [1, 6]]

Soit dit en passant, pour un style plus python, celui-ci est très bien aussi:

> c3 = [ [i for i in set(f) if i in c1] for f in c2]

Je ne sais pas si je suis en retard pour répondre à votre question. Après avoir lu votre question, j'ai trouvé une fonction intersect () qui peut fonctionner à la fois sur la liste et la liste imbriquée. J'ai utilisé la récursivité pour définir cette fonction, elle est très intuitive. J'espère que c'est ce que vous recherchez:

def intersect(a, b):
    result=[]
    for i in b:
        if isinstance(i,list):
            result.append(intersect(a,i))
        else:
            if i in a:
                 result.append(i)
    return result

Exemple:

>>> c1 = [1, 6, 7, 10, 13, 28, 32, 41, 58, 63]
>>> c2 = [[13, 17, 18, 21, 32], [7, 11, 13, 14, 28], [1, 5, 6, 8, 15, 16]]
>>> print intersect(c1,c2)
[[13, 32], [7, 13, 28], [1, 6]]

>>> b1 = [1,2,3,4,5,9,11,15]
>>> b2 = [4,5,6,7,8]
>>> print intersect(b1,b2)
[4, 5]

Considérez-vous [1,2]croiser [1, [2]]? Autrement dit, est-ce seulement les chiffres qui vous intéressent, ou la structure de la liste aussi?

Si seuls les chiffres, étudiez comment "aplatir" les listes, puis utilisez la set()méthode.

Je cherchais également un moyen de le faire, et finalement ça a fini comme ça:

def compareLists(a,b):
    removed = [x for x in a if x not in b]
    added = [x for x in b if x not in a]
    overlap = [x for x in a if x in b]
    return [removed,added,overlap]

c1 = [1, 6, 7, 10, 13, 28, 32, 41, 58, 63]

c2 = [[13, 17, 18, 21, 32], [7, 11, 13, 14, 28], [1, 5, 6, 8, 15, 16]]

c3 = [list(set(c2[i]).intersection(set(c1))) for i in xrange(len(c2))]

c3
->[[32, 13], [28, 13, 7], [1, 6]]

Nous pouvons utiliser des méthodes définies pour cela:

c1 = [1, 6, 7, 10, 13, 28, 32, 41, 58, 63]
c2 = [[13, 17, 18, 21, 32], [7, 11, 13, 14, 28], [1, 5, 6, 8, 15, 16]]

   result = [] 
   for li in c2:
       res = set(li) & set(c1)
       result.append(list(res))

   print result

Pour définir une intersection qui prend correctement en compte la cardinalité des éléments, utilisez Counter:

from collections import Counter

>>> c1 = [1, 2, 2, 3, 4, 4, 4]
>>> c2 = [1, 2, 4, 4, 4, 4, 5]
>>> list((Counter(c1) & Counter(c2)).elements())
[1, 2, 4, 4, 4]

# Problem:  Given c1 and c2:
c1 = [1, 6, 7, 10, 13, 28, 32, 41, 58, 63]
c2 = [[13, 17, 18, 21, 32], [7, 11, 13, 14, 28], [1, 5, 6, 8, 15, 16]]
# how do you get c3 to be [[13, 32], [7, 13, 28], [1, 6]] ?

Voici une façon de définir c3qui n'implique pas d'ensembles:

c3 = []
for sublist in c2:
    c3.append([val for val in c1 if val in sublist])

Mais si vous préférez utiliser une seule ligne, vous pouvez le faire:

c3 = [[val for val in c1 if val in sublist]  for sublist in c2]

C'est une compréhension de liste à l'intérieur d'une compréhension de liste, ce qui est un peu inhabituel, mais je pense que vous ne devriez pas avoir trop de mal à la suivre.

c1 = [1, 6, 7, 10, 13, 28, 32, 41, 58, 63]
c2 = [[13, 17, 18, 21, 32], [7, 11, 13, 14, 28], [1, 5, 6, 8, 15, 16]]
c3 = [list(set(i) & set(c1)) for i in c2]
c3
[[32, 13], [28, 13, 7], [1, 6]]

Pour moi, c'est un moyen très élégant et rapide d'y arriver :)

la liste plate peut être établie reducefacilement.

Tout ce dont vous avez besoin pour utiliser l' initialiseur - troisième argument dans la reducefonction.

reduce(
   lambda result, _list: result.append(
       list(set(_list)&set(c1)) 
     ) or result, 
   c2, 
   [])

Le code ci-dessus fonctionne pour python2 et python3, mais vous devez importer le module de réduction sous from functools import reduce. Reportez-vous au lien ci-dessous pour plus de détails.

• pour python2

• pour python3

Un moyen simple de trouver la différence et l'intersection entre les itérables

Utilisez cette méthode si la répétition est importante

from collections import Counter

def intersection(a, b):
    """
    Find the intersection of two iterables

    >>> intersection((1,2,3), (2,3,4))
    (2, 3)

    >>> intersection((1,2,3,3), (2,3,3,4))
    (2, 3, 3)

    >>> intersection((1,2,3,3), (2,3,4,4))
    (2, 3)

    >>> intersection((1,2,3,3), (2,3,4,4))
    (2, 3)
    """
    return tuple(n for n, count in (Counter(a) & Counter(b)).items() for _ in range(count))

def difference(a, b):
    """
    Find the symmetric difference of two iterables

    >>> difference((1,2,3), (2,3,4))
    (1, 4)

    >>> difference((1,2,3,3), (2,3,4))
    (1, 3, 4)

    >>> difference((1,2,3,3), (2,3,4,4))
    (1, 3, 4, 4)
    """
    diff = lambda x, y: tuple(n for n, count in (Counter(x) - Counter(y)).items() for _ in range(count))
    return diff(a, b) + diff(b, a)