Python 检查字典中是否已存在给定的密钥

在更新键的值之前，我想测试字典中是否存在键。 我编写了以下代码：

if 'key1' in dict.keys():
  print "blah"
else:
  print "boo"

---

我认为这不是完成这项任务的最佳方式。有没有更好的方法来测试字典中的键？

您不必调用键：

if 'key1' in dict:
  print("blah")
else:
  print("boo")

这与它使用字典的散列而不是调用键所做的线性搜索差不多。

您可以将其缩短：

if 'key1' in dict:
    ...

---

然而，这充其量只是一种表面上的改进。为什么您认为这不是最好的方法？

我建议改用

setdefault

方法。听起来它能做你想做的一切

>>> d = {'foo':'bar'}
>>> q = d.setdefault('foo','baz') #Do not override the existing key
>>> print q #The value takes what was originally in the dictionary
bar
>>> print d
{'foo': 'bar'}
>>> r = d.setdefault('baz',18) #baz was never in the dictionary
>>> print r #Now r has the value supplied above
18
>>> print d #The dictionary's been updated
{'foo': 'bar', 'baz': 18}

是测试数据库中是否存在密钥的预期方法

如果需要默认设置，则始终可以使用：

如果要始终确保任何键的默认值，可以重复使用或从模块中使用，如下所示：

from collections import defaultdict

d = defaultdict(int)

for i in range(100):
    d[i % 10] += 1

---

但一般来说，关键字in是最好的方法。

您可以使用in关键字测试字典中是否存在关键字：

d={'a'：1，'b'：2}
仅d#python2中的'a'（并且python2.7已经支持'in'）
您可以使用
has_key（）
方法：

if dict.has_key('xyz')==1:
    #update the value for the key
else:
    pass

d.get("key")

仅供参考添加到克里斯。B（最佳答案）：

工作也很好；原因是调用
int（）
返回
0
，这是
defaultdict
在幕后（构建字典时）所做的，因此在文档中被称为“工厂函数”。
使用EAFP如何（请求原谅比许可更容易）：

见其他SO帖子：

或

有关公认答案建议方法（10m循环）执行速度的更多信息：


mydict中的“键”
运行时间1.07秒
mydict.get（'key'）
运行时间1.84秒
mydefaultdict['key']
运行时间1.07秒

因此，建议使用
中的
或
defaultdict
来反对
get
获得结果的方法是：


如果您的字典有密钥（密钥）
如果输入您的命令
试/除块

哪个更好取决于三件事：

字典是“通常有密钥”还是“通常没有密钥”
你打算使用像if…else…elseif…else这样的条件吗
这本字典有多大
阅读更多：

使用try/block代替“in”或“if”：

try:
    my_dict_of_items[key_i_want_to_check]
except KeyError:
    # Do the operation you wanted to do for "key not present in dict".
else:
    # Do the operation you wanted to do with "key present in dict."

python中的Dictionary有一个get（'key'，default）方法。因此，您可以设置一个默认值，以防没有键

values = {...}
myValue = values.get('Key', None)

Python dictionary有一个名为
\uuuuuuuuuu包含的方法。如果字典具有键，则此方法将返回True，否则返回False

 >>> temp = {}

 >>> help(temp.__contains__)

Help on built-in function __contains__:

__contains__(key, /) method of builtins.dict instance
    True if D has a key k, else False.

使用三元运算符：

message = "blah" if 'key1' in dict else "booh"
print(message)

您可以使用
for
循环遍历字典，并获取要在字典中查找的键的名称，然后使用
if
条件检查它是否存在：

dic = {'first' : 12, 'second' : 123}
for each in dic:
    if each == 'second': 
        print('the key exists and the corresponding value can be updated in the dictionary')

共享使用布尔运算符检查键是否存在的另一种方法

d = {'a': 1, 'b':2}
keys = 'abcd'

for k in keys:
    x = (k in d and 'blah') or 'boo'
    print(x) 

这是回报

>>> blah
>>> blah
>>> boo
>>> boo

解释

首先，您应该知道，在Python中，
0
、
None
，或长度为零的对象的计算结果为
False
。其他所有内容的计算结果均为
True
。布尔运算从左到右求值，返回的操作数不为True或False

让我们看一个例子：

>>> 'Some string' or 1/0 
'Some string'
>>>

由于
'Some string'
的计算结果为
True
，因此不会计算
或
的其余部分，并且不会产生被零除的错误

但是，如果我们切换顺序
1/0
，则首先计算并引发异常：

>>> 1/0 or 'Some string'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> 

与

if k in d:
    'blah'
else:
    False

如果密钥存在，这已经返回了正确的结果，但我们希望它在不存在时打印“boo”。因此，我们获取结果，并使用
'boo'

>>> False or 'boo'
'boo'
>>> 'blah' or 'boo'
'blah'
>>> 

检查字典中是否已存在给定的密钥
为了了解如何做到这一点，我们首先检查可以调用字典的方法。
方法如下：

d={'clear':0, 'copy':1, 'fromkeys':2, 'get':3, 'items':4, 'keys':5, 'pop':6, 'popitem':7, 'setdefault':8, 'update':9, 'values':10}



检查密钥是否已存在的方法可能是
get（）
方法：

if dict.has_key('xyz')==1:
    #update the value for the key
else:
    pass

d.get("key")

另外两个有趣的方法
items（）
和
keys（）
听起来工作量太大了。因此，让我们检查一下
get（）
是否是适合我们的方法。我们有我们的指令
d
：

d= {'clear':0, 'copy':1, 'fromkeys':2, 'get':3, 'items':4, 'keys':5, 'pop':6, 'popitem':7, 'setdefault':8, 'update':9, 'values':10}

打印显示我们没有的密钥将返回
None
：

print(d.get('key')) #None
print(d.get('clear')) #0
print(d.get('copy')) #1

d= {'key':None}
print(d.get('key')) #None
print(d.get('key2')) #None

如果钥匙存在或没有，我们可以用它来获取信息。
但是如果我们用一个单一的<代码>键创建一个DICT，请考虑：
print(d.get('key')) #None
print(d.get('clear')) #0
print(d.get('copy')) #1

d= {'key':None}
print(d.get('key')) #None
print(d.get('key2')) #None

在某些值可能是
None
的情况下，引导
get（）
方法是不可靠的。
这个故事应该有一个更快乐的结局。如果我们在
比较器中使用
：

print('key' in d) #True
print('key2' in d) #False

我们得到了正确的结果。
我们可以检查Python字节代码：

import dis
dis.dis("'key' in d")
#   1           0 LOAD_CONST               0 ('key')
#               2 LOAD_NAME                0 (d)
#               4 COMPARE_OP               6 (in)
#               6 RETURN_VALUE

dis.dis("d.get('key2')")
#   1           0 LOAD_NAME                0 (d)
#               2 LOAD_METHOD              1 (get)
#               4 LOAD_CONST               0 ('key2')
#               6 CALL_METHOD              1
#               8 RETURN_VALUE

这表明，
中的
比较运算符不仅比
get（）
更可靠，而且比
。使用此方法查找键的时间是O（1），而调用键将生成一个列表，并且是O（n）。你确定这不是O（logn）吗？这是单个dict查找的复杂性，平均为O（1），最坏为O（n）。list（）将始终为O（n）。这也避免了额外的分配。（对于加快紧密循环非常重要）OP的问题与
setdefault
有什么关系？@hughdbrown“我想在更新键的值之前测试字典中是否存在键。”有时帖子中包含的代码会对一些不太符合原始目标的内容产生一连串的响应。要实现第一句中所述的目标，setdefault是最有效的方法，尽管它不是示例代码的替代品
d= {'key':None}
print(d.get('key')) #None
print(d.get('key2')) #None

print('key' in d) #True
print('key2' in d) #False

import dis
dis.dis("'key' in d")
#   1           0 LOAD_CONST               0 ('key')
#               2 LOAD_NAME                0 (d)
#               4 COMPARE_OP               6 (in)
#               6 RETURN_VALUE

dis.dis("d.get('key2')")
#   1           0 LOAD_NAME                0 (d)
#               2 LOAD_METHOD              1 (get)
#               4 LOAD_CONST               0 ('key2')
#               6 CALL_METHOD              1
#               8 RETURN_VALUE