Python: Else statement with 2 for loops

Question

I am searching for the pythonic way to do the following:

I have a list of keys and a list of objects.

For any key, something should be done with the first object that fits to that key.

If no object fits to no key, so nothing has be done at all, something different should be done instead.

I implemented this as follows and it is working properly:

didSomething = False
for key in keys:
    for obj in objects:
        if <obj fits to key>:
            doSomething(obj, key)
            didSomething = True
            break
if not didSomething:
    doSomethingDifferent()

But normally, if there is only one for-loop, you don't need such a temporary boolean to check whether something has been done or not. You can use a for-else statement instead. But this does not work with 2 for-loops, did it?

I have the feeling that there should be some better way to do this but i don't get it. Do you have any ideas or is there no improvement?

Thank you :)

Answer 1

This doesn't really fit into the for/else paradigm, because you don't want to break the outer loop. So just use a variable to track whether something was done, as in your original code.

Instead of the second loop, use a single expression that finds the first matching object. See Python: Find in list for ways to do this.

didSomething = false
for key in keys:
    found = next((obj for obj in objects if <obj fits to key>), None)
    if found:
        doSomething(found, key)
        didSomething = true
if not didSomething:
    doSomethingDifferent()

Answer 2

Whenever you find yourself needing to break out of a nested loop, it’s usually hard to think through the details, and when you finish figuring it out, the answer is usually just that it’s impossible (or at least only possible with an explicit flag variable or an exception or something else that obscures your logic).

There's an easy answer to that (which I'll include below in case anyone finding this question by search has that problem), but that's not actually your problem. What you want to check is not "did I complete the loop normally", because you always complete the loop normally. What you want to check is "did I do something (in this case, call doSomething) one or more times".

That isn't really about the outer loop, unlike breaking out of the outer loop (which obviously is), so there's no syntax for it. You need to keep track of whether you did something one or more times, and the way you're already doing that is probably the simplest way.

---

In some cases, you can rearrange things to flatten or invert the loop, so you end up doing one thing with all of the currently-outer values one time and breaking out of that loop, in which case it is about looping again. But if that twists your logic up so much that it's no longer clear what's going on, that's not going to be an improvement. For example:

fits = set()
for key in keys:
    for obj in objects:
        if <obj fits to key>:
            fits.add((obj, key))
for obj, key in fits:
    do_something(obj, key)
if not fits:
    do_something_else()

This can be simplified:

fits = {(obj, key) for key in keys for obj in objects if <obj fits to key>}
for obj, key in fits:
    do_something(obj, key)
if not fits:
    do_something_else()

But, either way, notice that the way I avoided storing a flag saying whether you ever found a fit was by storing a set of all of the fits you found. For some problems, that's an improvement. But if that set could be very large, it's a terrible idea. And if that set just conceptually doesn't mean anything in your problem, it might obscure the logic instead of simplifying it.

---

If your problem were breaking out of a nested loop (which it isn't, but, again, it might be for someone else who finds this question by search), there’s always an easy answer to that: just take the whole nest of loops and refactor it into a function. Then you can break out at any level by just using return. If you didn’t return anywhere, the code after the loops will get run, while if you did return, it will—just like an else.

So:

def fits():
    for key in keys:
        for obj in objects:
            if <obj fits to key>:
                doSomething(obj, key)
                return
    doSomethingDifferent()

fits()

I’m not sure whether breaking out if both loops is what you want. If it is, this does exactly what you want. If not, it doesn’t, but then I’m not sure what semantics you were looking for with the else–when it should get run—so I don’t know how to explain how to do that.

Once you’ve done this, you may find the abstraction generalizes to more than use in your code, so you can turn the function into something that takes parameters instead of using closure or global variables, and that returns a value or raises instead of calling one of two functions, and so on. But sometimes, this trivial local function is all you need.

Answer 3

There's no real way to simplify your code. It is, however, kind of confusing the way it's written. I would actually make it more verbose to make sure it's read properly:

def fit_objects_to_keys(objects, keys):
    for key in keys:
        for obj in objects:
            if <obj fits to key>:
                yield obj, key
                break

none_fit = True

for obj, key in fit_objects_to_keys(keys, objects):
    doSomething(obj, key)
    none_fit = False

if none_fit:
    doSomethingDifferent()

You may be able to simplify it further if you explain what <obj fits to key> actually does.

Answer 4

I agree with the comment that your code is fine as it is - but if you must flatten multiple for-loops into one (so that you can use the 'else' feature, for example, or the number of for-loops is itself variable), this is actually possible:

import itertools
for key, obj in itertools.product(keys, objects):
    if <obj fits to key>:
        doSomething(obj, key)
        break
else:
    doSomethingDifferent()