# python – How to retrieve an element from a set without removing it?

## python – How to retrieve an element from a set without removing it?

Two options that dont require copying the whole set:

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

Or…

```
e = next(iter(s))
```

But in general, sets dont support indexing or slicing.

Least code would be:

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

Obviously this would create a new list which contains each member of the set, so not great if your set is very large.

#### python – How to retrieve an element from a set without removing it?

I wondered how the functions will perform for different sets, so I did a 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()
```

This plot clearly shows that some approaches (`RandomSample`

, `SetUnpacking`

and `ListIndex`

) depend on the size of the set and should be avoided in the general case (at least if performance *might* be important). As already shown by the other answers the fastest way is `ForLoop`

.

However as long as one of the constant time approaches is used the performance difference will be negligible.

`iteration_utilities`

(Disclaimer: Im the author) contains a convenience function for this use-case: `first`

:

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

I also included it in the benchmark above. It can compete with the other two fast solutions but the difference isnt much either way.