Saya tahu cara mendapatkan persimpangan dua daftar datar:

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]

atau

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

print intersect(b1, b2)

Tetapi ketika saya harus menemukan persimpangan untuk daftar bersarang maka masalah saya mulai:

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

Pada akhirnya saya ingin menerima:

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

Bisakah kalian bantu saya dengan ini?

Terkait

• Meratakan daftar dangkal dengan python

Jika kamu mau:

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

Maka di sini adalah solusi Anda untuk Python 2:

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

Di Python 3 filtermengembalikan iterable, bukan list, jadi Anda harus membungkus filterpanggilan dengan list():

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

Penjelasan:

Bagian filter mengambil setiap item sublist dan memeriksa untuk melihat apakah ada dalam daftar sumber c1. Pemahaman daftar dieksekusi untuk setiap sublist di c2.

Anda tidak perlu mendefinisikan persimpangan. Ini sudah menjadi bagian dari kelas set.

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

Bagi orang-orang yang hanya ingin menemukan persimpangan dua daftar, Penanya menyediakan dua metode:

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]

dan

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

print intersect(b1, b2)

Tetapi ada metode hybrid yang lebih efisien, karena Anda hanya perlu melakukan satu konversi antara daftar / set, berbeda dengan tiga:

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

Ini akan berjalan di O (n), sedangkan metode aslinya yang melibatkan pemahaman daftar akan berjalan di O (n ^ 2)

Pendekatan fungsional:

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

dan itu dapat diterapkan pada kasus 1+ daftar yang lebih umum

Versi pemahaman daftar murni

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

Varian rata:

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

Varian bersarang:

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

Operator & mengambil persimpangan dua set.

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

Cara pythonic mengambil persimpangan 2 daftar adalah:

[x for x in list1 if x in list2]

Anda harus meratakan menggunakan kode ini (diambil dari http://kogs-www.informatik.uni-hamburg.de/~meine/python_tricks ), kodenya belum teruji, tapi saya cukup yakin itu berhasil:

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

Setelah Anda meratakan daftar, Anda melakukan persimpangan dengan cara yang biasa:

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

Sejak intersectdidefinisikan, pemahaman daftar dasar sudah cukup:

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

Peningkatan berkat ucapan S. Lott dan komentar terkait TM:

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

Diberikan:

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

Saya menemukan kode berikut berfungsi dengan baik dan mungkin lebih ringkas jika menggunakan operasi yang ditetapkan:

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

Itu mendapat:

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

Jika pesanan diperlukan:

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

kita punya:

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

Omong-omong, untuk gaya python yang lebih banyak, yang ini juga baik-baik saja:

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

Saya tidak tahu apakah saya terlambat menjawab pertanyaan Anda. Setelah membaca pertanyaan Anda, saya datang dengan fungsi intersect () yang dapat bekerja pada daftar dan daftar bersarang. Saya menggunakan rekursi untuk mendefinisikan fungsi ini, sangat intuitif. Semoga ini yang Anda cari:

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

Contoh:

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

Apakah Anda mempertimbangkan [1,2]untuk bersinggungan [1, [2]]? Artinya, apakah hanya angka yang Anda pedulikan, atau struktur daftar juga?

Jika hanya angka-angka, selidiki bagaimana cara "meratakan" daftar, kemudian gunakan set()metode.

Saya juga mencari cara untuk melakukannya, dan akhirnya berakhir seperti ini:

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

Kita dapat menggunakan metode yang ditetapkan untuk ini:

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

Untuk mendefinisikan persimpangan yang memperhitungkan kardinalitas elemen dengan benar, gunakan 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]] ?

Berikut ini satu cara untuk menyetel c3yang tidak melibatkan set:

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

Tetapi jika Anda lebih suka menggunakan satu baris saja, Anda bisa melakukan ini:

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

Ini adalah pemahaman daftar di dalam pemahaman daftar, yang agak tidak biasa, tapi saya pikir Anda seharusnya tidak mengalami terlalu banyak kesulitan untuk mengikutinya.

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

Bagi saya ini adalah cara yang sangat elegan dan cepat untuk itu :)

daftar datar dapat dibuat dengan reducemudah.

Yang Anda butuhkan untuk menggunakan initializer - argumen ketiga dalam reducefungsi.

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

Kode di atas berfungsi untuk python2 dan python3, tetapi Anda perlu mengimpor mengurangi modul sebagai from functools import reduce. Lihat tautan di bawah untuk detailnya.

• untuk python2

• untuk python3

Cara sederhana untuk menemukan perbedaan dan persimpangan antara iterables

Gunakan metode ini jika pengulangan penting

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)