从字典中提取键值对的子集?

你可以试试:

dict((k, bigdict[k]) for k in ('l', 'm', 'n'))

．.． 或在Python 3 Python 2.7或更高版本中(感谢Fábio Diniz指出它在2.7中也有效):

{k: bigdict[k] for k in ('l', 'm', 'n')}

更新:正如Håvard S指出的那样，我假设你知道键将在字典中-参见他的答案如果你不能做出这样的假设。或者，正如timbo在评论中指出的那样，如果你想要一个在bigdict中缺失的键映射到None，你可以这样做:

{k: bigdict.get(k, None) for k in ('l', 'm', 'n')}

如果你正在使用python3，并且你只有想要新字典中的键实际上存在于原始字典中，你可以使用fact来查看对象，实现一些set操作:

{k: bigdict[k] for k in bigdict.keys() & {'l', 'm', 'n'}}

至少要短一点:

wanted_keys = ['l', 'm', 'n'] # The keys you want
dict((k, bigdict[k]) for k in wanted_keys if k in bigdict)

可能:

subdict=dict([(x,bigdict[x]) for x in ['l', 'm', 'n']])

Python 3甚至支持以下内容:

subdict={a:bigdict[a] for a in ['l','m','n']}

注意你可以在字典中检查是否存在，如下所示:

subdict=dict([(x,bigdict[x]) for x in ['l', 'm', 'n'] if x in bigdict])

分别地。对于python 3

subdict={a:bigdict[a] for a in ['l','m','n'] if a in bigdict}

interesting_keys = ('l', 'm', 'n')
subdict = {x: bigdict[x] for x in interesting_keys if x in bigdict}

还有一个问题(我更喜欢Mark Longair的答案)

di = {'a':1,'b':2,'c':3}
req = ['a','c','w']
dict([i for i in di.iteritems() if i[0] in di and i[0] in req])

你也可以使用map(这是一个非常有用的非常函数):

sd = dict(map(lambda k: (k, l.get(k, None)), l))

例子:

large_dictionary = {'a1':123, 'a2':45, 'a3':344}
list_of_keys = ['a1', 'a3']
small_dictionary = dict(map(lambda key: (key, large_dictionary.get(key, None)), list_of_keys))

PS:我从以前的答案中借用了.get(key, None):)

好吧，这个问题已经困扰过我几次了，谢谢你的提问。

上面的答案似乎是一个很好的解决方案，但如果你在你的代码中使用它，我认为包装功能是有意义的。此外，这里有两个可能的用例:一个是关心是否所有关键字都在原始字典中。还有一个你不知道的地方。如果能对两者一视同仁就好了。

所以，为了我的二分之一的价值，我建议写一个字典的子类，例如。

class my_dict(dict):
def subdict(self, keywords, fragile=False):
d = {}
for k in keywords:
try:
d[k] = self[k]
except KeyError:
if fragile:
raise
return d

现在你可以用

orig_dict.subdict(keywords)

使用例子:

#
## our keywords are letters of the alphabet
keywords = 'abcdefghijklmnopqrstuvwxyz'
#
## our dictionary maps letters to their index
d = my_dict([(k,i) for i,k in enumerate(keywords)])
print('Original dictionary:\n%r\n\n' % (d,))
#
## constructing a sub-dictionary with good keywords
oddkeywords = keywords[::2]
subd = d.subdict(oddkeywords)
print('Dictionary from odd numbered keys:\n%r\n\n' % (subd,))
#
## constructing a sub-dictionary with mixture of good and bad keywords
somebadkeywords = keywords[1::2] + 'A'
try:
subd2 = d.subdict(somebadkeywords)
print("We shouldn't see this message")
except KeyError:
print("subd2 construction fails:")
print("\toriginal dictionary doesn't contain some keys\n\n")
#
## Trying again with fragile set to false
try:
subd3 = d.subdict(somebadkeywords, fragile=False)
print('Dictionary constructed using some bad keys:\n%r\n\n' % (subd3,))
except KeyError:
print("We shouldn't see this message")

如果你运行上面所有的代码，你应该会看到(类似于)下面的输出(抱歉格式化):

< p >原始字典:< br > {a: 0, ' c ': 2,“b”:1、“e”:4,' d ': 3,“g”:6“f”:5 “我”:8“h”:7,“k”:10“j”:9,“m”:12,“l”:11日,“o”:14日 “问”:“n”:13日,16日,“p”:15日“s”:18,“r”:17日“u”:20, “w”:“t”:19日,22日,“v”:21日“y”:24日,“x”:23日,“z”:25}< / p >

奇数键的字典:
{a: 0, ' c ': 2,“e”:4,“g”:6中,“我”:8“k”:10“m”:12,“o”:14日“问”:16日,“s”:18,“u”:20,“w”:22日“y”:24}< / p >

subd2构造失败:
原来的字典不包含一些键

使用坏键构造的字典 {“b”:1、“d”:3,“f”:5,“h”:7,“j”:9,“l”:11日,“n”:13日,“p”:15日“r”:17日“t”:19日,“v”:21岁的“x”:23日,“z”:25}< / p >

此答案使用与所选答案类似的字典推导，但不会对缺失项进行省略。

Python 2版本:

{k:v for k, v in bigDict.iteritems() if k in ('l', 'm', 'n')}

Python 3版本:

{k:v for k, v in bigDict.items() if k in ('l', 'm', 'n')}

比较一下所有提到的方法的速度:

UPDATED on 2020.07.13(谢谢@user3780389):

 IPython 5.5.0 -- An enhanced Interactive Python.
Python 2.7.18 (default, Aug  8 2019, 00:00:00)
[GCC 7.3.1 20180303 (Red Hat 7.3.1-5)] on linux2
import numpy.random as nprnd
...: keys = nprnd.randint(100000, size=10000)
...: bigdict = dict([(_, nprnd.rand()) for _ in range(100000)])
...:
...: %timeit {key:bigdict[key] for key in keys}
...: %timeit dict((key, bigdict[key]) for key in keys)
...: %timeit dict(map(lambda k: (k, bigdict[k]), keys))
...: %timeit {key:bigdict[key] for key in set(keys) & set(bigdict.keys())}
...: %timeit dict(filter(lambda i:i[0] in keys, bigdict.items()))
...: %timeit {key:value for key, value in bigdict.items() if key in keys}
100 loops, best of 3: 2.36 ms per loop
100 loops, best of 3: 2.87 ms per loop
100 loops, best of 3: 3.65 ms per loop
100 loops, best of 3: 7.14 ms per loop
1 loop, best of 3: 577 ms per loop
1 loop, best of 3: 563 ms per loop

正如预期的那样:字典推导式是最好的选择。

解决方案

from operator import itemgetter
from typing import List, Dict, Union




def subdict(d: Union[Dict, List], columns: List[str]) -> Union[Dict, List[Dict]]:
"""Return a dict or list of dicts with subset of
columns from the d argument.
"""
getter = itemgetter(*columns)


if isinstance(d, list):
result = []
for subset in map(getter, d):
record = dict(zip(columns, subset))
result.append(record)
return result
elif isinstance(d, dict):
return dict(zip(columns, getter(d)))


raise ValueError('Unsupported type for `d`')

使用实例

# pure dict


d = dict(a=1, b=2, c=3)
print(subdict(d, ['a', 'c']))


>>> In [5]: {'a': 1, 'c': 3}

# list of dicts


d = [
dict(a=1, b=2, c=3),
dict(a=2, b=4, c=6),
dict(a=4, b=8, c=12),
]


print(subdict(d, ['a', 'c']))


>>> In [5]: [{'a': 1, 'c': 3}, {'a': 2, 'c': 6}, {'a': 4, 'c': 12}]

使用地图(halfdanrump的答案)对我来说是最好的，尽管还没有计时……

但是如果你使用一个字典，如果你有一个big_dict:

1. 一定要确保你遍历了要求。这是至关重要的，并且会影响算法的运行时间(大O, theta，你能想到的)
2. 把它写得足够通用，以避免在没有键的情况下出现错误。

例如:

big_dict = {'a':1,'b':2,'c':3,................................................}
req = ['a','c','w']


{k:big_dict.get(k,None) for k in req )
# or
{k:big_dict[k] for k in req if k in big_dict)

请注意，在相反的情况下，req很大，但my_dict很小，您应该通过my_dict进行循环。

dict = {'a':1,'b':2,'c':3,................................................}
req = ['a','c','w',...................]


{k:dic[k] for k in set(req).intersection(dict.keys())}

它将关键操作移到python的c代码中，并适用于所有情况。

以防有人想要字典的前几项n而不知道键:

n = 5 # First Five Items
ks = [*dikt.keys()][:n]
less_dikt = {i: dikt[i] for i in ks}

如果你想保留大部分键，同时删除一些键，另一种方法是:

{k: bigdict[k] for k in bigdict.keys() if k not in ['l', 'm', 'n']}

py3.8+中另一种避免None值用于big_dict中缺少键的方法使用walrus:

small_dict = {key: val for key in ('l', 'm', 'n') if (val := big_dict.get(key))}