Comment récupérer un élément d'un ensemble sans le supprimer?

Supposons ce qui suit:

>>> s = set([1, 2, 3])

Comment puis-je obtenir une valeur (n'importe quelle valeur) ssans le faire s.pop()? Je veux laisser l'élément dans l'ensemble jusqu'à ce que je sois sûr de pouvoir le supprimer - quelque chose dont je ne peux être sûr qu'après un appel asynchrone à un autre hôte.

Rapide et sale:

>>> elem = s.pop()
>>> s.add(elem)

Mais connaissez-vous un meilleur moyen? Idéalement en temps constant.

Deux options qui ne nécessitent pas de copier l'ensemble complet:

for e in s:
    break
# e is now an element from s

Ou...

e = next(iter(s))

Mais en général, les ensembles ne prennent pas en charge l'indexation ou le découpage.

Le moins de code serait:

>>> s = set([1, 2, 3])
>>> list(s)[0]
1

Évidemment, cela créerait une nouvelle liste qui contient chaque membre de l'ensemble, donc pas génial si votre ensemble est très grand.

Je me demandais comment les fonctions fonctionneraient pour différents ensembles, alors j'ai fait un test de performance:

from random import sample

def ForLoop(s):
    for e in s:
        break
    return e

def IterNext(s):
    return next(iter(s))

def ListIndex(s):
    return list(s)[0]

def PopAdd(s):
    e = s.pop()
    s.add(e)
    return e

def RandomSample(s):
    return sample(s, 1)

def SetUnpacking(s):
    e, *_ = s
    return e

from simple_benchmark import benchmark

b = benchmark([ForLoop, IterNext, ListIndex, PopAdd, RandomSample, SetUnpacking],
              {2**i: set(range(2**i)) for i in range(1, 20)},
              argument_name='set size',
              function_aliases={first: 'First'})

b.plot()

Ce graphique montre clairement que certaines approches ( RandomSample, SetUnpackinget ListIndex) dépendent de la taille de l'ensemble et doivent être évitées dans le cas général (au moins si les performances peuvent être importantes). Comme l'ont déjà montré les autres réponses, le moyen le plus rapide est ForLoop.

Cependant, tant qu'une des approches à temps constant est utilisée, la différence de performances sera négligeable.

iteration_utilities(Avertissement: je suis l'auteur) contient une fonction pratique pour ce cas d'utilisation first::

>>> from iteration_utilities import first
>>> first({1,2,3,4})
1

Je l'ai également inclus dans l'indice de référence ci-dessus. Il peut rivaliser avec les deux autres solutions «rapides», mais la différence n'est pas grande dans les deux cas.

tl; dr

for first_item in muh_set: breakreste l'approche optimale dans Python 3.x. ^{Je te maudis, Guido.}

tu fais ça

Bienvenue dans un autre ensemble de timings Python 3.x, extrapolé à partir de wr. est une excellente réponse spécifique à Python 2.x . Contrairement à AChampion réponse spécifique à Python 3.x tout aussi utile d' , les délais ci-dessous temporisent également les solutions aberrantes suggérées ci-dessus - y compris:

• list(s)[0], La nouvelle solution basée sur des séquences de John .
• random.sample(s, 1), dF. la solution éclectique à base de RNG .

Extraits de code pour Great Joy

Allumez, syntonisez, chronométrez:

from timeit import Timer

stats = [
    "for i in range(1000): \n\tfor x in s: \n\t\tbreak",
    "for i in range(1000): next(iter(s))",
    "for i in range(1000): s.add(s.pop())",
    "for i in range(1000): list(s)[0]",
    "for i in range(1000): random.sample(s, 1)",
]

for stat in stats:
    t = Timer(stat, setup="import random\ns=set(range(100))")
    try:
        print("Time for %s:\t %f"%(stat, t.timeit(number=1000)))
    except:
        t.print_exc()

Timings intemporels rapidement obsolètes

Voir! Ordonné par extraits les plus rapides aux plus lents:

$ ./test_get.py
Time for for i in range(1000): 
    for x in s: 
        break:   0.249871
Time for for i in range(1000): next(iter(s)):    0.526266
Time for for i in range(1000): s.add(s.pop()):   0.658832
Time for for i in range(1000): list(s)[0]:   4.117106
Time for for i in range(1000): random.sample(s, 1):  21.851104

Plantes faciales pour toute la famille

Sans surprise, l' itération manuelle reste au moins deux fois plus rapide que la solution la plus rapide suivante. Bien que l'écart ait diminué depuis les jours Bad Old Python 2.x (au cours desquels l'itération manuelle était au moins quatre fois plus rapide), il déçoit en moi le fanatique PEP 20 que la solution la plus verbeuse est la meilleure. Au moins, convertir un ensemble en liste juste pour extraire le premier élément de l'ensemble est aussi horrible que prévu.Merci Guido, que sa lumière continue de nous guider.

Étonnamment, la solution basée sur RNG est absolument horrible. La conversion de liste est mauvaise, mais prend random vraiment le gâteau de sauce horrible. Voilà pour le Dieu du nombre aléatoire .

Je souhaite juste aux amorphes qu'ils auraient PEP une set.get_first()méthode pour nous déjà. Si vous lisez ceci, ils: "S'il vous plaît. Faites quelque chose."

Pour fournir des chiffres de synchronisation derrière les différentes approches, considérez le code suivant. Le get () est mon ajout personnalisé au setobject.c de Python, étant juste un pop () sans supprimer l'élément.

from timeit import *

stats = ["for i in xrange(1000): iter(s).next()   ",
         "for i in xrange(1000): \n\tfor x in s: \n\t\tbreak",
         "for i in xrange(1000): s.add(s.pop())   ",
         "for i in xrange(1000): s.get()          "]

for stat in stats:
    t = Timer(stat, setup="s=set(range(100))")
    try:
        print "Time for %s:\t %f"%(stat, t.timeit(number=1000))
    except:
        t.print_exc()

La sortie est:

$ ./test_get.py
Time for for i in xrange(1000): iter(s).next()   :       0.433080
Time for for i in xrange(1000):
        for x in s:
                break:   0.148695
Time for for i in xrange(1000): s.add(s.pop())   :       0.317418
Time for for i in xrange(1000): s.get()          :       0.146673

Cela signifie que la solution for / break est la plus rapide (parfois plus rapide que la solution get () personnalisée).

Puisque vous voulez un élément aléatoire, cela fonctionnera également:

>>> import random
>>> s = set([1,2,3])
>>> random.sample(s, 1)
[2]

La documentation ne semble pas mentionner les performances de random.sample. À partir d'un test empirique très rapide avec une liste énorme et un ensemble énorme, il semble qu'il soit temps constant pour une liste mais pas pour l'ensemble. De plus, l'itération sur un ensemble n'est pas aléatoire; l'ordre est indéfini mais prévisible:

>>> list(set(range(10))) == range(10)
True 

Si le caractère aléatoire est important et que vous avez besoin d'un tas d'éléments en temps constant (grands ensembles), j'utiliserais random.sampleet convertirais d'abord en liste:

>>> lst = list(s) # once, O(len(s))?
...
>>> e = random.sample(lst, 1)[0] # constant time

Apparemment le moyen le plus compact (6 symboles) mais très lent pour obtenir un élément set (rendu possible par PEP 3132 ):

e,*_=s

Avec Python 3.5+, vous pouvez également utiliser cette expression à 7 symboles (grâce à PEP 448 ):

[*s][0]

Les deux options sont environ 1000 fois plus lentes sur ma machine que la méthode for-loop.

J'utilise une fonction utilitaire que j'ai écrite. Son nom est quelque peu trompeur car il implique en quelque sorte qu'il pourrait s'agir d'un élément aléatoire ou quelque chose comme ça.

def anyitem(iterable):
    try:
        return iter(iterable).next()
    except StopIteration:
        return None

Après @wr. post, j'obtiens des résultats similaires (pour Python3.5)

from timeit import *

stats = ["for i in range(1000): next(iter(s))",
         "for i in range(1000): \n\tfor x in s: \n\t\tbreak",
         "for i in range(1000): s.add(s.pop())"]

for stat in stats:
    t = Timer(stat, setup="s=set(range(100000))")
    try:
        print("Time for %s:\t %f"%(stat, t.timeit(number=1000)))
    except:
        t.print_exc()

Production:

Time for for i in range(1000): next(iter(s)):    0.205888
Time for for i in range(1000): 
    for x in s: 
        break:                                   0.083397
Time for for i in range(1000): s.add(s.pop()):   0.226570

Cependant, lors du changement de l'ensemble sous-jacent (par exemple l'appel à remove()), les choses vont mal pour les exemples itérables ( for, iter):

from timeit import *

stats = ["while s:\n\ta = next(iter(s))\n\ts.remove(a)",
         "while s:\n\tfor x in s: break\n\ts.remove(x)",
         "while s:\n\tx=s.pop()\n\ts.add(x)\n\ts.remove(x)"]

for stat in stats:
    t = Timer(stat, setup="s=set(range(100000))")
    try:
        print("Time for %s:\t %f"%(stat, t.timeit(number=1000)))
    except:
        t.print_exc()

Résulte en:

Time for while s:
    a = next(iter(s))
    s.remove(a):             2.938494
Time for while s:
    for x in s: break
    s.remove(x):             2.728367
Time for while s:
    x=s.pop()
    s.add(x)
    s.remove(x):             0.030272

Ce que je fais habituellement pour les petites collections, c'est de créer une sorte de méthode analyseur / convertisseur comme celle-ci

def convertSetToList(setName):
return list(setName)

Ensuite, je peux utiliser la nouvelle liste et accéder par numéro d'index

userFields = convertSetToList(user)
name = request.json[userFields[0]]

En tant que liste, vous aurez toutes les autres méthodes avec lesquelles vous devrez peut-être travailler

Et alors s.copy().pop()? Je ne l'ai pas chronométré, mais ça devrait marcher et c'est simple. Cependant, cela fonctionne mieux pour les petits ensembles, car il copie l'ensemble entier.

Une autre option consiste à utiliser un dictionnaire avec des valeurs qui ne vous intéressent pas. Par exemple,

poor_man_set = {}
poor_man_set[1] = None
poor_man_set[2] = None
poor_man_set[3] = None
...

Vous pouvez traiter les clés comme un ensemble, sauf qu'elles ne sont qu'un tableau:

keys = poor_man_set.keys()
print "Some key = %s" % keys[0]

Un effet secondaire de ce choix est que votre code sera rétrocompatible avec les anciennes setversions antérieures de Python. Ce n'est peut-être pas la meilleure réponse, mais c'est une autre option.

Edit: Vous pouvez même faire quelque chose comme ça pour cacher le fait que vous avez utilisé un dict au lieu d'un tableau ou d'un ensemble:

poor_man_set = {}
poor_man_set[1] = None
poor_man_set[2] = None
poor_man_set[3] = None
poor_man_set = poor_man_set.keys()