`if key in dict` vs. try / except`-哪个更易读？

我有一个关于成语和可读性的问题，对于这种特殊情况，似乎存在Python哲学上的冲突：

我想从字典B构建字典A。如果B中不存在特定键，则什么也不做，继续。

哪种方法更好？

try:
    A["blah"] = B["blah"]
except KeyError:
    pass

要么

if "blah" in B:
    A["blah"] = B["blah"]

“请原谅”与“简单明了”。

哪个更好？为什么？

异常不是有条件的。

条件版本更清晰。这很自然：这是直接的流控制，这是条件设计的目的，而不是异常。

在循环中进行这些查找时，异常版本主要用作优化：对于某些算法，它允许从内部循环中消除测试。这里没有那个好处。它有一个小的优势，它避免了重复说"blah"两次，但是，如果您要进行很多次操作，则move_key无论如何您都应该具有辅助功能。

通常，除非您有特殊原因，否则我强烈建议默认情况下使用条件版本。有条件的是执行此操作的明显方法，通常强烈建议您优先选择一种解决方案。

还有第三种避免异常和双重查询的方法，如果查询很昂贵，这可能很重要：

value = B.get("blah", None)
if value is not None: 
    A["blah"] = value

如果您希望字典包含None值，则可以使用一些更深奥的常量，例如NotImplemented，Ellipsis或创建一个新的常量：

MyConst = object()
def update_key(A, B, key):
    value = B.get(key, MyConst)
    if value is not MyConst: 
        A[key] = value

无论如何，使用update()对我来说是最易读的选项：

a.update((k, b[k]) for k in ("foo", "bar", "blah") if k in b)

据我了解，您想使用字典B中的键值对更新字典A

update 是更好的选择。

A.update(B)

例：

>>> A = {'a':1, 'b': 2, 'c':3}
>>> B = {'d': 2, 'b':5, 'c': 4}
>>> A.update(B)
>>> A
{'a': 1, 'c': 4, 'b': 5, 'd': 2}
>>> 

来自Python性能Wiki的直接报价：

除了第一次以外，每次看到一个单词时，if语句的测试都会失败。如果要计算大量单词，许多单词可能会多次出现。在一个值的初始化仅发生一次且该值的增加将发生多次的情况下，使用try语句会更便宜。

因此，根据情况，这两种选择似乎都是可行的。有关更多详细信息，您可能想查看此链接：Try-except-performance

我认为这里的一般规则A["blah"]通常会存在，如果这样，则try-except是好的，如果不是，则使用if "blah" in b:

我认为“尝试”在时间上很便宜，但“除外”则更昂贵。

我认为第二个示例是您应该追求的，除非这段代码有意义：

try:
    A["foo"] = B["foo"]
    A["bar"] = B["bar"]
    A["baz"] = B["baz"]
except KeyError:
    pass

请记住，一旦没有密钥，代码将立即中止B。如果此代码有意义，则应使用异常方法，否则应使用测试方法。我认为，因为它更短并且清楚地表达了意图，所以它比异常方法更容易阅读。

当然，告诉您使用的人update是正确的。如果您使用的是支持字典理解的Python版本，则强烈建议您使用以下代码：

updateset = {'foo', 'bar', 'baz'}
A.update({k: B[k] for k in updateset if k in B})

其他语言的规则是为例外情况保留例外，即在常规使用中不会发生的错误。不知道该规则如何适用于Python，因为该规则不应该存在StopIteration。

就个人而言，我倾向于第二种方法（但使用has_key）：

if B.has_key("blah"):
  A["blah"] = B["blah"]

这样，每个赋值操作只有两行（而try / except则为4行），并且抛出的任何异常都将是真正的错误或您错过的事情（而不仅仅是尝试访问不存在的键） 。

事实证明（请参阅您的问题的评论），has_key已弃用-因此，我认为将其写为

if "blah" in B:
  A["blah"] = B["blah"]

从开始Python 3.8，并引入赋值表达式（PEP 572）（:=运算符），我们可以捕获条件值dictB.get('hello', None)到变量value中，以检查条件值是否不是None（dict.get('hello', None)返回关联值或None），然后在条件：

# dictB = {'hello': 5, 'world': 42}
# dictA = {}
if value := dictB.get('hello', None):
  dictA["hello"] = value
# dictA is now {'hello': 5}

尽管公认的答案强调“跨越式先行”原则可能适用于大多数语言，但基于python原则，更多的pythonic可能是第一种方法。更不用说这是python中的合法编码风格。重要的是要确保在正确的上下文中使用try try块并遵循最佳实践。例如。在try块中做太多的事情，捕获到非常广泛的异常，或更糟的是-仅有的except子句等。

寻求宽恕比允许容易。（EAFP）

请参见Python文档参考这里。

此外，来自Brett（核心开发人员之一）的博客简要介绍了其中的大部分内容。

在这里查看另一个SO讨论：