如何从集合中检索元素而不删除它？

假设以下内容：

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

我也将其包含在上述基准中。它可以与其他两个“快速”解决方案竞争，但是两者之间的差异并不大。

tl; dr

for first_item in muh_set: break仍然是Python 3.x中的最佳方法。^{诅咒你，圭多。}

do这样做

欢迎使用从wr推断出来的另一组Python 3.x计时。出色的特定于Python 2.x的响应。与AChampion同样有用的特定于Python 3.x的响应不同，下面的时间安排还建议了上面提到的时间异常解决方案，包括：

• list(s)[0]，约翰的新颖的基于序列的解决方案。
• random.sample(s, 1)，dF。基于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

全家人的面部植物

毫不奇怪，手动迭代的速度至少是下一个最快解决方案的两倍。尽管与Bad Old Python 2.x相比（以前的手动迭代速度至少快四倍），差距有所减小，但PPE 20狂热者对我而言最冗长的解决方案是最好的解决方案感到失望。至少将一个集转换为一个列表以仅提取该集的第一个元素是预期的那样可怕。感谢Guido，愿他的光芒继续指导我们。

令人惊讶的是，基于RNG的解决方案绝对可怕。列表转换不好，但random 确实会带来糟糕的结果。对于随机数上帝来说如此之多。

我只是希望那些无定形set.get_first()的人已经为我们准备了一种方法。如果您正在阅读本文，他们：“请。做点什么。”

为了提供不同方法背后的一些时序图，请考虑以下代码。 get（）是我自定义添加到Python的setobject.c中，只是一个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]

这两种选择在我的机器上都比for循环方法慢大约1000倍。

我使用编写的实用程序函数。它的名称有点误导，因为它暗示它可能是随机物品或类似物品。

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