Bir öğeyi kaldırmadan bir gruptan nasıl alınır?

Varsayalım:

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

Yapmadan bir değeri (herhangi bir değeri) nasıl elde sedebilirim s.pop()? Kaldırabileceğimden emin olana kadar öğeyi sette bırakmak istiyorum - ancak başka bir ana bilgisayara eşzamansız bir çağrıdan sonra emin olabileceğim bir şey.

Hızlı ve kirli:

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

Ama daha iyi bir yol biliyor musun? İdeal olarak sabit zamanda.

Tüm seti kopyalamayı gerektirmeyen iki seçenek:

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

Veya...

e = next(iter(s))

Ancak genel olarak, kümeler dizin oluşturmayı veya dilimlemeyi desteklemez.

En az kod şöyle olurdu:

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

Açıkçası bu, kümenin her bir üyesini içeren yeni bir liste oluşturacaktır, bu nedenle kümeniz çok büyükse harika değil.

İşlevlerin farklı setler için nasıl performans göstereceğini merak ettim, bu yüzden bir kıyaslama yaptım:

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

Bu arsa açıkça bazı yaklaşımlar olduğunu gösterir ( RandomSample, SetUnpackingve ListIndex) setin büyüklüğüne bağlıdır ve (en azından performans eğer genel durumda kaçınılmalıdır olabilir önemli). Zaten diğer cevaplar tarafından gösterildiği gibi en hızlı yoludur ForLoop.

Ancak, sabit zaman yaklaşımlarından biri kullanıldığı sürece performans farkı göz ardı edilebilir.

iteration_utilities(Feragatname: Yazarım) bu kullanım durumu için bir kolaylık işlevi içerir first:

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

Ben de yukarıdaki karşılaştırmaya dahil ettim. Diğer iki "hızlı" çözümle rekabet edebilir, ancak fark her iki şekilde de fazla değildir.

tl; Dr.

for first_item in muh_set: breakPython 3.x'te optimum yaklaşım olmaya devam ediyor. ^{Lanet olsun, Guido.}

bunu yap

Wr'den çıkarılan başka bir Python 3.x zamanlama setine hoş geldiniz . 'ın mükemmel Python 2.x'e özel yanıtı . Aksine AChampion 'eşit yardımcı s Python 3.x özgü tepki , zamanlama aşağıda ayrıca yukarıda önerilen çözümlerin uç değer süresi dahil olmak üzere -:

• list(s)[0], John'un yeni dizi tabanlı çözümü .
• random.sample(s, 1), dF. 'nin eklektik RNG tabanlı çözümü .

Büyük Sevinç için Kod Parçacıkları

Açın, ayarlayın, zamanlayın:

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

Hızla Eskimiş Zamansız Zamanlamalar

Seyretmek! En hızlıdan en yavaş snippet'lere göre sıralanır:

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

Tüm Aile İçin Faceplantlar

Şaşırtıcı olmayan bir şekilde, manuel yineleme bir sonraki en hızlı çözümün en az iki katı kadar hızlı kalır . Boşluk Bad Old Python 2.x günlerinden (manuel yinelemenin en az dört kat daha hızlı olduğu) azalmasına rağmen, içimdeki PEP 20 zealotunu en ayrıntılı çözümün en iyi olduğu konusunda hayal kırıklığına uğrattı . En azından bir seti sadece setin ilk elemanını çıkarmak için bir listeye dönüştürmek beklendiği kadar korkunçtur. Teşekkürler Guido, ışığı bize rehberlik etmeye devam etsin.

Şaşırtıcı bir şekilde, RNG tabanlı çözüm kesinlikle korkunç. Liste dönüşüm kötü, ama random gerçekten korkunç soslu kek alır. Rastgele Sayı Tanrı için çok fazla .

Ben sadece amorf diliyorum set.get_first()Bizim için zaten bir yöntem PEP olurdu . Bunu okuyorsanız, Onlar: "Lütfen. Bir şeyler yapın."

Farklı yaklaşımların arkasında bazı zamanlama rakamları sağlamak için aşağıdaki kodu göz önünde bulundurun. Get (), öğeyi kaldırmadan sadece bir pop () olan Python'un setobject.c'sine yaptığım özel eklentidir.

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

Çıktı:

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

Bu, for / break çözümünün en hızlı (bazen özel get () çözümünden daha hızlı) olduğu anlamına gelir .

Rastgele bir öğe istediğiniz için, bu da işe yarayacaktır:

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

Belgeler performansından bahsetmiyor gibi görünüyor random.sample. Büyük bir liste ve büyük bir set ile gerçekten hızlı bir ampirik testten, bir liste için sabit bir zaman gibi görünüyor, ancak set için değil. Ayrıca, bir kümedeki yineleme rastgele değildir; sipariş tanımsız ancak öngörülebilir:

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

Rasgelelik önemliyse ve sabit zamanda (büyük setler) bir grup öğeye ihtiyacınız varsa, önce random.samplebir listeye dönüştürürüm:

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

Görünüşte en kompakt (6 sembol) bir set elemanı elde etmek için çok yavaş bir yol olsa da ( PEP 3132 ile mümkün kılındı ):

e,*_=s

Python 3.5+ ile bu 7 sembollü ifadeyi de kullanabilirsiniz ( PEP 448 sayesinde ):

[*s][0]

Her iki seçenek de makinemde for-loop yönteminden yaklaşık 1000 kat daha yavaş.

Yazdığım bir yardımcı program işlevi kullanıyorum. Adı biraz yanıltıcıdır çünkü rastgele bir öğe veya bunun gibi bir şey olabileceğini ima eder.

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

@Wr. sonrası, benzer sonuçlar alıyorum (Python3.5 için)

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

Çıktı:

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

Bununla birlikte, temel kümeyi değiştirirken (örn. Çağırma remove()), yinelenebilir örnekler ( for, iter) için işler kötü gider :

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

Sonuçlar:

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

Genellikle küçük koleksiyonlar için yaptığım şey, böyle bir ayrıştırıcı / dönüştürücü yöntemi oluşturmaktır

def convertSetToList(setName):
return list(setName)

Sonra yeni listeyi kullanabilir ve dizin numarasına göre erişebilirim

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

Liste olarak çalışmak için ihtiyaç duyabileceğiniz diğer tüm yöntemlere sahip olacaksınız.

Nasıl s.copy().pop()? Zamanlamadım, ama işe yaramalı ve basit. Bununla birlikte, tüm seti kopyaladığı için küçük setler için en iyi sonucu verir.

Başka bir seçenek, umursadığınız değerlere sahip bir sözlük kullanmaktır. Örneğin,

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

Anahtarlara yalnızca bir dizi olmaları dışında bir küme olarak davranabilirsiniz:

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

Bu seçimin bir yan etkisi, kodunuzun eski setPython ön sürümleriyle geriye dönük olarak uyumlu olmasıdır . Belki de en iyi cevap değil ama başka bir seçenek.

Düzenleme: Hatta bir dizi veya küme yerine bir dikte kullandığınız gerçeğini gizlemek için böyle bir şey yapabilirsiniz:

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