选择:

>>> map(a.__getitem__, b)
[1, 5, 5]

>>> import operator
>>> operator.itemgetter(*b)(a)
(1, 5, 5)

你可以使用operator.itemgetter:

from operator import itemgetter
a = [-2, 1, 5, 3, 8, 5, 6]
b = [1, 2, 5]
print(itemgetter(*b)(a))
# Result:
(1, 5, 5)

或者你可以使用numpy:

import numpy as np
a = np.array([-2, 1, 5, 3, 8, 5, 6])
b = [1, 2, 5]
print(list(a[b]))
# Result:
[1, 5, 5]

但说真的，你现在的解决方案很好。这可能是其中最简洁的一个。

我的回答没有使用numpy或python集合。

查找元素的一种简单方法如下:

a = [-2, 1, 5, 3, 8, 5, 6]
b = [1, 2, 5]
c = [i for i in a if i in b]

缺点:此方法可能不适用于较大的列表。对于较大的列表，建议使用numpy。

基本的和不太广泛的测试，比较五个答案的执行时间:

def numpyIndexValues(a, b):
na = np.array(a)
nb = np.array(b)
out = list(na[nb])
return out


def mapIndexValues(a, b):
out = map(a.__getitem__, b)
return list(out)


def getIndexValues(a, b):
out = operator.itemgetter(*b)(a)
return out


def pythonLoopOverlap(a, b):
c = [ a[i] for i in b]
return c


multipleListItemValues = lambda searchList, ind: [searchList[i] for i in ind]

使用以下输入:

a = range(0, 10000000)
b = range(500, 500000)

简单的python循环是最快的，lambda操作紧随其后，mapIndexValues和getIndexValues始终非常相似，numpy方法在将列表转换为numpy数组后明显更慢。如果数据已经在numpy数组中，则使用numpy. numpyIndexValues方法。删除数组转换是最快的。

numpyIndexValues -> time:1.38940598 (when converted the lists to numpy arrays)
numpyIndexValues -> time:0.0193445 (using numpy array instead of python list as input, and conversion code removed)
mapIndexValues -> time:0.06477512099999999
getIndexValues -> time:0.06391049500000001
multipleListItemValues -> time:0.043773591
pythonLoopOverlap -> time:0.043021754999999995

我相信这已经被考虑过了:如果b中的指标数量很小并且是常数，我们可以这样写结果:

c = [a[b[0]]] + [a[b[1]]] + [a[b[2]]]

或者更简单，如果索引本身是常量……

c = [a[1]] + [a[2]] + [a[5]]

或者如果有一个连续的索引范围…

c = a[1:3] + [a[5]]

另一个解决方案是通过熊猫系列:

import pandas as pd


a = pd.Series([-2, 1, 5, 3, 8, 5, 6])
b = [1, 2, 5]
c = a[b]

如果你想，你可以把c转换回一个列表:

c = list(c)

静态索引和小列表?

不要忘记，如果列表很小，并且索引没有改变，就像你的例子中那样，有时最好的方法是使用序列拆封:

_,a1,a2,_,_,a3,_ = a

性能大大提高，你还可以节省一行代码:

 %timeit _,a1,b1,_,_,c1,_ = a
10000000 loops, best of 3: 154 ns per loop
%timeit itemgetter(*b)(a)
1000000 loops, best of 3: 753 ns per loop
%timeit [ a[i] for i in b]
1000000 loops, best of 3: 777 ns per loop
%timeit map(a.__getitem__, b)
1000000 loops, best of 3: 1.42 µs per loop

这里有一个更简单的方法:

a = [-2,1,5,3,8,5,6]
b = [1,2,5]
c = [e for i, e in enumerate(a) if i in b]

有点像python的方式:

c = [x for x in a if a.index(x) in b]

列表理解显然是最直接和最容易记住的——除了相当python化!

在任何情况下，在提出的解决方案中，它不是最快的(我已经在Windows上使用Python 3.8.3运行了我的测试):

import timeit
from itertools import compress
import random
from operator import itemgetter
import pandas as pd


__N_TESTS__ = 10_000


vector = [str(x) for x in range(100)]
filter_indeces = sorted(random.sample(range(100), 10))
filter_boolean = random.choices([True, False], k=100)


# Different ways for selecting elements given indeces


# list comprehension
def f1(v, f):
return [v[i] for i in filter_indeces]


# itemgetter
def f2(v, f):
return itemgetter(*f)(v)


# using pandas.Series
# this is immensely slow
def f3(v, f):
return list(pd.Series(v)[f])


# using map and __getitem__
def f4(v, f):
return list(map(v.__getitem__, f))


# using enumerate!
def f5(v, f):
return [x for i, x in enumerate(v) if i in f]


# using numpy array
def f6(v, f):
return list(np.array(v)[f])


print("{:30s}:{:f} secs".format("List comprehension", timeit.timeit(lambda:f1(vector, filter_indeces), number=__N_TESTS__)))
print("{:30s}:{:f} secs".format("Operator.itemgetter", timeit.timeit(lambda:f2(vector, filter_indeces), number=__N_TESTS__)))
print("{:30s}:{:f} secs".format("Using Pandas series", timeit.timeit(lambda:f3(vector, filter_indeces), number=__N_TESTS__)))
print("{:30s}:{:f} secs".format("Using map and __getitem__", timeit.timeit(lambda: f4(vector, filter_indeces), number=__N_TESTS__)))
print("{:30s}:{:f} secs".format("Enumeration (Why anyway?)", timeit.timeit(lambda: f5(vector, filter_indeces), number=__N_TESTS__)))

我的结果是:

列表理解:0.007113秒
操作符。Itemgetter:0.003247 secs
使用Pandas系列:2.977286秒
使用map和getitem:0.005029秒
枚举(为什么?):0.135156秒
Numpy:0.157018 secs

截至2022年6月的最新pandas==1.4.2的结果如下。

注意，简单的切片不再可能，基准测试结果更快。

import timeit
import pandas as pd
print(pd.__version__)
# 1.4.2


pd.Series([-2, 1, 5, 3, 8, 5, 6])[1, 2, 5]
# KeyError: 'key of type tuple not found and not a MultiIndex'


pd.Series([-2, 1, 5, 3, 8, 5, 6]).iloc[[1, 2, 5]].tolist()
# [1, 5, 5]


def extract_multiple_elements():
return pd.Series([-2, 1, 5, 3, 8, 5, 6]).iloc[[1, 2, 5]].tolist()


__N_TESTS__ = 10_000
t1 = timeit.timeit(extract_multiple_elements, number=__N_TESTS__)
print(round(t1, 3), 'seconds')
# 1.035 seconds