>>> mydict = {'one': 1, 'two': 2, 'three': 3}
>>> mykeys = ['three', 'one']
mykeys来获取字典中对应的值并以列表形式返回？>>> mydict.WHAT_GOES_HERE(mykeys)
[3, 1]
列表推导式似乎是实现这个的好方法：
>>> [mydict[x] for x in mykeys]
[3, 1]
除了列表推导式之外，还有几种方法：
map(mydict.__getitem__, mykeys)get方法构建列表并在未找到键时用None填充：map(mydict.get, mykeys)另外，可以使用operator.itemgetter返回一个元组：
from operator import itemgetter
myvalues = itemgetter(*mykeys)(mydict)
# use `list(...)` if list is required
注意：在 Python3 中，map 返回一个迭代器而不是列表。使用 list(map(...)) 转换为列表。
mydict.__getitem__()，而是使用生成器表达式：(mydict[key] for key in mykeys)。或者对于 list(map(...))，使用列表推导式：[mydict[key] for key in mykeys]。 - wjandrea一点速度比较：
Python 2.7.11 |Anaconda 2.4.1 (64-bit)| (default, Dec 7 2015, 14:10:42) [MSC v.1500 64 bit (AMD64)] on win32
In[1]: l = [0,1,2,3,2,3,1,2,0]
In[2]: m = {0:10, 1:11, 2:12, 3:13}
In[3]: %timeit [m[_] for _ in l] # list comprehension
1000000 loops, best of 3: 762 ns per loop
In[4]: %timeit map(lambda _: m[_], l) # using 'map'
1000000 loops, best of 3: 1.66 µs per loop
In[5]: %timeit list(m[_] for _ in l) # a generator expression passed to a list constructor.
1000000 loops, best of 3: 1.65 µs per loop
In[6]: %timeit map(m.__getitem__, l)
The slowest run took 4.01 times longer than the fastest. This could mean that an intermediate result is being cached
1000000 loops, best of 3: 853 ns per loop
In[7]: %timeit map(m.get, l)
1000000 loops, best of 3: 908 ns per loop
In[33]: from operator import itemgetter
In[34]: %timeit list(itemgetter(*l)(m))
The slowest run took 9.26 times longer than the fastest. This could mean that an intermediate result is being cached
1000000 loops, best of 3: 739 ns per loop
所以列表推导式和itemgetter是最快的方法来做到这一点。
对于大型随机列表和映射，我的结果有些不同：
Python 2.7.11 |Anaconda 2.4.1 (64-bit)| (default, Dec 7 2015, 14:10:42) [MSC v.1500 64 bit (AMD64)] on win32
In[2]: import numpy.random as nprnd
l = nprnd.randint(1000, size=10000)
m = dict([(_, nprnd.rand()) for _ in range(1000)])
from operator import itemgetter
import operator
f = operator.itemgetter(*l)
%timeit f(m)
1000 loops, best of 3: 1.14 ms per loop
%timeit list(itemgetter(*l)(m))
1000 loops, best of 3: 1.68 ms per loop
%timeit [m[_] for _ in l] # list comprehension
100 loops, best of 3: 2 ms per loop
%timeit map(m.__getitem__, l)
100 loops, best of 3: 2.05 ms per loop
%timeit list(m[_] for _ in l) # a generator expression passed to a list constructor.
100 loops, best of 3: 2.19 ms per loop
%timeit map(m.get, l)
100 loops, best of 3: 2.53 ms per loop
%timeit map(lambda _: m[_], l)
100 loops, best of 3: 2.9 ms per loop
因此，在这种情况下，明显的优胜者是f = operator.itemgetter(*l); f(m)，而鲜明的局外人是：map(lambda _: m[_], l) 。
import numpy.random as nprnd
l = nprnd.randint(1000, size=10000)
m = dict([(_, nprnd.rand()) for _ in range(1000)])
from operator import itemgetter
import operator
f = operator.itemgetter(*l)
%timeit f(m)
1.66 ms ± 74.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
%timeit list(itemgetter(*l)(m))
2.1 ms ± 93.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit [m[_] for _ in l] # list comprehension
2.58 ms ± 88.8 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit list(map(m.__getitem__, l))
2.36 ms ± 60.7 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit list(m[_] for _ in l) # a generator expression passed to a list constructor.
2.98 ms ± 142 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit list(map(m.get, l))
2.7 ms ± 284 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit list(map(lambda _: m[_], l)
3.14 ms ± 62.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
因此，Python 3.6.4的结果几乎相同。
以下是三种方法。
当未找到键时引发KeyError：
result = [mapping[k] for k in iterable]
缺失键的默认值。
result = [mapping.get(k, default_value) for k in iterable]
跳过缺失的键。
result = [mapping[k] for k in iterable if k in mapping]
found_keys = mapping.keys() & iterable会导致TypeError: unsupported operand type(s) for &: 'list' and 'list'错误。而found_keys = [key for key in mapping.keys() if key in iterable]是更好的选择。 - NotGaeL试一下：
mydict = {'one': 1, 'two': 2, 'three': 3}
mykeys = ['three', 'one','ten']
newList=[mydict[k] for k in mykeys if k in mydict]
print newList
[3, 1]
"if k in mydict"这部分会使其过于宽松——如果列表比字典中的键更广泛，但正确，则会悄悄地失败（比较狭窄，但不正确）。 - mirekphd试试这个：
mydict = {'one': 1, 'two': 2, 'three': 3}
mykeys = ['three', 'one'] # if there are many keys, use a set
[mydict[k] for k in mykeys]
=> [3, 1]
items() 是首选，它不需要进行额外的查找，这里没有 len(mydict)*len(mykeys) 的操作！（请注意我正在使用一个集合） - Óscar Lópezmykeys上的成员操作是摊销常数时间。 - Óscar Lópeznew_dict = {x: v for x, v in mydict.items() if x in mykeys}
new_dict = {x: mydict[x] for x in mykeys if x in mydict} - wjandreaPandas非常优雅地完成了这个任务，虽然列表推导式始终更符合Python的技术规范。我现在没有时间进行速度比较（稍后我会回来并加入）：
import pandas as pd
mydict = {'one': 1, 'two': 2, 'three': 3}
mykeys = ['three', 'one']
temp_df = pd.DataFrame().append(mydict)
# You can export DataFrames to a number of formats, using a list here.
temp_df[mykeys].values[0]
# Returns: array([ 3., 1.])
# If you want a dict then use this instead:
# temp_df[mykeys].to_dict(orient='records')[0]
# Returns: {'one': 1.0, 'three': 3.0}
issubset()方法。mydict = {'one': 1, 'two': 2, 'three': 3}
mykeys = ['three', 'one']
assert set(mykeys).issubset(set(mydict.keys()))
result = [mydict[key] for key in mykeys]
train_data, train_labels, test_data, test_labels = [
d[k] for d in [numpy.load('classify.npz')]
for k in 'train_data train_labels test_data test_labels'.split()]
match numpy.load('classify.npz'):
case {
'train_data': train_data,
'train_labels': train_labels,
'test_data': test_data,
'test_labels': test_labels}: pass
case _: raise KeyError()
mydict是一个函数调用（返回一个字典），那么这会多次调用该函数，对吗？ - endolith