Bagaimana cara memeriksa apakah salah satu item berikut ada dalam daftar?

Saya mencoba menemukan cara singkat untuk melihat apakah ada item berikut dalam daftar, tetapi upaya pertama saya tidak berhasil. Selain menulis fungsi untuk mencapai ini, adalah cara singkat untuk memeriksa apakah salah satu dari beberapa item ada dalam daftar.

>>> a = [2,3,4]
>>> print (1 or 2) in a
False
>>> print (2 or 1) in a
True

>>> L1 = [2,3,4]
>>> L2 = [1,2]
>>> [i for i in L1 if i in L2]
[2]


>>> S1 = set(L1)
>>> S2 = set(L2)
>>> S1.intersection(S2)
set([2])

Daftar kosong dan set kosong adalah False, sehingga Anda dapat menggunakan nilai secara langsung sebagai nilai kebenaran.

Ah, Tobias kau mengalahkanku karenanya. Saya sedang memikirkan sedikit variasi pada solusi Anda ini:

>>> a = [1,2,3,4]
>>> b = [2,7]
>>> print(any(x in a for x in b))
True

Mungkin sedikit lebih malas:

a = [1,2,3,4]
b = [2,7]

print any((True for x in a if x in b))

Pikirkan tentang apa yang sebenarnya dikatakan kode!

>>> (1 or 2)
1
>>> (2 or 1)
2

Itu mungkin harus menjelaskannya. :) Python rupanya mengimplementasikan "malas atau", yang seharusnya tidak mengejutkan. Melakukannya sesuatu seperti ini:

def or(x, y):
    if x: return x
    if y: return y
    return False

Pada contoh pertama, x == 1dan y == 2. Dalam contoh kedua, itu sebaliknya. Itu sebabnya ia mengembalikan nilai yang berbeda tergantung pada urutannya.

a = {2,3,4}
if {1,2} & a:
    pass

Versi kode golf. Pertimbangkan menggunakan set jika masuk akal untuk melakukannya. Saya menemukan ini lebih mudah dibaca daripada pemahaman daftar.

1 baris tanpa daftar daftar.

>>> any(map(lambda each: each in [2,3,4], [1,2]))
True
>>> any(map(lambda each: each in [2,3,4], [1,5]))
False
>>> any(map(lambda each: each in [2,3,4], [2,4]))
True

Terbaik yang bisa saya kemukakan:

any([True for e in (1, 2) if e in a])

Dalam python 3 kita bisa mulai menggunakan tanda bintang yang belum dibuka. Diberikan dua daftar:

bool(len({*a} & {*b}))

Sunting: sertakan saran alkanen

Ketika Anda berpikir "centang untuk melihat apakah a dalam b", pikirkan hash (dalam hal ini, set). Cara tercepat adalah dengan hash daftar yang ingin Anda periksa, dan kemudian periksa setiap item di sana.

Inilah sebabnya mengapa jawaban Joe Koberg cepat: memeriksa set persimpangan sangat cepat.

Ketika Anda tidak memiliki banyak data, membuat set bisa membuang-buang waktu. Jadi, Anda dapat membuat satu set daftar dan cukup memeriksa setiap item:

tocheck = [1,2] # items to check
a = [2,3,4] # the list

a = set(a) # convert to set (O(len(a)))
print [i for i in tocheck if i in a] # check items (O(len(tocheck)))

Ketika jumlah item yang ingin Anda periksa kecil, perbedaannya dapat diabaikan. Tetapi periksa banyak angka terhadap daftar besar ...

tes:

from timeit import timeit

methods = ['''tocheck = [1,2] # items to check
a = [2,3,4] # the list
a = set(a) # convert to set (O(n))
[i for i in tocheck if i in a] # check items (O(m))''',

'''L1 = [2,3,4]
L2 = [1,2]
[i for i in L1 if i in L2]''',

'''S1 = set([2,3,4])
S2 = set([1,2])
S1.intersection(S2)''',

'''a = [1,2]
b = [2,3,4]
any(x in a for x in b)''']

for method in methods:
    print timeit(method, number=10000)

print

methods = ['''tocheck = range(200,300) # items to check
a = range(2, 10000) # the list
a = set(a) # convert to set (O(n))
[i for i in tocheck if i in a] # check items (O(m))''',

'''L1 = range(2, 10000)
L2 = range(200,300)
[i for i in L1 if i in L2]''',

'''S1 = set(range(2, 10000))
S2 = set(range(200,300))
S1.intersection(S2)''',

'''a = range(200,300)
b = range(2, 10000)
any(x in a for x in b)''']

for method in methods:
    print timeit(method, number=1000)

kecepatan:

M1: 0.0170331001282 # make one set
M2: 0.0164539813995 # list comprehension
M3: 0.0286040306091 # set intersection
M4: 0.0305438041687 # any

M1: 0.49850320816 # make one set
M2: 25.2735087872 # list comprehension
M3: 0.466138124466 # set intersection
M4: 0.668627977371 # any

Metode yang secara konsisten cepat adalah membuat satu set (dari daftar), tetapi persimpangan bekerja pada data besar menentukan yang terbaik!

Dalam beberapa kasus (misalnya elemen daftar unik), operasi yang ditetapkan dapat digunakan.

>>> a=[2,3,4]
>>> set(a) - set([2,3]) != set(a)
True
>>> 

Atau, menggunakan set.isdisjoint () ,

>>> not set(a).isdisjoint(set([2,3]))
True
>>> not set(a).isdisjoint(set([5,6]))
False
>>> 

Ini akan melakukannya dalam satu baris.

>>> a=[2,3,4]
>>> b=[1,2]
>>> bool(sum(map(lambda x: x in b, a)))
True

Saya mengumpulkan beberapa solusi yang disebutkan dalam jawaban lain dan dalam komentar, kemudian menjalankan tes kecepatan. not set(a).isdisjoint(b)ternyata yang tercepat, ternyata juga tidak banyak melambat ketika hasilnya False.

Masing-masing dari tiga tes menjalankan sampel kecil dari kemungkinan konfigurasi adan b. Waktu dalam mikrodetik.

Any with generator and max
        2.093 1.997 7.879
Any with generator
        0.907 0.692 2.337
Any with list
        1.294 1.452 2.137
True in list
        1.219 1.348 2.148
Set with &
        1.364 1.749 1.412
Set intersection explcit set(b)
        1.424 1.787 1.517
Set intersection implicit set(b)
        0.964 1.298 0.976
Set isdisjoint explicit set(b)
        1.062 1.094 1.241
Set isdisjoint implicit set(b)
        0.622 0.621 0.753

import timeit

def printtimes(t):
    print '{:.3f}'.format(t/10.0),

setup1 = 'a = range(10); b = range(9,15)'
setup2 = 'a = range(10); b = range(10)'
setup3 = 'a = range(10); b = range(10,20)'

print 'Any with generator and max\n\t',
printtimes(timeit.Timer('any(x in max(a,b,key=len) for x in min(b,a,key=len))',setup=setup1).timeit(10000000))
printtimes(timeit.Timer('any(x in max(a,b,key=len) for x in min(b,a,key=len))',setup=setup2).timeit(10000000))
printtimes(timeit.Timer('any(x in max(a,b,key=len) for x in min(b,a,key=len))',setup=setup3).timeit(10000000))
print

print 'Any with generator\n\t',
printtimes(timeit.Timer('any(i in a for i in b)',setup=setup1).timeit(10000000))
printtimes(timeit.Timer('any(i in a for i in b)',setup=setup2).timeit(10000000))
printtimes(timeit.Timer('any(i in a for i in b)',setup=setup3).timeit(10000000))
print

print 'Any with list\n\t',
printtimes(timeit.Timer('any([i in a for i in b])',setup=setup1).timeit(10000000))
printtimes(timeit.Timer('any([i in a for i in b])',setup=setup2).timeit(10000000))
printtimes(timeit.Timer('any([i in a for i in b])',setup=setup3).timeit(10000000))
print

print 'True in list\n\t',
printtimes(timeit.Timer('True in [i in a for i in b]',setup=setup1).timeit(10000000))
printtimes(timeit.Timer('True in [i in a for i in b]',setup=setup2).timeit(10000000))
printtimes(timeit.Timer('True in [i in a for i in b]',setup=setup3).timeit(10000000))
print

print 'Set with &\n\t',
printtimes(timeit.Timer('bool(set(a) & set(b))',setup=setup1).timeit(10000000))
printtimes(timeit.Timer('bool(set(a) & set(b))',setup=setup2).timeit(10000000))
printtimes(timeit.Timer('bool(set(a) & set(b))',setup=setup3).timeit(10000000))
print

print 'Set intersection explcit set(b)\n\t',
printtimes(timeit.Timer('bool(set(a).intersection(set(b)))',setup=setup1).timeit(10000000))
printtimes(timeit.Timer('bool(set(a).intersection(set(b)))',setup=setup2).timeit(10000000))
printtimes(timeit.Timer('bool(set(a).intersection(set(b)))',setup=setup3).timeit(10000000))
print

print 'Set intersection implicit set(b)\n\t',
printtimes(timeit.Timer('bool(set(a).intersection(b))',setup=setup1).timeit(10000000))
printtimes(timeit.Timer('bool(set(a).intersection(b))',setup=setup2).timeit(10000000))
printtimes(timeit.Timer('bool(set(a).intersection(b))',setup=setup3).timeit(10000000))
print

print 'Set isdisjoint explicit set(b)\n\t',
printtimes(timeit.Timer('not set(a).isdisjoint(set(b))',setup=setup1).timeit(10000000))
printtimes(timeit.Timer('not set(a).isdisjoint(set(b))',setup=setup2).timeit(10000000))
printtimes(timeit.Timer('not set(a).isdisjoint(set(b))',setup=setup3).timeit(10000000))
print

print 'Set isdisjoint implicit set(b)\n\t',
printtimes(timeit.Timer('not set(a).isdisjoint(b)',setup=setup1).timeit(10000000))
printtimes(timeit.Timer('not set(a).isdisjoint(b)',setup=setup1).timeit(10000000))
printtimes(timeit.Timer('not set(a).isdisjoint(b)',setup=setup3).timeit(10000000))
print

Saya harus mengatakan bahwa situasi saya mungkin bukan yang Anda cari, tetapi mungkin memberikan alternatif bagi pemikiran Anda.

Saya telah mencoba metode set () dan any () tetapi masih memiliki masalah dengan kecepatan. Jadi saya ingat Raymond Hettinger mengatakan semuanya dengan python adalah kamus dan gunakan dict kapan pun Anda bisa. Jadi itulah yang saya coba.

Saya menggunakan defaultdict dengan int untuk menunjukkan hasil negatif dan menggunakan item dalam daftar pertama sebagai kunci untuk daftar kedua (dikonversi ke defaultdict). Karena Anda memiliki pencarian instan dengan dict, Anda langsung tahu apakah item itu ada di defaultdict. Saya tahu Anda tidak selalu bisa mengubah struktur data untuk daftar kedua Anda, tetapi jika Anda bisa dari awal, maka itu jauh lebih cepat. Anda mungkin harus mengubah list2 (daftar yang lebih besar) ke defaultdict, di mana kunci adalah nilai potensial yang ingin Anda periksa dari daftar kecil, dan nilainya adalah 1 (klik) atau 0 (tanpa klik, default).

from collections import defaultdict
already_indexed = defaultdict(int)

def check_exist(small_list, default_list):
    for item in small_list:
        if default_list[item] == 1:
            return True
    return False

if check_exist(small_list, already_indexed):
    continue
else:
    for x in small_list:
        already_indexed[x] = 1

Sederhana.

_new_list = []
for item in a:
    if item in b:
        _new_list.append(item)
    else:
        pass