Why is there no first(iterable) built-in function in Python?

Solution 1:

In Python 2, if you have an iterator, you can just call its next method. Something like:

>>> (5*x for x in xrange(2,4)).next()
10

In Python 3, you can use the next built-in with an iterator:

>>> next(5*x for x in range(2,4))
10

Solution 2:

There's a Pypi package called “first” that does this:

>>> from first import first
>>> first([0, None, False, [], (), 42])
42

Here's how you would use to return the first odd number, for example:

>> first([2, 14, 7, 41, 53], key=lambda x: x % 2 == 1)
7

If you just want to return the first element from the iterator regardless of whether is true or not, do this:

>>> first([0, None, False, [], (), 42], key=lambda x: True)
0

It's a very small package: it only contains this function, it has no dependencies, and it works on Python 2 and 3. It's a single file, so you don't even have to install it to use it.

In fact, here's almost the entire source code (from version 2.0.1, by Hynek Schlawack, released under the MIT licence):

def first(iterable, default=None, key=None):
    if key is None:
        for el in iterable:
            if el:
                return el
    else:
        for el in iterable:
            if key(el):
                return el
    return default

Solution 3:

I asked a similar question recently (it got marked as a duplicate of this question by now). My concern also was that I'd liked to use built-ins only to solve the problem of finding the first true value of a generator. My own solution then was this:

x = next((v for v in (f(x) for x in a) if v), False)

For the example of finding the first regexp match (not the first matching pattern!) this would look like this:

patterns = [ r'\d+', r'\s+', r'\w+', r'.*' ]
text = 'abc'
firstMatch = next(
  (match for match in
    (re.match(pattern, text) for pattern in patterns)
   if match),
  False)

It does not evaluate the predicate twice (as you would have to do if just the pattern was returned) and it does not use hacks like locals in comprehensions.

But it has two generators nested where the logic would dictate to use just one. So a better solution would be nice.