Проверьте, разделяют ли списки какие-либо элементы в 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

РЕДАКТИРОВАТЬ: Еще один вариант (с благодарностью Дэйву Кирби):

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

Это зависит от imapитератора, который реализован на 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)

Как указали Джон и Ли, это дает неверные результаты, когда для каждого i, совместно используемого двумя списками, 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.