下面是python 2.6中的一个例子:

>>> a = {1:1, 2:2, 3:3}
>>> dict((key,value) for key, value in a.iteritems() if key == 1)
{1: 1}

过滤部分是if语句。

如果你只想选择很多键中的几个，这个方法比delnan的答案要慢。

构造一个新词典:

dict_you_want = {key: old_dict[key] for key in your_keys}

使用字典理解。

如果你使用的版本缺少它们(如Python 2.6及更早版本)，请将其改为dict((key, old_dict[key]) for…)。它是一样的，只是更丑。

注意，与jnnnnn版本不同的是，对于任何大小的old_dicts具有稳定的性能(仅取决于your_keys的数量)。无论是速度还是内存。因为这是一个生成器表达式，所以它一次处理一个项，并且不会查看old_dict的所有项。

把所有东西都移走:

unwanted = set(keys) - set(your_dict)
for unwanted_key in unwanted: del your_dict[unwanted_key]

给定你的原始字典orig和你感兴趣的键的条目集:

filtered = dict(zip(keys, [orig[k] for k in keys]))

这并不像delnan的答案那么好，但应该适用于每个感兴趣的Python版本。然而，它对原始字典中存在的每个键元素都是脆弱的。

根据德尔南的回答。

如果你想要的钥匙不在旧字典里怎么办?delnan解决方案将抛出一个您可以捕获的KeyError异常。如果这不是你需要的，也许你想:

只包含同时存在于old_dict和你的wanted_keys集合中的键。 old_dict = {'name':"Foobar"， 'baz':42} Wanted_keys = ['name'， 'age'] New_dict = {k: old_dict[k] for k in set(wanted_keys) & set(old_dict.keys())} > > > new_dict {“名称”:“Foobar”} 对于old_dict中未设置的键具有默认值。 default =无 New_dict = {k: old_dict[k]如果k在old_dict否则默认k在wanted_keys} > > > new_dict {'age': None， 'name': 'Foobar'}

这个函数可以做到:

def include_keys(dictionary, keys):
    """Filters a dict by only including certain keys."""
    key_set = set(keys) & set(dictionary.keys())
    return {key: dictionary[key] for key in key_set}

就像delnan的版本一样，这个版本使用字典理解，并且对于大型字典具有稳定的性能(仅取决于您允许的键数，而不是字典中的键总数)。

就像MyGGan的版本一样，这个版本允许您的键列表包含字典中可能不存在的键。

作为奖励，这里是反向的，在这里你可以通过排除原始的某些键来创建字典:

def exclude_keys(dictionary, keys):
    """Filters a dict by excluding certain keys."""
    key_set = set(dictionary.keys()) - set(keys)
    return {key: dictionary[key] for key in key_set}

注意，与delnan版本不同的是，该操作不是在适当的位置完成的，因此性能与字典中的键数有关。但是，这样做的好处是该函数不会修改所提供的字典。

编辑:添加了一个单独的功能，用于从字典中排除某些键。

这一行lambda应该工作:

dictfilt = lambda x, y: dict([ (i,x[i]) for i in x if i in set(y) ])

这里有一个例子:

my_dict = {"a":1,"b":2,"c":3,"d":4}
wanted_keys = ("c","d")

# run it
In [10]: dictfilt(my_dict, wanted_keys)
Out[10]: {'c': 3, 'd': 4}

它是一个基本的列表推导式，遍历你的dict键(i in x)，如果键位于你想要的键列表(y)中，则输出一个元组(键，值)对列表。dict()将整个内容包装成dict对象输出。

略为优雅的词典理解:

foodict = {k: v for k, v in mydict.items() if k.startswith('foo')}

你可以用我的函数库中的项目函数来做:

from funcy import project
small_dict = project(big_dict, keys)

还要看一下select_keys。

代码1:

dict = { key: key * 10 for key in range(0, 100) }
d1 = {}
for key, value in dict.items():
    if key % 2 == 0:
        d1[key] = value

代码2:

dict = { key: key * 10 for key in range(0, 100) }
d2 = {key: value for key, value in dict.items() if key % 2 == 0}

代码3:

dict = { key: key * 10 for key in range(0, 100) }
d3 = { key: dict[key] for key in dict.keys() if key % 2 == 0}

所有代码段的性能都用timeit度量，使用number=1000，并为每段代码收集1000次。

对于python 3.6，三种过滤字典键的方式的性能几乎相同。对于python 2.7，代码3略快一些。

简式:

[s.pop(k) for k in list(s.keys()) if k not in keep]

正如大多数答案所建议的那样，为了保持简洁，我们必须创建一个重复的对象，无论是list还是dict。这个函数创建了一个丢弃列表，但删除了原始字典中的键。

另一个选择:

content = dict(k1='foo', k2='nope', k3='bar')
selection = ['k1', 'k3']
filtered = filter(lambda i: i[0] in selection, content.items())

但你得到的是一个列表(Python 2)或一个迭代器(Python 3)，由filter()返回，而不是字典。

如果我们想要创建一个删除选定键的新字典，我们可以使用字典理解 例如:

d = {
'a' : 1,
'b' : 2,
'c' : 3
}
x = {key:d[key] for key in d.keys() - {'c', 'e'}} # Python 3
y = {key:d[key] for key in set(d.keys()) - {'c', 'e'}} # Python 2.*
# x is {'a': 1, 'b': 2}
# y is {'a': 1, 'b': 2}

下面是在一行中使用del的另一个简单方法:

for key in e_keys: del your_dict[key]

E_keys是要排除的键的列表。它会更新你的字典，而不是给你一个新的。

如果你想要一个新的输出字典，那么在删除之前做一个字典的副本:

new_dict = your_dict.copy()           #Making copy of dict

for key in e_keys: del new_dict[key]

你可以使用python-benedict，它是dict的子类。

安装:pip install python-benedict

from benedict import benedict

dict_you_want = benedict(your_dict).subset(keys=['firstname', 'lastname', 'email'])

它在GitHub上开源:https://github.com/fabiocaccamo/python-benedict

声明:我是这个库的作者。

我们可以这样简单地处理函数:

>>> dict_filter = lambda x, y: dict([ (i,x[i]) for i in x if i in set(y) ])
>>> large_dict = {"a":1,"b":2,"c":3,"d":4}
>>> new_dict_keys = ("c","d")
>>> small_dict=dict_filter(large_dict, new_dict_keys)
>>> print(small_dict)
{'c': 3, 'd': 4}
>>> 

在我看来，这是最简单的方法:

d1 = {'a':1, 'b':2, 'c':3}
d2 = {k:v for k,v in d1.items() if k in ['a','c']}

我也喜欢这样做来揭示价值观:

a, c = {k:v for k,v in d1.items() if k in ['a','c']}.values()

这是我的方法，支持嵌套字段，如mongo查询。

使用方法:

>>> obj = { "a":1, "b":{"c":2,"d":3}}
>>> only(obj,["a","b.c"])
{'a': 1, 'b': {'c': 2}}

只有函数:

def only(object,keys):
    obj = {}
    for path in keys:
        paths = path.split(".")
        rec=''
        origin = object
        target = obj
        for key in paths:
            rec += key
            if key in target:
                target = target[key]
                origin = origin[key]
                rec += '.'
                continue
            if key in origin:
                if rec == path:
                    target[key] = origin[key]
                else:
                    target[key] = {}
                target = target[key]
                origin = origin[key]
                rec += '.'
            else:
                target[key] = None
                break
    return obj

我们也可以通过稍微更优雅的字典理解来实现这一点:

my_dict = {"a":1,"b":2,"c":3,"d":4}

filtdict = {k: v for k, v in my_dict.items() if k.startswith('a')}
print(filtdict)

根据问题的标题，人们会期望在适当的地方过滤字典-几个答案建议了这样做的方法-仍然不明显的一个明显的方法是什么-我添加了一些时间:

import random
import timeit
import collections

repeat = 3
numbers = 10000

setup = ''
def timer(statement, msg='', _setup=None):
    print(msg, min(
        timeit.Timer(statement, setup=_setup or setup).repeat(
            repeat, numbers)))

timer('pass', 'Empty statement')

dsize = 1000
d = dict.fromkeys(range(dsize))
keep_keys = set(random.sample(range(dsize), 500))
drop_keys = set(random.sample(range(dsize), 500))

def _time_filter_dict():
    """filter a dict"""
    global setup
    setup = r"""from __main__ import dsize, collections, drop_keys, \
keep_keys, random"""
    timer('d = dict.fromkeys(range(dsize));'
          'collections.deque((d.pop(k) for k in drop_keys), maxlen=0)',
          "pop inplace - exhaust iterator")
    timer('d = dict.fromkeys(range(dsize));'
          'drop_keys = [k for k in d if k not in keep_keys];'
          'collections.deque('
              '(d.pop(k) for k in list(d) if k not in keep_keys), maxlen=0)',
          "pop inplace - exhaust iterator (drop_keys)")
    timer('d = dict.fromkeys(range(dsize));'
          'list(d.pop(k) for k in drop_keys)',
          "pop inplace - create list")
    timer('d = dict.fromkeys(range(dsize));'
          'drop_keys = [k for k in d if k not in keep_keys];'
          'list(d.pop(k) for k in drop_keys)',
          "pop inplace - create list (drop_keys)")
    timer('d = dict.fromkeys(range(dsize))\n'
          'for k in drop_keys: del d[k]', "del inplace")
    timer('d = dict.fromkeys(range(dsize));'
          'drop_keys = [k for k in d if k not in keep_keys]\n'
          'for k in drop_keys: del d[k]', "del inplace (drop_keys)")
    timer("""d = dict.fromkeys(range(dsize))
{k:v for k,v in d.items() if k in keep_keys}""", "copy dict comprehension")
    timer("""keep_keys=random.sample(range(dsize), 5)
d = dict.fromkeys(range(dsize))
{k:v for k,v in d.items() if k in keep_keys}""",
          "copy dict comprehension - small keep_keys")

if __name__ == '__main__':
    _time_filter_dict()

结果:

Empty statement 8.375600000000427e-05
pop inplace - exhaust iterator 1.046749841
pop inplace - exhaust iterator (drop_keys) 1.830537424
pop inplace - create list 1.1531293939999987
pop inplace - create list (drop_keys) 1.4512304149999995
del inplace 0.8008298079999996
del inplace (drop_keys) 1.1573763689999979
copy dict comprehension 1.1982901489999982
copy dict comprehension - small keep_keys 1.4407784069999998

因此，如果我们想要在适当的地方更新，似乎del是赢家-字典理解解决方案取决于正在创建的字典的大小，当然，删除一半的键已经太慢了-所以避免创建一个新的字典，如果你可以在适当的地方过滤。

编辑来解决@mpen的评论-我从keep_keys中计算了drop key(假设我们没有drop key) -我假设keep_keys/drop_keys是这个迭代的集合，或者会花很长时间。有了这些假设，del仍然更快——但要确定的是:如果你有一个(set, list, tuple)的下拉键，使用del

如果你事先知道否定集(也不是键):

v = {'a': 'foo', 'b': 'bar', 'command': 'fizz', 'host': 'buzz'  }
args = {k: v[k] for k in v if k not in ["a", "b"]}
args # {'command': 'fizz', 'host': 'buzz'}

这只是一个简单的单行函数，带有一个过滤器，只允许现有的键。

data = {'give': 'what', 'not': '___', 'me': 'I', 'no': '___', 'these': 'needed'}
keys = ['give', 'me', 'these', 'not_present']

n = { k: data[k] for k in filter(lambda k: k in data, keys) }

print(n)
print(list(n.keys()))
print(list(n.values()))

输出:

{“给予”:“什么”，“我”:“我”，“这些”:“需要”} ['give'， 'me'， 'these'] ['what'， 'I'， 'needed']

如果给定字典中没有一个过滤器键，则接受的答案抛出KeyError。

要获得给定字典的副本，只包含允许键中的一些键，一种方法是检查该键是否确实存在于字典推导中给定的字典中:

filtered_dict = { k: old_dict[k] for k in allowed_keys if k in old_dict }

这不会影响性能，因为对字典的查找具有恒定的运行时复杂性。

或者，您可以使用old_dict。获取(k, some_default)来填充缺失的项。