Перевірте, чи спільні спільно використовувані елементи в python

Я хочу перевірити, чи є в одному списку будь-який елемент одного списку. Я можу це зробити просто за допомогою наведеного нижче коду, але я підозрюю, що для цього може бути функція бібліотеки. Якщо ні, чи існує більш пітонічний метод досягнення того ж результату.

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
   ....: 

Коротка відповідь : використовуйте not set(a).isdisjoint(b), як правило, це найшвидше.

Існує чотири загальні способи перевірити, чи є два списки aта bділитися якими-небудь предметами. Перший варіант - перетворити обидва набори і перевірити їх перетин, як такий:

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

Оскільки набори зберігаються за допомогою хеш-таблиці в Python, їх пошукO(1) (див. Тут для отримання додаткової інформації про складність операторів в Python). Теоретично це O(n+m)в середньому для nта mоб'єктів у списках aта b. Але 1) спочатку він повинен створити набори зі списків, які можуть зайняти незначну кількість часу, і 2) він припускає, що хеш-колізії є рідкими серед ваших даних.

Другий спосіб зробити це - використання вираження генератора, що виконує ітерацію у списках, таких як:

any(i in a for i in b)

Це дозволяє здійснювати пошук на місці, тому для посередницьких змінних не виділяється нова пам'ять. Це також підпадає під першу знахідку. Але inоператор завжди O(n)в списках (див. Тут ).

Іншим запропонованим варіантом є гібридто ітерація через один зі списку, перетворення іншого в набір і тест на приналежність до цього набору, наприклад:

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

Четвертий підхід полягає у використанні isdisjoint()методу (заморожених) наборів (див. Тут ), наприклад:

not set(a).isdisjoint(b)

Якщо елементи, які ви шукаєте, знаходяться біля початку масиву (наприклад, він відсортований), вираз генератора надається перевагу, оскільки метод перетину наборів повинен виділяти нову пам'ять для посередницьких змінних:

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

Ось графік часу виконання цього прикладу у функції розміру списку:

Зауважте, що обидві осі є логарифмічними. Це є найкращим випадком для вираження генератора. Як видно, isdisjoint()метод кращий для дуже малих розмірів списку, тоді як вираз генератора краще для більших розмірів списку.

З іншого боку, оскільки пошук починається з початку для гібридного і генераторного вираження, якщо спільний елемент систематично знаходиться в кінці масиву (або обидва списки не поділяють жодних значень), тоді роз'єднані та встановлені переходи перетину тоді Швидше, ніж генераторне вираження та гібридний підхід.

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

Цікаво зазначити, що експресія генератора набагато повільніше для більших розмірів списку. Це лише для 1000 повторень, а не 100000 для попередньої цифри. Ця настройка також добре наближається, коли жодних елементів не поділяється, і є найкращим випадком для роз'єднаних та встановлених підходів до перетину.

Ось два аналізи з використанням випадкових чисел (замість того, щоб сфальсифікувати налаштування на користь тієї чи іншої техніки):

Висока ймовірність спільного використання: елементи беруться випадковим чином [1, 2*len(a)]. Низький шанс поділитися: елементи беруться випадковим чином [1, 1000*len(a)].

До цього часу цей аналіз передбачає, що обидва списки однакового розміру. Якщо два списки різного розміру, наприклад a, значно менші, isdisjoint()завжди швидше:

Переконайтеся, що aсписок менший, інакше продуктивність знижується. У цьому експерименті aрозмір списку було встановлено постійним 5.

Підсумовуючи:

• Якщо списки дуже малі (<10 елементів), not set(a).isdisjoint(b)це завжди найшвидше.
• Якщо елементи в списках відсортовані або мають регулярну структуру, якою ви можете скористатися, вираз генератора any(i in a for i in b)є найшвидшим на великих розмірах списку;
• Перевірте встановлене перехрестя not set(a).isdisjoint(b), яке завжди швидше, ніж bool(set(a) & set(b)).
• Гібрид "повторення через список, тест на набір", a = set(a); any(i in a for i in b)як правило, повільніше, ніж інші методи.
• Експресія генератора та гібрид набагато повільніше, ніж два інші підходи, коли мова йде про списки без спільного використання елементів.

У більшості випадків використання isdisjoint()методу є найкращим підходом, оскільки експресія генератора займе набагато більше часу, оскільки це дуже неефективно, коли жодні елементи не поділяються.

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

Примітка: вищевикладене передбачає, що ви хочете отримати відповідь як булева. Якщо все, що вам потрібно, це вираз, який потрібно використовувати у ifвиписці, просто використовуйтеif set(a) & set(b):

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

Це асимптотично оптимально (найгірший випадок O (n + m)) і може бути кращим, ніж підхід перехрестя через anyкоротке замикання.

Наприклад:

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

поверне True, як тільки він потрапить 3 in sb

EDIT: Ще одна варіація (завдяки Дэйву Кірбі):

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

Це спирається на imapітератор 's, який реалізується на C, а не на розуміння генератора. Він також використовується sb.__contains__як функція відображення. Я не знаю, наскільки це залежить від продуктивності. Все одно буде коротке замикання.

Ви також можете використовувати anyз розумінням списку:

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

У python 2.6 або новіших версіях ви можете:

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

Ви можете використовувати будь-який вбудований вираз функції / генератора wa:

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

Як зазначають Джон і Лі, це дає невірні результати, коли для кожного я, поділеного двома списками, bool (i) == False. Вона повинна бути:

return any(i in b for i in a)

Це питання досить старе, але я помітив, що, коли люди сперечалися набори проти списків, ніхто не думав використовувати їх разом. Наслідуючи приклад Сораву,

Найгірший випадок для списків:

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

І найкращий випадок для списків:

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

Тож навіть швидше, ніж повторення через два списки, це повторення, хоча список переглядає, чи є він у наборі, що має сенс, оскільки перевірка наявності чисельності в наборі займає постійний час, а перевірка шляхом повторення списку займає час, пропорційний тривалості список.

Таким чином, мій висновок полягає в тому, що повторіть список і перевірте, чи є він у наборі .

якщо вам все одно, яким може бути елемент, що перекривається, ви можете просто перевірити lenкомбінований список проти списків, об'єднаних у вигляді набору. Якщо є елементи, що перекриваються, набір буде коротшим:

len(set(a+b+c))==len(a+b+c) повертає True, якщо немає перекриття.

Я піду ще один із функціональним стилем програмування:

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

Пояснення:

map(lambda x: x in a, b)

повертає список булевих , де елементи bзнаходяться в a. Потім цей список передається до any, який просто повертається, Trueякщо є якісь елементи True.