Ensembles Python vs Listes
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 quand même les doublons, un ensemble Python est-il plus lent qu'une liste Python?
Cela dépend de ce que vous avez l'intention de faire avec.
Les ensembles sont beaucoup plus rapides pour déterminer si un objet est présent dans l'ensemble (comme dans x in s), mais sont plus lents que les listes lorsqu'il s'agit d'itérer leur contenu.
Vous pouvez utiliser le module timeit pour voir lequel est le plus rapide selon votre situation.
Les listes sont légèrement plus rapides que les ensembles lorsque vous souhaitez simplement parcourir les valeurs.
Les ensembles sont toutefois beaucoup plus rapides que les listes si vous souhaitez vérifier si un élément est contenu dans celui-ci. Cependant, ils ne peuvent contenir que des objets uniques.
Il s'avère que les n-uplets fonctionnent presque de la même manière que les listes, à l'exception de leur immuabilité.
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étermine 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
Liste des performances:
>>> import timeit
>>> timeit.timeit(stmt='10**6 in a', setup='a = range(10**6)', number=100000)
0.008128150348026608
Définir la performance:
>>> timeit.timeit(stmt='10**6 in a', setup='a = set(range(10**6))', number=100000)
0.005674857488571661
Vous voudrez peut-être envisager Tuples ils sont similaires aux listes mais ne peuvent pas être modifiés. Ils utilisent un peu moins de mémoire et sont plus rapides d'accès. Ils ne sont pas aussi flexibles mais sont plus efficaces que les listes. Leur utilisation normale est de servir de clés de dictionnaire.
Les ensembles sont également des structures de séquence, mais avec deux différences entre les listes et les n-uplets. Bien que les ensembles aient un ordre, cet ordre est arbitraire et n'est pas sous le contrôle du programmeur. La deuxième différence est que les éléments d'un ensemble doivent être uniques.
set par définition. [ python | wiki ].
>>> x = set([1, 1, 2, 2, 3, 3])
>>> x
{1, 2, 3}
Set gagne en raison de vérifications «contient» presque instantanées: https://en.wikipedia.org/wiki/Hash_table
List implémentation: généralement un tableau, niveau bas proche du métal, bon pour l'itération et l'accès aléatoire par index d'élément.
Set implementation: https://en.wikipedia.org/wiki/Hash_table , il n'itère pas la liste, mais trouve l'élément en calculant un hash à partir de la clé, donc cela dépend de la nature des éléments clés et de la fonction de hachage. Semblable à ce qui est utilisé pour dict. Je soupçonne que list pourrait être plus rapide si vous avez très peu d'éléments (<5). Plus le nombre d'éléments est grand, meilleure sera la set pour une vérification de contenu. Il est également rapide pour l’ajout et le retrait d’éléments.
NOTE: Si la list est déjà triée, la recherche de la list peut être assez rapide, mais dans les cas usuels, une set est plus rapide et plus simple pour les vérifications de contenu.
Je recommanderais une implémentation Set dans laquelle le cas d'utilisation est limité au référencement ou à la recherche d'existence et à l'implémentation Tuple lorsque le cas d'utilisation nécessite l'exécution d'une itération. Une liste est une implémentation de bas niveau et nécessite une surcharge de mémoire importante.
tl; dr
Les structures de données (DS) sont importantes car elles sont utilisées pour effectuer des opérations sur des données, ce qui implique fondamentalement: de prendre une entrée , de le traiter , et rendent la sortie .
Certaines structures de données sont plus utiles que d'autres dans certains cas particuliers. Par conséquent, il est assez injuste de demander lequel (DS) est le plus efficace/rapide. C'est comme demander quel outil est le plus efficace entre un couteau et une fourchette. Je veux dire que tout dépend de la situation.
Listes
Une liste est une séquence mutable , généralement utilisée pour stocker des collections d'éléments homogènes .
Ensembles
Un objet set est une collection non ordonnée d'objets distincts pouvant être séparés . Il est couramment utilisé pour tester l'appartenance, supprimer les doublons d'une séquence et calculer des opérations mathématiques telles que l'intersection, l'union, la différence et la différence symétrique.
Usage
Certaines réponses indiquent clairement qu’une liste est bien plus rapide qu’un ensemble lorsqu’il parcourt les valeurs. D'autre part, un ensemble est plus rapide qu'une liste lorsqu'il vérifie si un élément est contenu dans celui-ci. Par conséquent, la seule chose que vous puissiez dire, c'est qu'une liste est préférable à un ensemble pour certaines opérations et inversement.