Python: iterar sobre la lista de artículos de diccionario vs sobre la eficiencia

Question

Se iteración sobre some_dict.items() tan eficiente como iterar sobre una lista de los mismos artículos en CPython?

Answer 1

Depende de la versión de Python que esté utilizando. En Python 2, some_dict.items() crea una nueva lista, que ocupa algo más de tiempo y utiliza memoria adicional. Por otro lado, una vez creada la lista, que es una lista, y así debe tener características de funcionamiento idénticos después de la sobrecarga de la creación de la lista es completa.

En Python 3, some_dict.items() crea un objeto de vista en lugar de una lista, y anticipo que la creación e iteración sobre items() sería más rápida que en Python 2, ya que no se debe copiar nada. Pero tambiénanticipo que la iteración en una vista ya creado sería un poco más lenta que la iteración en una lista ya creada, ya que los datos diccionario se almacena un tanto escaso, y creo que no hay una buena manera para que pitón para evitar la iteración sobre cada bin en el diccionario, incluso los vacíos.

En Python 2, unos tiempos de confirmar mis intuiciones:

>>> some_dict = dict(zip(xrange(1000), reversed(xrange(1000)))) 
>>> some_list = zip(xrange(1000), xrange(1000)) 
>>> %timeit for t in some_list: t 
10000 loops, best of 3: 25.6 us per loop 
>>> %timeit for t in some_dict.items(): t 
10000 loops, best of 3: 57.3 us per loop 

interactuando sobre la items es aproximadamente dos veces más lento. Usando iteritems está un poco poco más rápido ...

>>> %timeit for t in some_dict.iteritems(): t 
10000 loops, best of 3: 41.3 us per loop 

Pero la iteración en la lista en sí es básicamente la misma que la iteración en cualquier otra lista:

>>> some_dict_list = some_dict.items() 
>>> %timeit for t in some_dict_list: t 
10000 loops, best of 3: 26.1 us per loop 

Python 3 puede crear y iterar sobre items más rápido que Python 2 puede (compárese con 57.3 us):

>>> some_dict = dict(zip(range(1000), reversed(range(1000)))) 
>>> %timeit for t in some_dict.items(): t  
10000 loops, best of 3: 33.4 us per loop 

Pero el tiempo para crear una vista es insignificante; en realidad es más lento iterar que una lista.

>>> some_list = list(zip(range(1000), reversed(range(1000)))) 
>>> some_dict_view = some_dict.items() 
>>> %timeit for t in some_list: t 
10000 loops, best of 3: 18.6 us per loop 
>>> %timeit for t in some_dict_view: t 
10000 loops, best of 3: 33.3 us per loop 

Esto significa que en Python 3, si desea repetir muchas veces en los artículos en un diccionario, y el rendimiento es crítico, se puede obtener un aumento de velocidad del 30% en el almacenamiento en caché de la vista en forma de lista.

>>> some_list = list(some_dict_view) 
>>> %timeit for t in some_list: t 
100000 loops, best of 3: 18.6 us per loop 

Answer 2

Un poco de referencia me muestra que se repite una lista es definitivamente más rápido.

def iterlist(list_): 
    i = 0 
    for _ in list_: 
     i += 1 
    return i 

def iterdict(dict_): 
    i = 0 
    for _ in dict_.iteritems(): 
     i += 1 
    return i 

def noiterdict(dict_): 
    i = 0 
    for _ in dict_.items(): 
     i += 1 
    return i 

list_ = range(1000000) 
dict_ = dict(zip(range(1000000), range(1000000))) 

probado con IPython en Python 2.7 (Kubuntu):

%timeit iterlist(list_) 
10 loops, best of 3: 28.5 ms per loop 

%timeit iterdict(dict_) 
10 loops, best of 3: 39.7 ms per loop 

%timeit noiterdict(dict_) 
10 loops, best of 3: 86.1 ms per loop 

Answer 3

Aunque iteración a través de some_list es aumento de velocidad 2x de some_dict.items(), pero iteración a través de some_list por el índice es casi tan mismo como iteración a través de some_dict por clave .

K = 1000000 
some_dict = dict(zip(xrange(K), reversed(xrange(K)))) 
some_list = zip(xrange(K), xrange(K)) 
%timeit for t in some_list: t 
10 loops, best of 3: 55.7 ms per loop 
%timeit for i in xrange(len(some_list)):some_list[i] 
10 loops, best of 3: 94 ms per loop 
%timeit for key in some_dict: some_dict[key] 
10 loops, best of 3: 115 ms per loop 
%timeit for i,t in enumerate(some_list): t 
10 loops, best of 3: 103 ms per loop