Как извлечь элемент из набора, не удаляя его?

Предположим следующее:

>>> 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. «S отлично Python 2.x-специфический ответ . В отличие от не менее полезного ответа AChampion на Python 3.x , приведенные ниже временные интервалы также предлагают решения, превышающие время, предложенные выше, включая:

• list(s)[0], Новое решение Джона на основе последовательностей .
• random.sample(s, 1), дф. Эклектичное решение на основе RNG .

Фрагменты кода для большой радости

Включите, настройте время:

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

Faceplants для всей семьи

Неудивительно, что итерация вручную остается как минимум вдвое быстрее, чем следующее быстрое решение. Несмотря на то, что разрыв сократился по сравнению с плохим старым Python 2.x днями (в которых ручная итерация была как минимум в четыре раза быстрее), меня разочаровывает фанат 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 символов), хотя и очень медленный способ получить элемент set (это стало возможным благодаря 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

Тем не менее, при изменении базового набора (например, call to 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. Возможно, это не лучший ответ, но это другой вариант.

Изменить: Вы можете даже сделать что-то вроде этого, чтобы скрыть тот факт, что вы использовали dict вместо массива или набора:

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