Listelerin python'daki herhangi bir öğeyi paylaşıp paylaşmadığını test edin

Bir listedeki öğelerden herhangi birinin başka bir listede olup olmadığını kontrol etmek istiyorum . Bunu basitçe aşağıdaki kodla yapabilirim, ancak bunu yapacak bir kütüphane işlevi olabileceğinden şüpheleniyorum. Değilse, aynı sonucu elde etmenin daha pitonik bir yöntemi var mı?

In [78]: a = [1, 2, 3, 4, 5]

In [79]: b = [8, 7, 6]

In [80]: c = [8, 7, 6, 5]

In [81]: def lists_overlap(a, b):
   ....:     for i in a:
   ....:         if i in b:
   ....:             return True
   ....:     return False
   ....: 

In [82]: lists_overlap(a, b)
Out[82]: False

In [83]: lists_overlap(a, c)
Out[83]: True

In [84]: def lists_overlap2(a, b):
   ....:     return len(set(a).intersection(set(b))) > 0
   ....: 

Kısa cevap : kullanın not set(a).isdisjoint(b), genellikle en hızlısıdır.

İki liste aolup olmadığını test etmenin ve bherhangi bir öğeyi paylaşmanın dört yaygın yolu vardır . İlk seçenek, her ikisini de kümelere dönüştürmek ve kesişimlerini kontrol etmektir, örneğin:

bool(set(a) & set(b))

Çünkü setleri onları olduğu arama, Python bir karma tablo kullanılarak depolanırO(1) (bkz burada Python operatörleri karmaşıklığı hakkında daha fazla bilgi için). Teorik olarak, bu O(n+m)ortalama üzerinde nve mlistelerde nesneleri ave b. Ancak 1) önce listelerden ihmal edilemeyecek bir süre alabilen kümeler oluşturmalıdır ve 2) karma çarpışmaların verileriniz arasında seyrek olduğunu varsayar.

Bunu yapmanın ikinci yolu, listelerde yineleme yapan bir üretici ifadesi kullanmaktır, örneğin:

any(i in a for i in b)

Bu, yerinde aramaya izin verir, böylece ara değişkenler için yeni bellek tahsis edilmez. Aynı zamanda ilk bulgudan kurtulur. Ancak inoperatör her zaman O(n)listelerde bulunur ( buraya bakın ).

Önerilen diğer bir seçenek ise, listeden birini yinelemek, diğerini bir sette dönüştürmek ve bu sette üyeliği test etmek için hibrittir, örneğin:

a = set(a); any(i in a for i in b)

Dördüncü bir yaklaşım, isdisjoint()(dondurulmuş) kümelerin yönteminden yararlanmaktır ( buraya bakın ), örneğin:

not set(a).isdisjoint(b)

Aradığınız elemanlar bir dizinin başlangıcına yakınsa (örneğin sıralanırsa), setler kesişimi yönteminin ara değişkenler için yeni bellek ayırması gerektiğinden, oluşturucu ifadesi tercih edilir:

from timeit import timeit
>>> timeit('bool(set(a) & set(b))', setup="a=list(range(1000));b=list(range(1000))", number=100000)
26.077727576019242
>>> timeit('any(i in a for i in b)', setup="a=list(range(1000));b=list(range(1000))", number=100000)
0.16220548999262974

Liste boyutuna bağlı olarak bu örnek için yürütme süresinin grafiğini aşağıda bulabilirsiniz:

Her iki eksenin de logaritmik olduğuna dikkat edin. Bu, üretici ifadesi için en iyi durumu temsil eder. Görüldüğü gibi, isdisjoint()yöntem çok küçük liste boyutları için daha iyidir, oysa oluşturucu ifadesi daha büyük liste boyutları için daha iyidir.

Öte yandan, arama hibrit ve üretici ifadesinin başlangıcıyla başladığından, eğer paylaşılan eleman sistematik olarak dizinin sonunda ise (veya her iki liste de herhangi bir değeri paylaşmıyorsa), ayrık ve küme kesişim yaklaşımları o zaman jeneratör ifadesi ve hibrit yaklaşımdan çok daha hızlı.

>>> timeit('any(i in a for i in b)', setup="a=list(range(1000));b=[x+998 for x in range(999,0,-1)]", number=1000))
13.739536046981812
>>> timeit('bool(set(a) & set(b))', setup="a=list(range(1000));b=[x+998 for x in range(999,0,-1)]", number=1000))
0.08102107048034668

Daha büyük liste boyutları için oluşturucu ifadesinin çok daha yavaş olduğuna dikkat etmek ilginçtir. Bu, önceki rakam için 100000 yerine sadece 1000 tekrar içindir. Bu kurulum aynı zamanda hiçbir öğe paylaşılmadığında iyi bir şekilde yaklaşır ve ayrık ve kesişme yaklaşımları için en iyi durumdur.

İşte rastgele sayılar kullanan iki analiz (bir tekniği veya diğerini tercih etmek için kurulumu karıştırmak yerine):

Yüksek paylaşma şansı: öğelerden rastgele alınır [1, 2*len(a)]. Düşük paylaşım şansı: öğelerden rastgele alınır [1, 1000*len(a)].

Şimdiye kadar, bu analiz her iki listenin de aynı büyüklükte olduğunu varsayıyordu. Farklı boyutlarda iki liste olması durumunda, örneğin açok daha küçükse, isdisjoint()her zaman daha hızlıdır:

aListenin daha küçük olduğundan emin olun , aksi takdirde performans düşer. Bu deneyde, aliste boyutu olarak sabit ayarlandı 5.

Özetle:

• Listeler çok küçükse (<10 öğe), not set(a).isdisjoint(b)her zaman en hızlısıdır.
• Listelerdeki öğeler sıralanırsa veya yararlanabileceğiniz düzenli bir yapıya sahipse, oluşturucu ifadesi any(i in a for i in b)büyük liste boyutlarında en hızlısıdır;
• not set(a).isdisjoint(b)Her zaman daha hızlı olan küme kesişimini test edin bool(set(a) & set(b)).
• Karma "listeden yineleme, sette test etme" a = set(a); any(i in a for i in b)genellikle diğer yöntemlerden daha yavaştır.
• Oluşturucu ifadesi ve melez, öğeleri paylaşmadan listeler söz konusu olduğunda diğer iki yaklaşımdan çok daha yavaştır.

Çoğu durumda, isdisjoint()hiçbir öğe paylaşılmadığında çok verimsiz olduğundan, oluşturucu ifadenin yürütülmesi çok daha uzun süreceği için yöntemi kullanmak en iyi yaklaşımdır.

def lists_overlap3(a, b):
    return bool(set(a) & set(b))

Not: Yukarıdakiler, yanıt olarak bir boole istediğinizi varsayar. İhtiyacınız olan tek şey bir ifadede kullanılacak bir ififadeyse, sadeceif set(a) & set(b):

def lists_overlap(a, b):
  sb = set(b)
  return any(el in sb for el in a)

Bu, asimptotik olarak optimaldir (en kötü durum O (n + m)) ve anykısa devre nedeniyle kavşak yaklaşımından daha iyi olabilir .

Örneğin:

lists_overlap([3,4,5], [1,2,3])

ulaşır ulaşmaz True döndürür 3 in sb

DÜZENLEME: Başka bir varyasyon (Dave Kirby sayesinde):

def lists_overlap(a, b):
  sb = set(b)
  return any(itertools.imap(sb.__contains__, a))

Bu imap, bir üreteç anlayışından çok, C'de uygulanan yineleyicisine dayanır . Ayrıca sb.__contains__eşleme işlevi olarak da kullanır . Bunun ne kadar performans farkı yarattığını bilmiyorum. Yine de kısa devre olacaktır.

anyListe anlama ile de kullanabilirsiniz :

any([item in a for item in b])

Python 2.6 veya sonraki sürümlerde şunları yapabilirsiniz:

return not frozenset(a).isdisjoint(frozenset(b))

Herhangi bir yerleşik işlev / wa oluşturucu ifadesini kullanabilirsiniz:

def list_overlap(a,b): 
     return any(i for i in a if i in b)

John ve Lie'nin belirttiği gibi, bu iki liste tarafından paylaşılan her i için bool (i) == False olduğunda yanlış sonuçlar verir. Olmalı:

return any(i in b for i in a)

Bu soru oldukça eskidir, ancak insanlar kümelere karşı listeleri tartışırken kimsenin onları birlikte kullanmayı düşünmediğini fark ettim. Soravux örneğine göre,

Listeler için en kötü durum:

>>> timeit('bool(set(a) & set(b))',  setup="a=list(range(10000)); b=[x+9999 for x in range(10000)]", number=100000)
100.91506409645081
>>> timeit('any(i in a for i in b)', setup="a=list(range(10000)); b=[x+9999 for x in range(10000)]", number=100000)
19.746716022491455
>>> timeit('any(i in a for i in b)', setup="a= set(range(10000)); b=[x+9999 for x in range(10000)]", number=100000)
0.092626094818115234

Ve listeler için en iyi durum:

>>> timeit('bool(set(a) & set(b))',  setup="a=list(range(10000)); b=list(range(10000))", number=100000)
154.69790101051331
>>> timeit('any(i in a for i in b)', setup="a=list(range(10000)); b=list(range(10000))", number=100000)
0.082653045654296875
>>> timeit('any(i in a for i in b)', setup="a= set(range(10000)); b=list(range(10000))", number=100000)
0.08434605598449707

Bu yüzden, iki listeyi yinelemekten bile daha hızlı, bir listenin bir kümede olup olmadığını görmek için yinelemektir; bu mantıklıdır, çünkü bir sayının bir kümede olup olmadığını kontrol etmek sabit zaman alırken, bir listeyi yineleyerek kontrol etmek, sürenin uzunluğuyla orantılı zaman alır. liste.

Bu nedenle, sonucum bir listeyi yinelemek ve bir küme içinde olup olmadığını kontrol etmek .

Örtüşen öğenin ne olabileceği umurunuzda değilse len, bir küme olarak birleştirilmiş listelerle karşılaştırıldığında birleşik listeyi kontrol edebilirsiniz . Örtüşen öğeler varsa, küme daha kısa olacaktır:

len(set(a+b+c))==len(a+b+c) Örtüşme yoksa True döndürür.

İşlevsel programlama stiline sahip bir tane daha ekleyeceğim:

any(map(lambda x: x in a, b))

Açıklama:

map(lambda x: x in a, b)

elemanları boole listesini döndürür bbulunur a. Bu liste daha sonra any, Trueherhangi bir öğe varsa , basitçe dönen'e aktarılır True.