180

clear()在python中，调用和分配{}给字典有区别吗？如果是，那是什么？例子：

d = {"stuff":"things"}
d.clear()   #this way
d = {}      #vs this way

4

8 回答 8

303

如果您有另一个变量也引用同一字典，则存在很大差异：

>>> d = {"stuff": "things"}
>>> d2 = d
>>> d = {}
>>> d2
{'stuff': 'things'}
>>> d = {"stuff": "things"}
>>> d2 = d
>>> d.clear()
>>> d2
{}

这是因为分配d = {}创建了一个新的空字典并将其分配给d变量。这留下d2了指向旧字典，其中仍有项目。但是，d.clear()清除d和d2都指向的同一个字典。

于 2008-12-15T22:30:29.463 回答
32

d = {}将创建一个新实例，d但所有其他引用仍将指向旧内容。 d.clear()将重置内容，但对同一实例的所有引用仍然是正确的。

于 2008-12-15T22:32:02.907 回答
22

除了其他答案中提到的差异之外，还存在速度差异。d = {} 快两倍多：

python -m timeit -s "d = {}" "for i in xrange(500000): d.clear()"
10 loops, best of 3: 127 msec per loop

python -m timeit -s "d = {}" "for i in xrange(500000): d = {}"
10 loops, best of 3: 53.6 msec per loop
于 2008-12-16T11:31:10.790 回答
8

作为前面已经提到的事情的说明：

>>> a = {1:2}
>>> id(a)
3073677212L
>>> a.clear()
>>> id(a)
3073677212L
>>> a = {}
>>> id(a)
3073675716L
于 2011-12-08T08:34:25.803 回答
7

除了@odano 的回答，d.clear()如果您想多次清除字典，似乎使用速度更快。

import timeit

p1 = ''' 
d = {}
for i in xrange(1000):
    d[i] = i * i
for j in xrange(100):
    d = {}
    for i in xrange(1000):
        d[i] = i * i
'''

p2 = ''' 
d = {}
for i in xrange(1000):
    d[i] = i * i
for j in xrange(100):
    d.clear()
    for i in xrange(1000):
        d[i] = i * i
'''

print timeit.timeit(p1, number=1000)
print timeit.timeit(p2, number=1000)

结果是：

20.0367929935
19.6444659233
于 2012-12-25T08:41:33.207 回答
7

如果原始对象不在范围内，变异方法总是有用的：

def fun(d):
    d.clear()
    d["b"] = 2

d={"a": 2}
fun(d)
d          # {'b': 2}

重新分配字典将创建一个新对象，并且不会修改原始对象。

于 2015-11-25T10:27:12.553 回答
4

没有提到的一件事是范围问题。不是一个很好的例子，但这是我遇到问题的情况：

def conf_decorator(dec):
    """Enables behavior like this:
        @threaded
        def f(): ...

        or

        @threaded(thread=KThread)
        def f(): ...

        (assuming threaded is wrapped with this function.)
        Sends any accumulated kwargs to threaded.
        """
    c_kwargs = {}
    @wraps(dec)
    def wrapped(f=None, **kwargs):
        if f:
            r = dec(f, **c_kwargs)
            c_kwargs = {}
            return r
        else:
            c_kwargs.update(kwargs) #<- UnboundLocalError: local variable 'c_kwargs' referenced before assignment
            return wrapped
    return wrapped

解决方案是替换c_kwargs = {}为c_kwargs.clear()

如果有人想出一个更实际的例子，请随时编辑这篇文章。

于 2013-08-26T01:53:11.040 回答
4

此外，有时 dict 实例可能是 dict 的子类（defaultdict例如）。在这种情况下，clear最好使用 using，因为我们不必记住 dict 的确切类型，也可以避免重复代码（将清除行与初始化行耦合）。

x = defaultdict(list)
x[1].append(2)
...
x.clear() # instead of the longer x = defaultdict(list)
于 2017-07-03T11:47:11.387 回答