Python: parcourir la liste vs-dessus dict éléments efficacité

Est une itération sur some_dict.items() aussi efficace que de parcourir la liste des mêmes éléments dans Disponible?

Probablement pas, mais vous pouvez utiliser timeit à faire des points de repère.

OriginalL'auteur Jonathan | 2012-09-22

  1. 22

    Il dépend de la version de Python que vous utilisez. En Python 2, some_dict.items() crée une nouvelle liste, qui prend un peu plus de temps et utilise de la mémoire supplémentaire. D'autre part, une fois la liste créée, c'est une liste, et donc devrait avoir les mêmes caractéristiques de performance après la surcharge de la création d'une liste est complète.

    En Python 3, some_dict.items() crée un objet de vue au lieu de une liste, et je prévois que la création et l'itération sur items() serait plus rapide que Python 2, puisque rien ne doit être copié. Mais je aussi anticiper qu'une itération sur un déjà créé vue serait un peu plus lent que d'itérer sur une déjà créée liste, en raison de données du dictionnaire est stocké quelque peu à peu, et je crois qu'il n'y a pas de bonne façon de python pour éviter une itération sur chaque bin dans le dictionnaire-même le vide.

    En Python 2, certains timings de confirmer mes intuitions:

    >>> 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

    Une itération sur la items est environ deux fois plus lent. À l'aide de iteritems est un tantinet plus rapide...

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

    Mais une itération sur la liste elle-même est fondamentalement la même que l'itération sur toute autre liste:

    >>> 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 permet de créer et de faire une itération sur items plus rapide que Python 2 peut (à comparer à 57,3 nous ci-dessus):

    >>> 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

    Mais le temps de créer une vue est négligeable; il est en fait plus lentement pour itérer sur que une liste. 

    >>> 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

    Cela signifie qu'en Python 3, si vous souhaitez effectuer une itération de nombreuses fois sur les éléments d'un dictionnaire, et la performance est critique, vous pouvez obtenir 30% de l'accélération par la mise en cache de la vue sous forme de liste. 

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

    OriginalL'auteur senderle

  2. 7

    Un petit benchmark me montre que l'itération d'une liste est certainement plus rapide.

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

    Testé avec IPython sur 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

    OriginalL'auteur Wolph

  3. 0

    Bien que parcourant some_list est 2x plus rapide que some_dict.items(), mais une itération à travers some_list par index est presque le même que d'une itération à travers some_dict par clé. 

    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

    OriginalL'auteur AaronYin