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

d = {} creará una nueva instancia para d pero todas las demás referencias seguirán apuntando al contenido antiguo. d.clear() restablecerá el contenido, pero todas las referencias a la misma instancia seguirán siendo correctas.

Además De las diferencias mencionadas en otras respuestas, también hay una diferencia de velocidad. d = {} es más del doble de 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

Además de la respuesta de @odano, parece que usar d.clear() es más rápido si desea borrar el dictado 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

Como ilustración de las cosas ya mencionadas:

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

Los métodos mutantes siempre son útiles si el objeto original no está en el 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 el original.

Una cosa que no se menciona son los problemas de alcance. No es un gran ejemplo, pero aquí está el caso donde 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 sustituir c_kwargs = {} por c_kwargs.clear()

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

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 (acoplando 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)