Як отримати елемент із набору, не виймаючи його?

Припустимо наступне:

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

Як я можу отримати значення (будь-яке значення), sне виконуючи це s.pop()? Я хочу залишити елемент у наборі до тих пір, поки не буду впевнений, що зможу його видалити - у чому я можу бути впевнений лише після асинхронного дзвінка іншому хосту.

Швидкий і брудний:

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

Але чи знаєте ви кращого способу? Ідеально в постійний час.

Два варіанти, які не потребують копіювання всього набору:

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

Або ...

e = next(iter(s))

Але в цілому набори не підтримують індексацію або нарізку.

Найменший код буде:

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

Очевидно, це створило б новий список, який містить кожного члена набору, тому не чудово, якщо ваш набір дуже великий.

Мені було цікаво, як будуть виконувати функції для різних наборів, тому я зробив орієнтир:

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

Цей сюжет ясно показує , що деякі підходи ( RandomSample, SetUnpackingі ListIndex) залежить від розміру набору і його слід уникати в загальному випадку (принаймні , якщо продуктивність може бути важлива). Як уже показано в інших відповідях, найшвидший спосіб ForLoop.

Однак доки застосовується один із постійних підходів до часу, різниця в продуктивності буде незначною.

iteration_utilities(Відмова: я автор) містить функцію зручності для цього випадку використання first::

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

Я також включив його до еталону вище. Він може конкурувати з іншими двома "швидкими" рішеннями, але різниця не в великій мірі.

тл; д-р

for first_item in muh_set: breakзалишається оптимальним підходом у Python 3.x. ^{Прокляни тебе, Гвідо.}

ти це зробиш

Ласкаво просимо до ще одного набору синхронізацій Python 3.x, екстрапольованого з wr. відмінна відповідь Python 2.x-специфічна . На відміну від не менш корисної для конкретного відповіді Python 3.x для AChampion , наведені нижче терміни також пропонують рішення, що пропонуються вище, включаючи:

• list(s)[0], Рішення Джона в новій послідовності .
• random.sample(s, 1), dF. Еклектичне рішення на основі РНГ .

Кодові фрагменти для великої радості

Увімкніть, налаштуйте, час:

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

Швидко застарілі позачасові таймінги

Ось! Упорядковано найшвидшими та найповільнішими фрагментами:

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

Лицьові рослини для всієї родини

Не дивно, що ручна ітерація залишається принаймні удвічі швидшою, ніж наступне найшвидше рішення. Хоча розрив зменшився від Bad Old Python за двадцять днів (коли ручна ітерація була принаймні у чотири рази швидшою), це розчаровує в мене ревника PEP 20 тим, що найголовніше рішення є найкращим. Принаймні перетворення набору в список лише для вилучення першого елемента набору є таким же жахливим, як і очікувалося. Дякую Гуйдо, нехай його світло продовжує нас керувати.

Дивно, але рішення, що базується на СПГ, абсолютно жахливе. Перетворення списків погано, але random насправді приймає жахливий торт-соус. Стільки за Бога випадкового числа .

Я просто бажаю аморфним. Вони б вже підготували set.get_first()метод для нас. Якщо ви читаєте це, вони: "Будь ласка. Робіть щось".

Щоб забезпечити деякі показники часу, що стоять за різними підходами, врахуйте наступний код. Get () - моє спеціальне доповнення до setobject.c Python, будучи просто pop (), не виймаючи елемент.

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

Вихід:

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

Це означає, що рішення for / break є найшвидшим (іноді швидшим, ніж спеціальне рішення get ()).

Оскільки ви хочете випадковий елемент, це також буде працювати:

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

Документація, схоже, не згадує показники роботи random.sample. З дійсно швидкого емпіричного тесту з величезним списком і величезним набором, здається, що це постійний час для списку, але не для набору. Крім того, ітерація над набором не є випадковою; замовлення не визначено, але передбачувано:

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

Якщо випадковість важлива і вам потрібна купа елементів за постійний час (великі набори), я спочатку використовую random.sampleта перетворюю на список:

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

Здавалося б , що найбільш компактні (6 символів) , хоча дуже повільний спосіб отримати безліч елементів ( що стало можливим завдяки PEP 3132 ):

e,*_=s

За допомогою Python 3.5+ ви також можете використовувати цей вираз із 7 символів (завдяки PEP 448 ):

[*s][0]

Обидва варіанти на моїй машині приблизно в 1000 разів повільніше, ніж метод for-loop.

Я використовую функцію утиліти, яку я написав. Його назва дещо вводить в оману, оскільки з цього виду випливає, що це може бути випадковий предмет або щось подібне.

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

Читає @wr. повідомлення, я отримую подібні результати (для 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()

Вихід:

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

Однак при зміні базового набору (наприклад, заклик до remove()) речі йдуть погано на приклади ітерабельного ( 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()

Призводить до:

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

Що я зазвичай роблю для невеликих колекцій, це створити такий метод аналізатора / перетворювача, як цей

def convertSetToList(setName):
return list(setName)

Тоді я можу використовувати новий список та отримати доступ за номером індексу

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

У списку у вас будуть всі інші методи, з якими вам може знадобитися працювати

Як щодо s.copy().pop()? Я ще не приурочила його, але це має працювати і це просто. Однак він найкраще працює для невеликих наборів, оскільки копіює весь набір.

Інший варіант - використовувати словник зі значеннями, які вас не цікавлять. Наприклад,

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

Ви можете ставитися до ключів як до набору, за винятком того, що вони є лише масивом:

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

Побічним ефектом цього вибору є те, що ваш код буде сумісним із старими попередніми setверсіями Python. Це, можливо, не найкраща відповідь, але це інший варіант.

Редагувати: Ви навіть можете зробити щось подібне, щоб приховати факт, що ви використовували дикт замість масиву чи набору:

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