听起来您的应用程序可能会从使用Bloom Filter数据结构中获得优势。

简而言之，bloom过滤器查找可以非常快速地告诉你一个值是否绝对不存在于一个集合中。否则，您可以执行较慢的查找，以获得可能在列表中的值的索引。因此，如果您的应用程序倾向于获得“未找到”结果，而不是“找到”结果，您可能会通过添加Bloom Filter看到速度的提高。

关于细节，维基百科提供了Bloom过滤器如何工作的很好的概述，在网上搜索“python Bloom过滤器库”将提供至少两个有用的实现。

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()部分，然后重复使用它。如果a确实发生了变化，请提供更多关于您正在做什么的细节。

这不是代码，而是快速搜索的算法。

如果您的列表和您正在寻找的值都是数字，这是相当简单的。如果字符串:看底部:

-Let "n" be the length of your list -Optional step: if you need the index of the element: add a second column to the list with current index of elements (0 to n-1) - see later Order your list or a copy of it (.sort()) Loop through: Compare your number to the n/2th element of the list If larger, loop again between indexes n/2-n If smaller, loop again between indexes 0-n/2 If the same: you found it Keep narrowing the list until you have found it or only have 2 numbers (below and above the one you are looking for) This will find any element in at most 19 steps for a list of 1.000.000 (log(2)n to be precise)

如果您还需要您的数字的原始位置，请在第二索引列中查找。

如果您的列表不是由数字组成的，该方法仍然有效，并且将是最快的，但您可能需要定义一个可以比较/排序字符串的函数。

当然，这需要使用sorted()方法，但如果您不断重用相同的列表进行检查，那么这样做可能是值得的。

你可以把你的物品放在一个集合里。设置查找非常有效。

Try:

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

在注释中，你说你想获取元素的索引。不幸的是，集合没有元素位置的概念。另一种方法是对列表进行预先排序，然后在每次需要查找元素时使用二分搜索。

如果您只想检查列表中是否存在一个元素，

7 in list_data

是最快的解决方案。请注意

7 in set_data

是一个近乎自由的操作，与集合的大小无关!从一个大列表中创建一个set要比在列表中慢300到400倍，所以如果您需要检查许多元素，首先创建一个set会更快。

用perfplot创建的Plot:

import perfplot
import numpy as np


def setup(n):
    data = np.arange(n)
    np.random.shuffle(data)
    return data, set(data)


def list_in(data):
    return 7 in data[0]


def create_set_from_list(data):
    return set(data[0])


def set_in(data):
    return 7 in data[1]


b = perfplot.bench(
    setup=setup,
    kernels=[list_in, set_in, create_set_from_list],
    n_range=[2 ** k for k in range(24)],
    xlabel="len(data)",
    equality_check=None,
)
b.save("out.png")
b.show()

最初的问题是:

知道一个值是否存在于一个列表(一个列表 它有数百万个值)，它的索引是什么?

因此，有两件事需要发现:

是列表中的一项，和 索引是什么(如果在列表中)。

为此，我修改了@xslittlegrass代码来计算所有情况下的索引，并添加了一个额外的方法。

结果

方法是:

基本上，if x In b: return b。index(x) 在b.index(x)上尝试/捕获(跳过必须检查x是否在b中) Set——基本上如果x在Set (b):返回b.index(x) 平分——对b和它的下标排序，对x在排序(b)中进行二分搜索。 注意来自@ xsllittlegrass的mod，它返回排序后的b的下标， 而不是原来的b) 反向——为b形成一个反向查找字典d;然后 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()