Ensembles Python vs Listes

Question

En Python, quelle structure de données est la plus efficace / rapide? En supposant que cet ordre ne soit pas important pour moi et que je vérifierais les doublons de toute façon, un jeu Python est-il plus lent qu'une liste Python?

Answer 1

Cela dépend de ce que vous avez l'intention de faire avec. Les ensembles sont beaucoup plus rapides lorsqu'il s'agit de déterminer si un objet est présent dans l'ensemble (comme dans x in s ), mais ils sont plus lents que les listes lorsqu'il s'agit d'itérer leur contenu. Vous pouvez utiliser le module timeit pour voir ce qui est le plus rapide pour votre situation.

Answer 2

Si vous voulez conserver certaines valeurs lequel vous serez à parcourir, Python liste constructions sont légèrement plus rapide. Toutefois, si vous entreposez (unique) des valeurs afin de vérifier leur existence, alors les ensembles sont beaucoup plus rapides.

Il s'avère tuples effectuer dans presque exactement de la même manière que pour les listes, mais ils n'utilisent moins de mémoire en supprimant la possibilité de les modifier après la création (immuable).

L'itération

>>> def iter_test(iterable):
...     for i in iterable:
...         pass
...
>>> from timeit import timeit
>>> timeit(
...     "iter_test(iterable)",
...     setup="from __main__ import iter_test; iterable = set(range(10000))",
...     number=100000)
12.666952133178711
>>> timeit(
...     "iter_test(iterable)",
...     setup="from __main__ import iter_test; iterable = list(range(10000))",
...     number=100000)
9.917098999023438
>>> timeit(
...     "iter_test(iterable)",
...     setup="from __main__ import iter_test; iterable = tuple(range(10000))",
...     number=100000)
9.865639209747314

Déterminer si un objet est présent

>>> def in_test(iterable):
...     for i in range(1000):
...         if i in iterable:
...             pass
...
>>> from timeit import timeit
>>> timeit(
...     "in_test(iterable)",
...     setup="from __main__ import in_test; iterable = set(range(1000))",
...     number=10000)
0.5591847896575928
>>> timeit(
...     "in_test(iterable)",
...     setup="from __main__ import in_test; iterable = list(range(1000))",
...     number=10000)
50.18339991569519
>>> timeit(
...     "in_test(iterable)",
...     setup="from __main__ import in_test; iterable = tuple(range(1000))",
...     number=10000)
51.597304821014404

Answer 3

Les performances de la liste:

>>> import timeit
>>> timeit.timeit(stmt='10**6 in a', setup='a = range(10**6)', number=100000)
0.008128150348026608

Performances:

>>> timeit.timeit(stmt='10**6 in a', setup='a = set(range(10**6))', number=100000)
0.005674857488571661

Vous pourriez envisager de Tuples comme ils sont semblables à des listes, mais ne peut pas être modifié. Ils prennent un peu moins de mémoire et sont plus rapides d'accès. Ils ne sont pas aussi souples, mais elles sont plus efficaces que les listes. Leur utilisation normale est de servir les clés de dictionnaire.

Les ensembles sont aussi des structures séquence, mais avec deux différences dans les listes et les tuples. Bien que les jeux ont un ordre, cet ordre est arbitraire et ne pas être sous le programmeur de contrôle. La deuxième différence est que les éléments d'un jeu doit être unique.

set , par définition. [python | wiki].

>>> x = set([1, 1, 2, 2, 3, 3])
>>> x
{1, 2, 3}

Answer 4

Cela dépend de ce que vous entendez par "vérifier s'il y a des doublons". Quel pourcentage d'entrée est unique? Aussi plus lent à faire quoi? Essayez d’écrire (pour chacun des ensembles et des listes) le code qui fait ce que vous voulez faire et chronométrez-le. Vous pouvez ensuite demander ici de faire vérifier / améliorer votre code et votre méthodologie de chronométrage.