Sự khác biệt giữa dict.clear () và gán {} trong Python

Trong python, có sự khác biệt giữa gọi clear()và gán {}cho một từ điển? Nếu có, nó là cái gì? Thí dụ:

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

Nếu bạn có một biến khác cũng đề cập đến cùng một từ điển, có một sự khác biệt lớn:

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

Điều này là do việc gán d = {}tạo ra một từ điển mới, trống và gán nó cho dbiến. Lá này d2chỉ vào từ điển cũ với các mục vẫn còn trong đó. Tuy nhiên, d.clear()xóa cùng một từ điển dvà d2cả hai điểm.

d = {}sẽ tạo một phiên bản mới cho dnhưng tất cả các tham chiếu khác vẫn sẽ trỏ đến nội dung cũ. d.clear()sẽ đặt lại nội dung, nhưng tất cả các tham chiếu đến cùng một thể hiện vẫn sẽ chính xác.

Ngoài sự khác biệt được đề cập trong các câu trả lời khác, còn có sự khác biệt về tốc độ. d = {} nhanh hơn gấp đôi:

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

Như một minh họa cho những điều đã được đề cập trước đó:

>>> a = {1:2}
>>> id(a)
3073677212L
>>> a.clear()
>>> id(a)
3073677212L
>>> a = {}
>>> id(a)
3073675716L

Ngoài câu trả lời của @odano, có vẻ như việc sử dụng d.clear()sẽ nhanh hơn nếu bạn muốn xóa chính tả nhiều lần.

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)

Kết quả là:

20.0367929935
19.6444659233

Các phương thức gây đột biến luôn hữu ích nếu đối tượng ban đầu không nằm trong phạm vi:

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

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

Việc gán lại từ điển sẽ tạo ra một đối tượng mới và sẽ không sửa đổi đối tượng ban đầu.

Một điều không được đề cập là vấn đề phạm vi. Không phải là một ví dụ tuyệt vời, nhưng đây là trường hợp tôi gặp phải vấn đề:

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

Giải pháp là thay thế c_kwargs = {}bằngc_kwargs.clear()

Nếu ai đó nghĩ ra một ví dụ thực tế hơn, vui lòng chỉnh sửa bài đăng này.

Ngoài ra, đôi khi thể hiện dict có thể là một lớp con của dict ( defaultdictví dụ). Trong trường hợp đó, việc sử dụng clearđược ưu tiên hơn, vì chúng ta không phải nhớ chính xác loại chính tả và cũng tránh mã trùng lặp (ghép dòng xóa với dòng khởi tạo).

x = defaultdict(list)
x[1].append(2)
...
x.clear() # instead of the longer x = defaultdict(list)