Get the first item in a sequence that matches a condition

Question

I've been trying to figure out what's the best, most Pythonic way to get the first element of a sequence that matches a condition. Here are three options:

1. I don't like that I've written caller[0].f_locals.get("runner") twice, but it feels most Pythonic otherwise.

   runner = next(
       caller[0].f_locals.get("runner")
       for caller in inspect.stack()
       if isinstance(caller[0].f_locals.get("runner"), AbstractRunner)
   )
   

2. Is it weird to rely on an assignment during the loop?

   for caller in inspect.stack():
       runner = caller[0].f_locals.get("runner")
       if isinstance(runner, AbstractRunner):
           break
   

3. The second line is Pythonic and all, but the first line is only there to set up a generator where you no longer have to compute the expression (only apply the conditional in the second line).

   generator = (caller[0].f_locals.get("runner") for caller in inspect.stack())
   runner = next(x for x in generator if isinstance(x, AbstractRunner))
   

There's no performance difference at all from my tests.

Answer 1

This is a use case for the walrus operator :=, which was introduced in Python 3.8. It allows you to write 1) without repeating yourself:

runner = next(
    r
    for caller in inspect.stack()
    if isinstance(r := caller[0].f_locals.get("runner"), AbstractRunner)
)

Whether or not you find this more readable or if this is too much nestedness in the if part is up to personal taste.

Answer 2

I have to be honest, I actually prefer option 3, and it's what I've used previously. It gives a clear separation of steps: "Produce the data, then filter it".

For a simpler case, I might go with @Graipher's suggestion. I have nothing against :=; I use it regularly. That last line of his in particular though is getting a bit noisy, and takes some processing to see what's going on.

Answer 3

You could also avoid your duplication with the single-value list idiom:

runner = next(
    runner
    for caller in inspect.stack()
    for runner in [caller[0].f_locals.get("runner")]
    if isinstance(runner, AbstractRunner)
)

Separates getting the runner from checking its type, works in older Python's as well, doesn't leak like the walrus does, and since 3.9, it's "as fast as a simple assignment".

Answer 4

I would vote against the walrus operator here; it's a clear case of doing two things at once.

Your original (#1) is probably good. I like that you're directly assigning the final value to its variable without preamble. If the repetition is really bugging you (or if the get function is expensive), then you could just nest generators

runner = next(
    r
    for r in (caller[0].f_locals.get("runner")
              for caller in inspect.stack())
    if isinstance(r, AbstractRunner)
)

or abandon comprehension-syntax

runner = next(filter(lambda r: isinstance(r, AbstractRunner),
                     map(lambda c: c[0].f_locals.get("runner"),
                         inspect.stack())))

Some people don't like lambdas; they're one of python's weak points. Unfortunately we hit several other weak points if we try to get rid of them: functools.partial won't work on isinstance (it takes positional args only, and we want to lock the second arg), and there's no built-in composition operator which is what we'd need for the map.

Really any of the repetitious comprehension, the nested comprehension, or the filter-&-map, or some hybrid, would be fine.