Eu sei como obter uma interseção de duas listas simples:

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)

Mas quando tenho que encontrar a interseção para listas aninhadas, meus problemas começam:

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

No final, gostaria de receber:

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

Vocês podem me dar uma mão nisso?

Relacionado

• Achatando uma lista superficial em python

Se você quiser:

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

Então aqui está sua solução para o Python 2:

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

No Python 3, filterretorna um iterável em vez de list, portanto, é necessário agrupar as filterchamadas com list():

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

Explicação:

A parte do filtro pega o item de cada sub-lista e verifica se está na lista de fontes c1. A compreensão da lista é executada para cada sub-lista em c2.

Você não precisa definir interseção. Já é uma parte de primeira classe do set.

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

Para pessoas que procuram encontrar a interseção de duas listas, o Asker forneceu dois métodos:

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]

e

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

print intersect(b1, b2)

Mas há um método híbrido que é mais eficiente, porque você só precisa fazer uma conversão entre lista / conjunto, em vez de três:

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

Isso será executado em O (n), enquanto o método original que envolve compreensão de lista será executado em O (n ^ 2)

A abordagem funcional:

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

e pode ser aplicado ao caso mais geral de 1 ou mais listas

Versão de compreensão pura da lista

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

Achatar variante:

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

Variante aninhada:

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

O operador & faz a interseção de dois conjuntos.

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

Uma maneira pitônica de fazer a interseção de 2 listas é:

[x for x in list1 if x in list2]

Você deve nivelar usando este código (extraído de http://kogs-www.informatik.uni-hamburg.de/~meine/python_tricks ), o código não foi testado, mas tenho certeza de que funciona:

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

Depois de nivelar a lista, você faz a interseção da maneira usual:

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

Desde que intersectfoi definido, uma compreensão básica da lista é suficiente:

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

Melhoria graças à observação de S. Lott e à observação associada de TM.

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

Dado:

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

Acho que o código a seguir funciona bem e talvez seja mais conciso se estiver usando a operação set:

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

Tem:

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

Se pedido necessário:

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

obtemos:

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

A propósito, para um estilo mais python, este também é bom:

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

Não sei se estou atrasado em responder sua pergunta. Depois de ler sua pergunta, criei uma função intersect () que pode funcionar tanto na lista quanto na lista aninhada. Eu usei recursão para definir essa função, é muito intuitiva. Espero que seja o que você está procurando:

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

Exemplo:

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

Você considera [1,2]interceptar [1, [2]]? Ou seja, são apenas os números importantes para você ou a estrutura da lista?

Se apenas os números, investigue como "achatar" as listas e use o set()método

Eu também estava procurando uma maneira de fazer isso e, eventualmente, acabou assim:

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

Podemos usar métodos definidos para isso:

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

Para definir a interseção que leva em consideração corretamente a cardinalidade dos elementos, use 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]] ?

Aqui está uma maneira de definir c3que não envolve conjuntos:

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

Mas se você preferir usar apenas uma linha, poderá fazer o seguinte:

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

É uma compreensão de lista dentro de uma compreensão de lista, o que é um pouco incomum, mas acho que você não deve ter muita dificuldade em segui-la.

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

Para mim, esta é uma maneira muito elegante e rápida de fazê-lo :)

lista simples pode ser feita reducefacilmente.

Tudo o que você precisa para usar o inicializador - terceiro argumento na reducefunção.

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

O código acima funciona para python2 e python3, mas você precisa importar o módulo de redução como from functools import reduce. Consulte o link abaixo para obter detalhes.

• para python2

• para python3

Maneira simples de encontrar diferença e interseção entre iterables

Use este método se a repetição for 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)