Самый быстрый способ проверить, существует ли значение в списке

Какой самый быстрый способ узнать, существует ли значение в списке (список с миллионами значений в нем) и каков его индекс?

Я знаю, что все значения в списке уникальны, как в этом примере.

Первый метод, который я пробую, - это (3,8 сек в моем реальном коде):

a = [4,2,3,1,5,6]

if a.count(7) == 1:
    b=a.index(7)
    "Do something with variable b"

Второй метод, который я пытаюсь использовать (в 2 раза быстрее: 1,9 с для моего реального кода):

a = [4,2,3,1,5,6]

try:
    b=a.index(7)
except ValueError:
    "Do nothing"
else:
    "Do something with variable b"

Предлагаемые методы от пользователя Stack Overflow (2,74 с для моего реального кода):

a = [4,2,3,1,5,6]
if 7 in a:
    a.index(7)

В моем реальном коде первый метод занимает 3,81 секунды, а второй - 1,88 секунды. Это хорошее улучшение, но:

Я новичок в Python / scripting, и есть ли более быстрый способ сделать то же самое и сэкономить больше времени на обработку?

Более конкретное объяснение для моего приложения:

В Blender API я могу получить доступ к списку частиц:

particles = [1, 2, 3, 4, etc.]

Оттуда я могу получить доступ к местоположению частицы:

particles[x].location = [x,y,z]

И для каждой частицы я проверяю, существует ли сосед, выполняя поиск каждой локации частицы следующим образом:

if [x+1,y,z] in particles.location
    "Find the identity of this neighbour particle in x:the particle's index
    in the array"
    particles.index([x+1,y,z])

7 in a

Самый простой и быстрый способ сделать это.

Вы также можете рассмотреть возможность использования set, но создание этого набора из вашего списка может занять больше времени, чем сэкономит более быстрое тестирование членства. Единственный способ быть уверенным - это хорошо оценивать. (это также зависит от того, какие операции вам требуются)

Как утверждают другие, inможет быть очень медленным для больших списков. Вот несколько сравнений выступлений для in, setи bisect. Обратите внимание на время (в секундах) в логарифмическом масштабе.

Код для тестирования:

import random
import bisect
import matplotlib.pyplot as plt
import math
import time

def method_in(a,b,c):
    start_time = time.time()
    for i,x in enumerate(a):
        if x in b:
            c[i] = 1
    return(time.time()-start_time)   

def method_set_in(a,b,c):
    start_time = time.time()
    s = set(b)
    for i,x in enumerate(a):
        if x in s:
            c[i] = 1
    return(time.time()-start_time)

def method_bisect(a,b,c):
    start_time = time.time()
    b.sort()
    for i,x in enumerate(a):
        index = bisect.bisect_left(b,x)
        if index < len(a):
            if x == b[index]:
                c[i] = 1
    return(time.time()-start_time)

def profile():
    time_method_in = []
    time_method_set_in = []
    time_method_bisect = []

    Nls = [x for x in range(1000,20000,1000)]
    for N in Nls:
        a = [x for x in range(0,N)]
        random.shuffle(a)
        b = [x for x in range(0,N)]
        random.shuffle(b)
        c = [0 for x in range(0,N)]

        time_method_in.append(math.log(method_in(a,b,c)))
        time_method_set_in.append(math.log(method_set_in(a,b,c)))
        time_method_bisect.append(math.log(method_bisect(a,b,c)))

    plt.plot(Nls,time_method_in,marker='o',color='r',linestyle='-',label='in')
    plt.plot(Nls,time_method_set_in,marker='o',color='b',linestyle='-',label='set')
    plt.plot(Nls,time_method_bisect,marker='o',color='g',linestyle='-',label='bisect')
    plt.xlabel('list size', fontsize=18)
    plt.ylabel('log(time)', fontsize=18)
    plt.legend(loc = 'upper left')
    plt.show()

Вы можете положить свои вещи в set. Набор поисков очень эффективен.

Пытаться:

s = set(a)
if 7 in s:
  # do stuff

edit В комментарии вы говорите, что хотите получить индекс элемента. К сожалению, наборы не имеют понятия положения элемента. Альтернативой является предварительная сортировка списка, а затем использование бинарного поиска каждый раз, когда вам нужно найти элемент.

def check_availability(element, collection: iter):
    return element in collection

Применение

check_availability('a', [1,2,3,4,'a','b','c'])

Я считаю, что это самый быстрый способ узнать, находится ли выбранное значение в массиве.

a = [4,2,3,1,5,6]

index = dict((y,x) for x,y in enumerate(a))
try:
   a_index = index[7]
except KeyError:
   print "Not found"
else:
   print "found"

Это будет хорошей идеей, только если a не изменится, и, таким образом, мы можем выполнить часть dict () один раз, а затем использовать ее повторно. Если что-то изменилось, пожалуйста, предоставьте более подробную информацию о том, что вы делаете.

Первоначальный вопрос был:

Какой самый быстрый способ узнать, существует ли значение в списке (список с миллионами значений в нем) и каков его индекс?

Таким образом, есть две вещи, которые нужно найти:

1. это элемент в списке, и
2. что такое индекс (если в списке).

Для этого я изменил код @xslittlegrass для вычисления индексов во всех случаях и добавил дополнительный метод.

Результаты

Методы:

1. in - в основном, если x в b: вернуть b.index (x)
2. try - try / catch для b.index (x) (пропускает необходимость проверять наличие x в b)
3. set - в основном, если x в set (b): вернуть b.index (x)
4. bisect - сортировка b по индексу, двоичный поиск по x в sorted (b). Обратите внимание на мод от @xslittlegrass, который возвращает индекс в отсортированном b, а не в исходный b)
5. реверс - сформировать словарь обратного просмотра d для b; тогда d [x] дает индекс x.

Результаты показывают, что метод 5 является самым быстрым.

Интересно, что методы try и set эквивалентны по времени.

Тестовый код

import random
import bisect
import matplotlib.pyplot as plt
import math
import timeit
import itertools

def wrapper(func, *args, **kwargs):
    " Use to produced 0 argument function for call it"
    # Reference https://www.pythoncentral.io/time-a-python-function/
    def wrapped():
        return func(*args, **kwargs)
    return wrapped

def method_in(a,b,c):
    for i,x in enumerate(a):
        if x in b:
            c[i] = b.index(x)
        else:
            c[i] = -1
    return c

def method_try(a,b,c):
    for i, x in enumerate(a):
        try:
            c[i] = b.index(x)
        except ValueError:
            c[i] = -1

def method_set_in(a,b,c):
    s = set(b)
    for i,x in enumerate(a):
        if x in s:
            c[i] = b.index(x)
        else:
            c[i] = -1
    return c

def method_bisect(a,b,c):
    " Finds indexes using bisection "

    # Create a sorted b with its index
    bsorted = sorted([(x, i) for i, x in enumerate(b)], key = lambda t: t[0])

    for i,x in enumerate(a):
        index = bisect.bisect_left(bsorted,(x, ))
        c[i] = -1
        if index < len(a):
            if x == bsorted[index][0]:
                c[i] = bsorted[index][1]  # index in the b array

    return c

def method_reverse_lookup(a, b, c):
    reverse_lookup = {x:i for i, x in enumerate(b)}
    for i, x in enumerate(a):
        c[i] = reverse_lookup.get(x, -1)
    return c

def profile():
    Nls = [x for x in range(1000,20000,1000)]
    number_iterations = 10
    methods = [method_in, method_try, method_set_in, method_bisect, method_reverse_lookup]
    time_methods = [[] for _ in range(len(methods))]

    for N in Nls:
        a = [x for x in range(0,N)]
        random.shuffle(a)
        b = [x for x in range(0,N)]
        random.shuffle(b)
        c = [0 for x in range(0,N)]

        for i, func in enumerate(methods):
            wrapped = wrapper(func, a, b, c)
            time_methods[i].append(math.log(timeit.timeit(wrapped, number=number_iterations)))

    markers = itertools.cycle(('o', '+', '.', '>', '2'))
    colors = itertools.cycle(('r', 'b', 'g', 'y', 'c'))
    labels = itertools.cycle(('in', 'try', 'set', 'bisect', 'reverse'))

    for i in range(len(time_methods)):
        plt.plot(Nls,time_methods[i],marker = next(markers),color=next(colors),linestyle='-',label=next(labels))

    plt.xlabel('list size', fontsize=18)
    plt.ylabel('log(time)', fontsize=18)
    plt.legend(loc = 'upper left')
    plt.show()

profile()

Похоже, что ваше приложение может получить преимущество от использования структуры данных Bloom Filter.

Короче говоря, просмотр фильтра Блума может очень быстро сказать вам, если значение ОПРЕДЕЛЕННО НЕ присутствует в наборе. В противном случае вы можете выполнить поиск медленнее, чтобы получить индекс значения, которое МОЖЕТ БЫТЬ в списке. Поэтому, если ваше приложение имеет тенденцию получать результат «не найден» гораздо чаще, чем результат «найден», вы можете ускорить процесс, добавив фильтр Блума.

Для получения более подробной информации Википедия предоставляет хороший обзор того, как работают фильтры Bloom, а веб-поиск «библиотеки фильтров Python Bloom» предоставит как минимум пару полезных реализаций.

Имейте в виду, что inоператор проверяет не только равенства ( ==), но и идентичности ( is),in логика для lists примерно эквивалентна следующему (на самом деле он написан на C, а не на Python, по крайней мере в CPython):

for element in s:
    if element is target:
        # fast check for identity implies equality
        return True
    if element == target:
        # slower check for actual equality
        return True
return False

В большинстве случаев эта деталь не имеет значения, но в некоторых случаях она может удивить новичка в Python, например, numpy.NANнеобычным свойством быть не равным себе :

>>> import numpy
>>> numpy.NAN == numpy.NAN
False
>>> numpy.NAN is numpy.NAN
True
>>> numpy.NAN in [numpy.NAN]
True

Чтобы различать эти необычные случаи, вы можете использовать any()как:

>>> lst = [numpy.NAN, 1 , 2]
>>> any(element == numpy.NAN for element in lst)
False
>>> any(element is numpy.NAN for element in lst)
True 

Обратите внимание in логика для lists с any()будет:

any(element is target or element == target for element in lst)

Тем не менее, я должен подчеркнуть, что это крайний случай, и в подавляющем большинстве случаев inоператор высоко оптимизирован и, разумеется, именно то, что вы хотите (с помощью listилиset ).

Или используйте __contains__:

sequence.__contains__(value)

Демо-версия:

>>> l=[1,2,3]
>>> l.__contains__(3)
True
>>> 

Решение @Winston Ewert дает большое ускорение для очень больших списков, но этот ответ на стекопоток указывает, что конструкция try: / exception: / else: будет замедлена, если часто достигается ветвь exc. Альтернативой является использование .get()метода для диктовки:

a = [4,2,3,1,5,6]

index = dict((y, x) for x, y in enumerate(a))

b = index.get(7, None)
if b is not None:
    "Do something with variable b"

.get(key, default)Метод только для случая , когда вы не можете гарантировать ключ будет в Словаре. Если ключ находится присутствует, она возвращает значение (как было dict[key]), но когда это не так , .get()возвращает ваше значение по умолчанию (здесь None). В этом случае необходимо убедиться, что выбранное значение по умолчанию не будет a.

Это не код, а алгоритм очень быстрого поиска.

Если ваш список и значение, которое вы ищете, все числа, это довольно просто. Если строки: посмотрите внизу:

• -Позвольте "n" быть длиной вашего списка
• -Дополнительный шаг: если вам нужен индекс элемента: добавьте второй список в список с текущим индексом элементов (от 0 до n-1) - см. Позже
• Заказать свой список или его копию (.sort ())
• Переберите:
  • Сравните ваш номер с п / 2-м элементом списка
    • Если больше, повторите цикл между индексами n / 2-n
    • Если меньше, повторите цикл между индексами 0-n / 2
    • Если то же самое: вы нашли это
• Продолжайте сужать список, пока не найдете его или не получите только 2 числа (ниже и выше того, которое вы ищете)
• Это найдет любой элемент не более чем в 19 шагах для списка 1.000.000 (log (2) n, если быть точным)

Если вам также нужна исходная позиция вашего номера, найдите ее во втором столбце индекса.

Если ваш список не состоит из чисел, метод все еще работает и будет самым быстрым, но вам может потребоваться определить функцию, которая может сравнивать / упорядочивать строки.

Конечно, это требует вложений метода sorted (), но если вы продолжаете использовать один и тот же список для проверки, это может стоить того.

Поскольку вопрос не всегда следует понимать как самый быстрый технический способ - я всегда предлагаю самый простой и быстрый способ понять / написать: понимание списка, однострочник

[i for i in list_from_which_to_search if i in list_to_search_in]

У меня был список list_to_search_inвсех элементов, и я хотел вернуть индексы элементов в list_from_which_to_search.

Это возвращает индексы в хорошем списке.

Есть и другие способы проверить эту проблему - однако понимание списка достаточно быстро, добавляя факт написания достаточно быстро, чтобы решить проблему.

Для меня это было 0,030 с (реальное), 0,026 с (пользователь) и 0,004 с (sys).

try:
print("Started")
x = ["a", "b", "c", "d", "e", "f"]

i = 0

while i < len(x):
    i += 1
    if x[i] == "e":
        print("Found")
except IndexError:
    pass

Код для проверки наличия двух элементов в массиве, произведение которых равно k:

n = len(arr1)
for i in arr1:
    if k%i==0:
        print(i)