Come recuperare un elemento da un set senza rimuoverlo?

Supponiamo che:

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

Come posso ottenere un valore (qualsiasi valore) ssenza farlo s.pop()? Voglio lasciare l'elemento nel set fino a quando non sono sicuro di poterlo rimuovere - qualcosa di cui posso essere sicuro solo dopo una chiamata asincrona a un altro host.

Veloce e sporco:

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

Ma conosci un modo migliore? Idealmente a tempo costante.

Due opzioni che non richiedono la copia dell'intero set:

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

O...

e = next(iter(s))

Ma in generale, i set non supportano l'indicizzazione o il slicing.

Il codice minimo sarebbe:

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

Ovviamente questo creerebbe un nuovo elenco che contiene ogni membro del set, quindi non eccezionale se il tuo set è molto grande.

Mi chiedevo come funzionassero le funzioni per diversi set, quindi ho fatto un benchmark:

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

Questo grafico mostra chiaramente che alcuni approcci ( RandomSample, SetUnpackinge ListIndex) dipende dalle dimensioni del set e dovrebbe essere evitata nel caso generale (almeno se la performance potrebbe essere importante). Come già mostrato dalle altre risposte, il modo più veloce è ForLoop.

Tuttavia, finché viene utilizzato uno degli approcci a tempo costante, la differenza di prestazioni sarà trascurabile.

iteration_utilities(Dichiarazione di non responsabilità: sono l'autore) contiene una funzione di praticità per questo caso d'uso first::

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

L'ho incluso anche nel benchmark sopra. Può competere con le altre due soluzioni "veloci", ma la differenza non è molto importante in entrambi i casi.

tl; dr

for first_item in muh_set: breakrimane l'approccio ottimale in Python 3.x. ^{Ti maledico, Guido.}

fai questo

Benvenuti in un altro set di timing Python 3.x, estrapolato da wr. 's eccellente risposta 2.x-specifica Python . A differenza della altrettanto utile risposta specifica di Python 3.x di AChampion , i tempi di seguito indicati sono anche soluzioni temporanee suggerite sopra, tra cui:

• list(s)[0], La nuova soluzione basata su sequenze di John .
• random.sample(s, 1), dF. la soluzione eclettica basata su RNG .

Snippet di codice per una grande gioia

Accendi, sintonizza, cronometra:

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

Tempi senza tempo rapidamente obsoleti

Ecco! Ordinato per frammenti dal più veloce al più lento:

$ ./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

Faceplants per tutta la famiglia

Non sorprende che l'iterazione manuale rimanga almeno due volte più veloce della soluzione più veloce successiva. Sebbene il divario sia diminuito dai giorni Bad Old Python 2.x (in cui l'iterazione manuale era almeno quattro volte più veloce), delude lo zelo di PEP 20 in me che la soluzione più prolissa è la migliore. Almeno convertire un set in un elenco solo per estrarre il primo elemento del set è orribile come previsto. Grazie a Guido, possa la sua luce continuare a guidarci.

Sorprendentemente, la soluzione basata su RNG è assolutamente orribile. La conversione della lista è cattiva, ma prende random davvero la torta con salsa terribile. Questo per quanto riguarda il Dio numero casuale .

Vorrei solo che gli amorfi avrebbero già elaborato un set.get_first()metodo per noi. Se stai leggendo questo, loro: "Per favore. Fai qualcosa."

Per fornire alcune cifre temporali alla base dei diversi approcci, considerare il seguente codice. Get () è la mia aggiunta personalizzata al setobject.c di Python, essendo solo un pop () senza rimuovere l'elemento.

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

L'output è:

$ ./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

Ciò significa che la soluzione for / break è la più veloce (a volte più veloce della soluzione get () personalizzata).

Poiché desideri un elemento casuale, funzionerà anche:

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

La documentazione non sembra menzionare le prestazioni di random.sample. Da un test empirico veramente veloce con una lista enorme e una serie enorme, sembra essere il tempo costante per una lista ma non per la serie. Inoltre, l'iterazione su un set non è casuale; l'ordine è indefinito ma prevedibile:

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

Se la casualità è importante e hai bisogno di un mucchio di elementi in tempo costante (set di grandi dimensioni), utilizzerei prima random.samplee convertirò in un elenco:

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

Apparentemente il modo più compatto (6 simboli) anche se molto lento per ottenere un elemento impostato (reso possibile da PEP 3132 ):

e,*_=s

Con Python 3.5+ puoi anche usare questa espressione di 7 simboli (grazie a PEP 448 ):

[*s][0]

Entrambe le opzioni sono circa 1000 volte più lente sulla mia macchina rispetto al metodo for-loop.

Uso una funzione di utilità che ho scritto. Il suo nome è in qualche modo fuorviante perché implica che potrebbe essere un oggetto casuale o qualcosa del genere.

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

A seguito di @wr. post, ottengo risultati simili (per 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()

Produzione:

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

Tuttavia, quando si cambia il set sottostante (es. Call to remove()) le cose vanno male per gli esempi iterabili ( 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()

Risultati in:

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

Quello che faccio di solito per le piccole raccolte è creare una specie di metodo parser / converter come questo

def convertSetToList(setName):
return list(setName)

Quindi posso utilizzare il nuovo elenco e accedere in base al numero indice

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

Come elenco avrai tutti gli altri metodi con cui potresti aver bisogno di lavorare

Che ne dici s.copy().pop()? Non l'ho cronometrato, ma dovrebbe funzionare ed è semplice. Funziona meglio per piccoli set, poiché copia l'intero set.

Un'altra opzione è quella di utilizzare un dizionario con valori che non ti interessano. Per esempio,

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

Puoi considerare le chiavi come un set, tranne per il fatto che sono solo un array:

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

Un effetto collaterale di questa scelta è che il codice sarà retrocompatibile con le setversioni precedenti di Python. Forse non è la risposta migliore ma è un'altra opzione.

Modifica: puoi persino fare qualcosa del genere per nascondere il fatto che hai usato un dict anziché un array o un set:

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