从带有键列表的 Python 字典中收集值

Question

Dict = {'w1': 56, 'w2': 19, 'w3': 77, 'w4': 45, 'w5': 31}
myWords = ['w1','w4','w5']

OutputList=[]
for items in myWords:
    tmps = Dict[items]
    OutputList.append(tmps)

我的问题是，我们能否不使用 for 循环，从具有特定列表（“myWord”）的字典中收集值（输出）？

Answer 1

或者使用map，如果myWords包含字典Dict的键，使用

OutputList = map(Dict.get, myWords)

Answer 2

您可以使用列表推导：

OutputList = [Dict[x] for x in myWords]

Answer 3

这就是operator.itemgetter 的用途：

>>> import operator
>>> Dict = {'w1': 56, 'w2': 19, 'w3': 77, 'w4': 45, 'w5': 31}
>>> myWords = ['w1','w4','w5']
>>> operator.itemgetter(*myWords)(Dict)
(56, 45, 31)

Answer 4

以下是几种不同方法的基准：

from __future__ import print_function
import timeit
from operator import itemgetter

def f1(d, l):
    '''map'''
    return list(map(d.get, l))

def f2(d, l):
    '''itemgetter'''
    return itemgetter(*l)(d)

def f3(d, l):
    '''list comprehension'''
    return [d[k] for k in l]

def f4(d, l):
    '''WRONG, but map and filter'''
    return list(map(lambda k: d[k], filter(d.get, l)))

def f5(d, l):
    '''simple for loop'''
    rtr=[]
    for e in l:
        rtr.append(d[e])
    return rtr  

def f6(d, l):
    '''CORRECTED map, filter '''    
    return list(map(lambda k: d[k], filter(d.__contains__, l))) 

if __name__ == '__main__':
    s=10000000
    d={'W{}'.format(k):k for k in range(s)} 
    l=['W{}'.format(x) for x in range(0,s,4)]

    times=[]                
    for f in (f1,f2,f3,f4,f5,f6):
        times.append((f.__doc__, timeit.timeit('f(d,l)', setup="from __main__ import f, d, l", number=10)))

    for e in sorted(times, key=itemgetter(1)):
         print('{:30}{:10.3f} seconds'.format(*e))

对于 Python 2.7，打印：

itemgetter                         4.109 seconds
list comprehension                 4.467 seconds
map                                5.450 seconds
simple for loop                    6.132 seconds
CORRECTED map, filter             11.283 seconds
WRONG, but map and filter         11.852 seconds

Python 3.4：

itemgetter                         5.196 seconds
list comprehension                 5.224 seconds
map                                5.923 seconds
simple for loop                    6.548 seconds
WRONG, but map and filter          9.080 seconds
CORRECTED map, filter              9.931 seconds

PyPy：

list comprehension                 4.450 seconds
map                                4.718 seconds
simple for loop                    5.962 seconds
itemgetter                         7.952 seconds
WRONG, but map and filter          8.962 seconds
CORRECTED map, filter              9.909 seconds

您可以看到，即使使用与 OP 所述大小相似的字典（1,000,000 个元素），简单的“for”循环也可以与更高级的方法竞争。列表理解是非常有竞争力的。

您还可以看到看起来花哨的东西并不是那么好。

过早的优化是万恶之源

Answer 5

l = ['a', 'b', 'c'] 
d = { 'a': 1, 'b': 2}
result = map(lambda x: d[x], filter(d.get, l))
print result #[1, 2]