Question

我要检查字典中是否存在键。据我所知，最合适的方法是： if d_.get(s):。但是，在尝试对Leetcode提问时，当我使用此方法时出现TLE错误。但是，当我尝试if s in d_时，TLE消失了。我想知道为什么in比get()快。

我尝试了一些问题，发现this one上有d_.get() v / s d_[s]的解释。没有一个问题是d_.get()对s in d_的回答。

以防万一，在某些情况下：

以if self.memo.get(s):失败的代码：

from typing import List


class Solution:
    def __init__(self):
        self.word_dict = {}
        self.memo = {}

    def word_break(self, s):
        if not s:
            return True
        if self.memo.get(s):
            return self.memo[s]
        res = False
        for word in self.word_dict.keys():
            if len(word) <= len(s) and s[:len(word)] == word:
                res = res or self.word_break(s[len(word):])
                self.memo[s] = res
        return res

    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
        for word in wordDict:
            self.word_dict[word] = 1
        return(self.word_break(s))

该代码已被if s in self.memo接受：

from typing import List


class Solution:
    def __init__(self):
        self.word_dict = {}
        self.memo = {}

    def word_break(self, s):
        if not s:
            return True
        if s in self.memo:
            return self.memo[s]
        res = False
        for word in self.word_dict.keys():
            if len(word) <= len(s) and s[:len(word)] == word:
                res = res or self.word_break(s[len(word):])
                self.memo[s] = res
        return res

    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
        for word in wordDict:
            self.word_dict[word] = 1
        return(self.word_break(s))

我一直认为in比获取属性（这里是get()）要慢。

Answer 1

使用链接问题中的dis.dis方法：

>>> import dis
>>> dis.dis(compile('d.get(key)', '', 'eval'))
  1           0 LOAD_NAME                0 (d)
              2 LOAD_METHOD              1 (get)
              4 LOAD_NAME                2 (key)
              6 CALL_METHOD              1
              8 RETURN_VALUE
>>> dis.dis(compile('key in d', '', 'eval'))
  1           0 LOAD_NAME                0 (key)
              2 LOAD_NAME                1 (d)
              4 COMPARE_OP               6 (in)
              6 RETURN_VALUE

我们可以清楚地看到d.get(key)必须再执行一个步骤：LOAD_METHOD步骤。此外，d.get必须处理更多信息：它必须：

检查是否存在
如果找到，则返回值
否则，返回指定的默认值（如果未指定默认值，则返回None。

另外，通过查看C code for in和C code for .get，我们可以发现它们非常相似。

int                                                           static PyObject * 
PyDict_Contains(PyObject *op, PyObject *key)                  dict_get_impl(PyDictObject *self, PyObject *key, PyObject *default_value)
{                                                             {
    Py_hash_t hash;                                               PyObject *val = NULL;
    Py_ssize_t ix;                                                Py_hash_t hash;
    PyDictObject *mp = (PyDictObject *)op;                        Py_ssize_t ix;                       
    PyObject *value;                                           

    if (!PyUnicode_CheckExact(key) ||                             if (!PyUnicode_CheckExact(key) ||                  
        (hash = ((PyASCIIObject *) key)->hash) == -1) {               (hash = ((PyASCIIObject *) key)->hash) == -1) {                             
        hash = PyObject_Hash(key);                                    hash = PyObject_Hash(key);        
        if (hash == -1)                                               if (hash == -1)
            return -1;                                                    return NULL;
    }                                                             }
    ix = (mp->ma_keys->dk_lookup)(mp, key, hash, &value);         ix = (self->ma_keys->dk_lookup) (self, key, hash, &val);                                         
    if (ix == DKIX_ERROR)                                         if (ix == DKIX_ERROR) 
        return -1;                                                    return NULL;
    return (ix != DKIX_EMPTY && value != NULL);                   if (ix == DKIX_EMPTY || val == NULL) {                        
}                                                                     val = default_value;
                                                                  }
                                                                  Py_INCREF(val);
                                                                  return val;
                                                              }

实际上，它们几乎相同，但是.get的开销更大，必须返回一个值。

但是，如果已知哈希值，d in key似乎将使用faster method，而d.get每次都会重新计算哈希值。此外，CALL_METHOD和LOAD_METHOD的开销比执行内置布尔运算之一的COMPARE_OP高得多。请注意，COMPARE_OP只会跳到here。

Answer 2

时间开销是显式调用方法，而不是让语言构造体来照顾它。我们可以使用timeit进行演示：

>>> timeit.timeit('"__name__" in x', 'x = globals()')
0.037103720999766665
>>> timeit.timeit('x.__contains__("__name__")', 'x = globals()')
0.07471312899997429
>>> timeit.timeit('x["__name__"]', 'x = globals()')
0.03828814600001351
>>> timeit.timeit('x.__getitem__("__name__")', 'x = globals()')
0.07529343100031838
>>> timeit.timeit('x.get("__name__")', 'x = globals()')
0.08261531900006958

我最初尝试通过分别查看__contains__()和.get()的源代码来找出差异，只是发现除了增加.get()之外，它们几乎是相同的对象的引用计数（应该差不多可以忽略不计）。当然，没有足够的差异来解释您所看到的时差。

但是，通过测试，我们可以看到实际上使用了语言构造（in和[]），而不是它们会变成（__contains__()和{{ 1}}）快了整整50％。

全面调查将花费我一些时间和精力，但我想这是由于某些内置的加速器和解释器适用的跳过的步骤-使用语言构造而不是显式调用方法降低了可以预期的复杂度，并且解释器可以直接跳入C代码，而无需先调用该方法即可。

正如@rassar的答案所表明的，实际上，这基本上就是发生的情况。

Answer 3

这两段代码做的不一样。请注意如何设置self.memo：

self.memo[s] = res

如果res是False，则if的{{1}}语句将失败，而get的{{1}}将会成功。

为什么dict（）中的key比Python3中的dict.get（key）更快？

3 个答案: