Diferencia entre dict.clear() y asignar {} en Python

Question

En python, ¿hay alguna diferencia entre llamar a clear() y asignar {} a un diccionario? ¿Y si si, que? Ejemplo:

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

Answer 1

Si usted tiene otra variable también se refieren al mismo diccionario, hay una gran diferencia:

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

Esto se debe a la asignación de d = {} crea un nuevo diccionario, vacío y lo asigna a la d variable. Esto deja d2 apuntando al viejo diccionario con los elementos que todavía están en él. Sin embargo, d.clear() borra el mismo diccionario que d y d2 ambos apuntan a.

Answer 2

d = {} creará una nueva instancia para d pero todas las demás referencias seguirán señalando los contenidos anteriores. d.clear() restablecerá el contenido, pero todas las referencias a la misma instancia seguirán siendo correctas.

Answer 3

Además de las diferencias mencionadas en otras respuestas, también hay una diferencia de velocidad. d = {} es más de dos veces más rápido:

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 

Answer 4

A modo de ejemplo de las cosas ya mencionadas antes:

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

Answer 5

Además de @odano 's respuesta, parece que el uso de d.clear() más rápido si se le gustaría borrar el dict por muchas veces.

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) 

El resultado es:

20.0367929935 
19.6444659233 

Answer 6

Una cosa que no se menciona es cuestiones de alcance. No es un gran ejemplo, pero aquí está el caso en el que me encontré con el problema:

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 

La solución es reemplazar c_kwargs = {} con c_kwargs.clear()

Si alguien piensa que un ejemplo más práctico, no dude en editar este post .

Answer 7

La mutación métodos son útiles siempre si el objeto original no está en su alcance:

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

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

Reasignar el diccionario crearía un nuevo objeto y no modificaría la original.

Answer 8

Además, a veces la instancia dict podría ser una subclase de dict (defaultdict por ejemplo). En ese caso, se prefiere usar clear, ya que no tenemos que recordar el tipo exacto del dict, y también evitar el código duplicado (acoplar la línea de compensación con la línea de inicialización).

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