Python’s For - Else

http://book.pythontips.com/en/latest/for_-_else.html

by federicoponzi • 8 years ago

469 242 8 years ago

book.pythontips.com

kbumsik2• 8 years ago

It is worth noting that the else clause can also be used with while loops.

[1] https://docs.python.org/3.6/reference/compound_stmts.html#wh...

kasbah2• 8 years ago

Seems a bit useless since

    while x < 2:
        ...
    else: 
        print('>= 2')

is the same as

    while x < 2:
        ... 
    print('>= 2')

unless you use a break. Just seems unnecessarily confusing to me. I have used for ... else though.

znpy• 8 years ago

I think that the subtle difference is that in the second example "print('>= 2')" is always executed whereas in the first example the print statements is executed only if no break was executed in the while loop.

Quoting documentation: "A break statement executed in the first suite terminates the loop without executing the else clause’s suite."

jwilk• 8 years ago

But... for+else without break can be rewritten the same way. And yet you claim that you've used for+else.

But indeed, in my experience, while+else are much less common that for+else. I'm not sure why.

ubernostrum• 8 years ago

And the full form of a Python exception handling block is not try/except/finally. It's try/except/else/finally.

The 'try' block contains code which might raise an exception.

It can be followed by zero or more 'except' blocks, each of which indicates the type(s) of exception it will catch and contains code to execute in the event of that type of exception.

The 'except' block(s) can be followed by one 'else' block, which contains code to execute in the event no exception was raised by the code in the 'try' block.

And then there is optionally a 'finally' block, containing code that must be executed in all circumstances.

grosjona• 8 years ago

I hate it when code uses weird niche features that are not obvious, are impossible to look up and add 0 value aside from saving a couple of lines of code.

jkaplowitz• 8 years ago

Me too, but this use case seems clearer than most features I'd label that way, even though I didn't know about it either.

It certainly shouldn't be used when unclear, just like any feature. There's no reason this feature's sensible use cases should be as niche as they currently are.

deathanatos• 8 years ago

are impossible to look up

Questions about Python's syntax are anything but impossible to look up. Python has excellent documentation around this, and the steps to get to the right part of the documentation are pretty straight-forward:

1. Start at the main page, https://docs.python.org/

2. Click "Language Reference"; note the subtitle that clearly hints this is what we want: "describes syntax and language elements"

3. We are interested in for loops, so we click "8.3. The for statement"; the resulting page describes the behavior.

XorNot• 8 years ago

Agreed. The way this ends up looking is absolutely unclear what it does - and seems like more a quirk then a feature.

vortico• 8 years ago

[Mistake, a moderator please delete this comment! Completely agree with the parent comment now. for...else is dumb and unintuitive. I misunderstood its function, which proves the above point to me.]

Izkata• 8 years ago

The symantics of for...else are immediately obvious

The code in your example is how it reads, but that's not how it works. The "obvious" reading is wrong, so it's obviously not "immediately obvious".

This is what it's actually doing:

  found = False
  for l in get_list():
    if ...:
      found = True
      break
  if not found:
    ...

reificator4• 8 years ago

I think it's worth keeping the comment around for that exact reason. It underscores that the concept really is confusing and mislabeled.

marban• 8 years ago

Now I feel like I have to rewrite every single Python script I ever wrote.

vesinisa• 8 years ago

Please don't bother. Obscure, very rarely used language constructs like these often don't really enhance the code's maintainability. On the contrary; would you have understood the very same code yourself before reading this article if someone else had used the construct?

AlphaSite• 8 years ago

I think if you read it, you'd read it and get it.

Walkman• 8 years ago

not really a good idea

fratlas3• 8 years ago

I'm in favour of writing simple python that even a junior dev can read rather than using niche syntax tricks. Guess that depends on whether you think a junior should know this syntax.

ben0x539• 8 years ago

This is a weird response. You can definitely argue that it's bad syntactic design because people seem to expect it to do something different, but if the argument is just that some category of programmer doesn't already know what it does, you're pretty much arguing against introducing any new language feature, syntax or library that wasn't taught in your imagined CS101 or whatever.

fratlas3• 8 years ago

I agree with your point, but I meant that I haven't seen this specific syntax in many py tutorials or projects I've read.

ben509• 8 years ago

you're pretty much arguing against introducing any new language feature, syntax or library that wasn't taught in your imagined CS101 or whatever.

But there clearly is a body of knowledge which you can discover yourself: you can interview candidates, read discussions on SO, read library code, and you will find some techniques are commonly used, and some are rarely used.

That distribution of what's known is changing over time regardless of what we do, because our peers are constantly learning and studying at different rates.

This feature has been around for years, and is so rarely used that only language mavens know about it. Thus, you can observe that this is a failed feature and avoid using it.

We can always reevaluate if people understand it later on, since that could change.

jacobolus2• 8 years ago

This has long (always?) been a basic part of the Python language. How do you decide what is a “niche syntax trick”?

Here’s the python language reference from python version 1.4 (1996), http://web.archive.org/web/19970606191447/http://www.python....

The expression list is evaluated once; it should yield a sequence. The suite is then executed once for each item in the sequence, in the order of ascending indices. Each item in turn is assigned to the target list using the standard rules for assignments, and then the suite is executed. When the items are exhausted (which is immediately when the sequence is empty), the suite in the else clause, if present, is executed, and the loop terminates.
A break statement executed in the first suite terminates the loop without executing the else clause's suite. A continue statement executed in the first suite skips the rest of the suite and continues with the next item, or with the else clause if there was no next item.

* * *

Here’s the tutorial, http://web.archive.org/web/19970606183615/http://www.python....

The break statement, like in C, breaks out of the smallest enclosing for or while loop.
The continue statement, also borrowed from C, continues with the next iteration of the loop.
Loop statements may have an else clause; it is executed when the loop terminates through exhaustion of the list (with for) or when the condition becomes false (with while), but not when the loop is terminated by a break statement. [... and then an example ...]

fratlas3• 8 years ago

My point was more towards benwilber0's comment; not a lot of usage in code I've seen.

daveFNbuck• 8 years ago

How do you decide what is a “niche syntax trick”?

You decide with experience. When other people read my code, this is probably the feature that surprises them most. Other features that they haven't seen before usually make sense from context. This one is surprising enough that I often forget whether it executes if there is a break or if there isn't a break.

When explaining and remembering what the syntax means dwarfs the effort saved by using the syntax, it's a niche syntax trick.

ageofwant• 8 years ago

The `else` clause follows the same general pattern wherever it supported: `for`, `while` and `try` are consistent. It usually makes code shorter or at least leads to narrowing concerns when used with `try`.

For some reason I often forget to use it though.

contravariant8• 8 years ago

Oh, that didn't do what I expected at all.

I was expecting this to be similar to:

    if list: for x in list:
       # Some code
    else:
       # else clause

which would have been quite useful to have for general iterators. But apparently it's a statement that triggers unless you use 'break' to end the loop, which just seems like a really weird use case, and smells like a goto.

LolWolf• 8 years ago

This is usually quite useful, actually! It happens a lot in numerical computing where you try a bunch of possible solutions and if none are found then you output some sort of "infeasibility" result, otherwise you output the result you broke at (skipping the else statement).

contravariant8• 8 years ago

Putting the loop in its own function would solve the problem as well (allowing you to just return the output), or if that's not an option then you need to store the output anyway so you might as well just add a check 'if output is None:'.

jackewiehose• 8 years ago

which just seems like a really weird use case

I think quite the opposite: What you expected seems unnecessary to me because that is already easy to do with that if-statement in your example.

On the other hand, to accomplish this "for-else" you would have to do something like this:

    found = false
    for x in list:
        if ...:
           found = true
    if not found:
       ...

While writing this example I noticed that I also could make good use of the negativ: Something like

    for x in list:
        ...
    then:
        ...

contravariant8• 8 years ago

To achieve the for else I suggested for general generators requires a similar pattern to your suggestion so both of them save equal amounts of complexity.

However I'm struggling to find a use case for the python for-else definition where you don't end up doing something like 'result=something; break' anyway. What would be the point of breaking if you don't have any results? And if you have such a situation, wouldn't an exception make more sense?

Conversely to check if an iterator is non-empty you need to set a boolean to true, and you can't easily skip this part so you end up setting it to true every loop. It would have been quite nice to have an 'else' condition that triggers when the generator is empty (which also fits quite nicely with all empty containers being considered falsy).

xiaq2• 8 years ago

It is useful when the "normal" flow is to terminate the loop early with a break. For instance, in a linear search algorithm:

    for x in li:
      if x == to_find:
        print("found")
        break
    else:
      print("not found")

Logically, the "else" matches with the "if" introducing the "break" and means "if none of elements cause the break branch to be taken".

sooheon3• 8 years ago

It's a special case that matches `else` with `if` at the wrong level of indentation. Seems a lot like faux-simplicity, like a lot of Python: it seems simple and "pythonic" superficially, but really forces the coder to learn special cases.

contravariant8• 8 years ago

Yeah I get that it can be useful, but I just don't like ending a loop in two different ways. It just seems too easy to end up writing something like:

    for x in sorted_list:
        if x == to_find:
            print("found")
            break # we've found a match
        elif to_find > x:
            break # match is not possible
    else:
        print("not found)

shawnz3• 8 years ago

and smells like a goto.

What about while/break, for/break, try/except, etc doesn't "smell like a goto"? Isn't that the whole point of these sophisticated constructs, to serve as more rigorous replacements for "goto"?

contravariant8• 8 years ago

Sure, and break/continue etc. should be discouraged for that precise reason. I don't quite see try/except/finally as a goto, since I'm not sure how to make one that behaves that way.

However IMO the best 'rigorous' model of programs is maintaining pre and post conditions. Escaping early when the post-condition is satisfied is compatible with this model (like with e.g. return/break/continue). Escaping in two different ways is not.

If you really need to handle exceptional cases where you need to escape a loop differently then exceptions are the better option IMHO, these also have a fairly rigorous definition in terms of Monads. Obviously if actual Monads (which in the case of python would be containers / generators) are an option they should be preferred.

userbinator• 8 years ago

which just seems like a really weird use case, and smells like a goto.

That's exactly what it's for. In C, this is a pretty common pattern:

      for( ... )
        if( ... )
          goto found;
      /* else not found */
      ...
    found:
      ...

I remember when I had to use a bit of Python and lamented its lack of goto, then came across this "else loop" and thought "yes, they even thought of that."

benwilber0• 8 years ago

I hate adding syntax but you know what's really useful? Django's `for .. empty` template syntax.

I would like to see this in Python:

  for i in []:
    print(i)
  empty:
    print("Sequence was empty!")

askvictor3• 8 years ago

Write up a PEP! It's a great idea. Syntax can be good if it makes sense and makes code easier to read and write.

mixmastamyk4• 8 years ago

Won't be accepted. Recognized as a problem, but now set in stone.

maccam94• 8 years ago

Except the python "for/else" executes regardless of whether there's a sequence. I've used it before for retry logic, but it confuses the heck out of people.

Nition3• 8 years ago

I think the user you're replying to is just saying that a for...empty would be nice too.

rad_gruchalski• 8 years ago

Pretty convenient feature.

jordansmithnz2• 8 years ago

To me, the else isn’t intuitive if you haven’t encountered it before. It’s a nice feature, but perhaps better naming could improve code readability.

How about for-finally? It’s a hard thing to name correctly, but to me this seems to be slightly more intuitive if you’ve never seen the feature before.

detaro2• 8 years ago

Finally would suggest it's always executed, even if aborted, like try...finally

makecheck2• 8 years ago

You can’t use "finally" because that implies an expression that runs regardless, which this does not (it only runs if the loop never breaks).

jordansmithnz2• 8 years ago

Yeah, that’s a good point. To me it’s a little more clear than ‘else’ but there might be a better name still that doesn’t suggest this code always runs. Naming is hard :)

SamReidHughes4• 8 years ago

Since Python doesn't have goto statements, this removes one of the situations where a goto statement is the best tool to use in a language like C++.

xapata• 8 years ago

In a sense, raise/except is a goto.

Go-lang decided against exceptions in part because they are equivalent to gotos.

zephyrfalcon2• 8 years ago

But Go does have a goto statement...?

askvictor3• 8 years ago

The word else implies something different to what it does (IMHO at least). In and if/else clause, the else happens when the primary/expected thing doesn't happen. I would expect that for a loop, an else clause would happen when the loop does _not_ finish normally, or if they loop is empty. I'm sure it's a useful clause in certain cases, but the meaning of the word used is reversed. It might be better use 'then' or something like that:

  for i in l:
     print(i)
  then:
     print("iteration finished without breaking")

jacobolus2• 8 years ago

They probably used the word "else" to cut down on the number of reserved keywords, and for consistency with try / except / else.

kazinator4• 8 years ago

It is consistent with the idea that it provides an alternative clause to a failing loop guard.

Using the much clearer C syntax as pseudo-code, suppose we have this:

  for (;;) {
    if (loop_guard()) {
      body;
    } else {
      alternative;
      break;
    }
  }

We can imagine an extension to while which lets us rewrite it like this:

  while (loop_guard()) {
    body;
  } else {
    alternative;
  }

Based on this framing, there is justification in calling it else.

The runs counter to an intuition which would like it to be this:

   if (loop_guard()) {
     while (loop_guard()) {
       body;
     }
   } else {
     alternative;
   }

I.e. not an alternative in the face of the failed loop guard on every iteration, but just the first loop guard test: an alternative to the loop when no iterations take place.

rlayton2• 8 years ago

I'm a strong python advocate and rarely use for/else for this exact reason. It makes more sense to me for it to be the other way (your way) around. I always add a comment on the else when I do too, to ensure that future readers don't make the same mistake.

bjd2385• 8 years ago

I agree. It's seldom something I've used in my scripts/small projects for this exact reason.

It should also be noted that there is a `while-else` compound statement as well, wherein using a `break` immediately exits the loop, without executing the `else` clause [1].

[1] https://docs.python.org/3/reference/compound_stmts.html#the-...

kchr2• 8 years ago

Yeah, it really feels (almost in a physical sense) like an anti-pattern... I have to force my fingers to write it.

joelcornett• 8 years ago

I’ve never found a compelling reason to use this construct (or the analogous `while...else` construct). But then again, I rarely find myself using `else` with `if` either...

shawnz3• 8 years ago

It makes sense to me in the specific context of using it to respond to an item not being found in a list. In other contexts, I agree that the word is not a good fit.

georgyo3• 8 years ago

The else makes perfect sense. The for loop keeps going as long as the condition is true. When the condition is false, it exits the loop without breaking. Else acts on the condition being false.

Nition3• 8 years ago

But the else fires in Python if the loop does not break. It sounds like you're saying the opposite. Even if you aren't, I think we can agree it's potentially confusing.

Myrmornis2• 8 years ago

What you say implies that you’d be happy with

  while(condition()):
      ...
  else:
      ...

But that makes even less sense since `while` is semantically like an `if` with continuation. GP is right, it’s rarely used, because the syntax clashes with the natural reading of the code.

mlthoughts20184• 8 years ago

I don’t like this feature of Python, but I have come to disagree with what you mention, even though I understand your point.

For example, from [0], it’s described as:

“The else clause is only executed when your while condition becomes false. If you break out of the loop, or if an exception is raised, it won't be executed.”

So it is very analogous to an if / else statement: the “else” after a for or while loop directly means the conditional of the loop evaluated to False.

If the program never reaches a state in which the loop conditional evaluates to False, then the else block is not entered.

Just like: only when the conditional of an if statement evaluates to False will the else block be entered.

After I understood this, I started to think that break is really the more problematic thing, because it means more like a goto sort of jump, abandoning the status of the variables governing the loop condition.

But again, I don’t like these loop-else features. They definitely violate least surprise for most people reading the code.

[0]: < https://stackoverflow.com/questions/3295938/else-clause-on-p... >

thaumasiotes3• 8 years ago

So it is very analogous to an if / else statement: the “else” after a for or while loop directly means the conditional of the loop evaluated to False.

...how is that supposed to apply to "for i in l"? What is the conditional?

I don't think of python for statements as involving conditionals at all; you seem to be describing a while/else rather than a for/else.

reificator4• 8 years ago

If python used C style loops rather than pushing iterators/generators so hard, I would buy that reasoning. But where's the conditional statement in `for i in range(0,10)`?

Now, clearly there is a check to see if it's still producing values. But it's intentionally hidden from a surface-level reading of the code.

Naming a control structure `else` when it intentionally does not have a clear conditional tied to it is odd to say the least.

But it's worse than that- the else clause is supposed to be the normal flow of the program. Programming introductions (fresh in the minds of many who use Python as it's targeted as user-friendly) often stress the fact that in an if/else statement only one or the other block is executed. But this flips that idea upside-down.

SamReidHughes4• 8 years ago

I don't think it violates any important least-surprise principle. You might be surprised to see it used -- but you don't get surprised when the code behaves how the documentation says it will.

yk• 8 years ago

When I thought about this, I first agreed, then I thought that from the perspective of the interpreter it is else as in checks the condition and then goes to else if the condition is false. So I think it is not so much unintuitive, as it is consistent in a not immediately intuitive way.

sound1• 8 years ago

Agree completely. I think for-else is same as if-else in that if the condition satisfies then it executes the main loop and if not it executes the 'else'.

logicallee• 8 years ago

I like it! Makes perfect sense, it's short, and since then "belongs to" the for, it makes sense for a break or exception to break out of both. On the other hand, under your suggestion someone still has to learn the meaning of then, it's not fully explicit. Since "Explicit is better than Implicit", if we are not optimizing for brevity I have these two suggestions that are more explicit alternatives to your then suggestion.

--------

Suggestion 1 (horrific suggestion):

Call this keyword finally. This implies that no matter what the finally part will execute. This is like defining never as a synonym for true, so that if(never) always executes. Why would anyone ever do that!! Hardly any choice in a design is as bad as explicitly saying something different from what will happen. So this is a terrible suggestion.

--------

Suggestion 2 (good suggestion):

Call this keyword ifthru. (Thru being an abbreviation for through). As it says, this one will run if the loop completed. Another way to read it is if execution continued "through" the end.

So your example might read:

  for i in l:
     print(i)
  ifthru:
     print("iteration finished without breaking or exceptions")

This is extremely explicit about the condition. I picked it to be short while remaining explicit. The elif keyword is an existing precedent for mispelling for the sake of brevity.

It also alerts the reader that logically there is a condition here. After all, semantically every block could start with the "then" word in English. Semantically, when you break you could also be considered to be "through" however in this case the ifthru keyword wouldn't serve any purpose at all, since it could just be on the next line. The "if" alerts the reader that there's a condition here..

I hope you'll agree that my second suggestion is pretty good :)

p1necone• 8 years ago

Fwiw my initial assumption (as a non python dev) was that the else statement would execute once the loop condition was false (including the case where loop condition was never true).

zephyrfalcon2• 8 years ago

I agree that the word 'else' is confusing here. To me, it suggests that one thing is done, or the other, but not both. Python's try..except..else follows this pattern, but for..else and while..else do not, for some reason.

ehsankia• 8 years ago

Every time I go to use for...else, I need to look up what the behavior is, I can never remember if it's hitting the break or not hitting the break. That being said, python always tries to minimize the number of keywords, so re-using else makes more sense then introducing a whole new keyword for a niche usecase.

seandougall• 8 years ago

Agreed. I can see where the design is coming from, but this coupled with the reliance on indentation to delineate scope means that it’s really visually confusing — I expect the `else` to correspond to the `if` statement when I see it in the context of the given example. It’s not strictly ambiguous, but it’s certainly an impediment to readability.

vqng• 8 years ago

I am not a native speaker but I think "done" or "finished" is better. "else" is a counterpart of "break". It assumes people must think of "break" whenever they see a "for", which is not always the case. We refer to this weirdness as Pythonic.

combatentropy• 8 years ago

The Handlebars template engine works the way you're talking about. The "each" helper loops through an array. You can put in an "else" block for when the array is empty.

  {{#each paragraphs}}
      <p>{{this}}</p>
  {{else}}
      <p class="empty">No content</p>
  {{/each}}

--- https://handlebarsjs.com/builtin_helpers.html

kchr2• 8 years ago

I like this ternary approach.

scardine• 8 years ago

Django templates also have such a clause but it is named "empty" instead of "else".

tzs2• 8 years ago

I would expect that for a loop, an else clause would happen when the loop does _not_ finish normally, or if they loop is empty

Suppose it worked like that and you had this code:

  for i in l:
    A()
    if B():
      break
    C()
  else:
    D()

Wouldn't that be equivalent to:

  for i in l:
    A()
    if B():
      D()
      break
    C()

What your suggested else is doing is providing a place to put code to execute after a break in the loop, but we already have a place for such code: immediately in front of the break in the loop.

The only place that comes to mind where this would be useful is situations where you there is more than one

  if ...:
    D()
    break

in the loop. With your suggested kind of else, you could move all the D()'s to an else after the loop.

Animats• 8 years ago

Yes, "then" would have been a better choice. But "then" isn't a keyword in Python.

"else" is used with try blocks to indicate the exception didn't take place. It makes more sense there, because it follows the "except" sections.

jimmytucson• 8 years ago

Here’s why (Hettinger):

In 1991, “else” was the obvious choice because of the traditional way compilers implemented while-loops: pastebin.com/tY35CTJ4

That is, “if I haven’t finished the loop, GOTO the body.”

He says if he had a time machine he could tell Guido in the future we’re all using structured programming so no one will find “else” intuitive; call it “nobreak” instead: https://m.youtube.com/watch?v=OSGv2VnC0go#

Guido says if he had a time machine he would not have included the feature at all: https://mail.python.org/pipermail/python-ideas/2009-October/...

This whole thing was Knuth’s idea, not Guido’s: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.103...

pmontra5• 8 years ago

Guido says if he had a time machine he would not have included the feature at all

So deprecate it with a runtime warning and remove it after some years.

I wonder if there are some statistics about its usage. I guess it's very low.

evandijk70• 8 years ago

If Guido would not have included the feature at all, why did he not remove it from Python 3? That would have been the perfect opportunity.

qwerty456127• 8 years ago

He says if he had a time machine he could tell Guido in the future we’re all using structured programming

Sounds like if people were not already coding C, C++ and Pascal when Python was invented...

pasta1212• 8 years ago

"Then" implies that the associated code will always run after the for loop completes, which isn't true either. Maybe "complete" is a decent choice. I'm sure language keywords are an issue here, too.

Doxin• 8 years ago

It always made sense to me since I think about these constructs as the loop searching for something (and breaking if it finds it) and the else running if nothing was found.

    for item in list:
        if search_condition:
            found_item=item
            break
    else:
        found_item=default_item

hughdbrown• 8 years ago

As an alternative, you could do this:

found_item = next((item for item in list if search_condition), default_item)

gbin• 8 years ago

Honestly it is not a big deal, just remember the else is for the break, not the for. Then it reads naturally: for this break else do that.

farzher• 8 years ago

it should be called nobreak

that explains exactly what it does

mixmastamyk4• 8 years ago

Yes the for...else is useful but for years it didn't do what I expected, which is execute when the sequence was empty. After reading the docs a half dozen times I finally internalized that the else actually means "not broken," aka "not found."

So now when I use it, I always put a comment next to it for myself and the next person:

    for item in items:
        if found:
            break
            
    else:  # no-break 
        print('not found.')

kazinator4• 8 years ago

In fact, what it means is "execute this else when the loop guard fails" (regardless of whether the loop body has executed at all, or how many times). It is a legitimate alternate clause in the sense that it provides alternative behavior when the guard fails.

Except when the loop is infinite, or is broken prematurely, the loop guard will fail. Under for item in list, the implicit guard fails immediately when the list is empty. If the list isn't empty, it fails after the last item is iterated upon.

Thus here it also means "else if there are no more items to be processed".

acqq• 8 years ago

It is a legitimate alternate clause in the sense that it provides alternative behavior when the guard fails.

But the "guard fails" and the else is executed on every normal loop exit, except if the exit was done with break.

    for a in range( 1,3 ):
        print( a )
    else:
        print( "end" )

gives:

    1
    2
    end

It's an "alternative" only when there's break. In all other cases it is executed.

Even naming it "nobreak" would be confusing as without break it is always executed at the end. The clearer naming would be approximately "on_every_nonbreak_end_of_for"

iamforreal• 8 years ago

Honestly, I would just not use it wherever possible. It's a wart on the language, and there are plenty of semantically superior alternatives. I would rather wrap in function + use return over break, use a sentinel value, or raise an exception over using the else block.

If there's anything I've learned, it's that just because a language has a feature, doesn't mean it should be used.

maxbond2• 8 years ago

Function + return seems like a good solution, but I'd rather not keep additional state or use `raise` (ie socially acceptable GOTO) when the language has a primitive for this.

You shouldn't use a feature just because a language has it, you should use it because it's a simple, well-defined primitive that's less complex than alternatives.

rplnt4• 8 years ago

for years it didn't do what I expected, which is execute when the sequence was empty

It does though http://codepad.org/en4mzowh

mixmastamyk4• 8 years ago

Sorry, "^only execute when the sequence was empty".

eigenvalue• 8 years ago

The fact that so many commenters here are confused or surprised by what it means or how it works sort of proves to me that it is a bad idea to use this in your code-- especially if anyone else might need to work on that code. I always prefer the clearer, obvious approach, even it is slightly longer.

Myrmornis2• 8 years ago

I agree that many people find it surprising/ bad syntax. I’m one of them, I have to think and double think every time I consider using it. But it’s part of the language, and we should embrace our language that we use.

kbumsik2• 8 years ago

It is true that this is confusing for people who come across it for the first time, but it is easy to understand/remember once you know this feature.

genidoi• 8 years ago

A counter-intuitive feature is not worth using even if 9/10 python devs know about it. Which they don't seem to. https://twitpic.com/4a52sh

Seems like bad usability.

makecheck2• 8 years ago

While this is a great capability to have, the tendency to have an indented “if” preceding a not-indented “else” just always seems like somebody might have made a mistake.

I would rather something that captures the loop state itself as an operable object, such as:

    with for as loop:
        for x in my_list:
            ...
        if not loop.broken:
            ...

sooheon3• 8 years ago

Interesting how people's intuitions differ. For me hiding yet another . method that requires discovery is more burden on the human. I'd rather reach for map/filter => processing.

Mangalor• 8 years ago

Seconded

fyi11835• 8 years ago

The if you're talking about ends in a break.

To me and many others, having an else associated to an if that ends in break/continue/return is a code smell, because it misleadingly suggests that there are two possible paths of control flow that reach the code after the if/else, when in reality you can only reach that point through the else block.

nickm122• 8 years ago

https://twitpic.com/4a52sh

A survey on this feature was done at Pycon 2011. Maybe things have changed since then, but at the time, most people didn't understand what for/else did.

I think it's a bad construct because, as many have mentioned, a lot of people make the commonsense interpretation that the else block will only execute if the for block did not.

Note, the link above come via Jeremy Avnet in the comments of this blog post.

https://nedbatchelder.com/blog/201110/forelse.html

mar77i• 8 years ago

Personally, I'm really struggling with the idea which is underlying to this feature, and I find it relieving to find this article and survey result.

- Does the else realize that the loop contains an if block?

- How does a break statement relate to the StopIteration exception?

- How does the else block run if the range wasn't, technically, empty?

rplnt4• 8 years ago

the commonsense interpretation that the else block will only execute if the for block did not

That is exactly what it does. So when you explicitly break, the for body was executed. As for the poll, the first answer is not wrong. It's first option even, the question is vague enough. I wouldn't read that much into it, 33+24+9 (66%) people gave correct answer.

irishsultan• 8 years ago

Except it isn't what it does. What that option means is that either the loop is entered, or else if the condition is false from the start it will execute the else block.

wodenokoto• 8 years ago

So when you explicitly break, the for body was executed.

Maybe that is what is technically happening, I honestly don't know what that means.

I consider the body of a for statement to be execute for every loop, and for the loop to normally end when all values have been iterated. And else-clause is something that happens instead of the intended clause, which makes it very hard to fit in.

Reading through the comments here, there does seem to exist a mental model where the else makes sense. Something along the lines of

`if` there still is a value to assign to `i` do `loop-body`, `else` do `else-body`.

You can learn that, and it does make sense, but it is not the mental model the majority of people will build when they see a normal for loop in Python.

nickm122• 8 years ago

I think you're mistaken on both counts. The first answer is what I call the "commonsense interpretation" and it is incorrect about what python's for/else does.

zmmmmm• 8 years ago

Nearly everybody seems surprised by what it does, which would appear to constitute a fairly strong violation of the "principle of least surprise" that is one of the most cited guiding principles employed by the designers of Python. As such it would seem better to be described as an "anti-tip" or something like that.

eesmith• 8 years ago

It was a feature van Rossum added in the earliest days of Python, on 14 Oct 1990, back before he fully developed his design sense.

As I recall, he said added it because the implementation structure of the "for" code matched the implementation structure of the "if" code, and he felt that 'for' could use an 'else'.

AlexCoventry• 8 years ago

I'm curious why people are interested in this. No way I would have predicted it would get to the top of HN.

mychael• 8 years ago

Never use this in the real world please.

reuven• 8 years ago

I love Python's for-else feature. I've used it on a number of occasions, and have found it to be useful and to cut down on code.

However, I agree that the use of "else" is horribly confusing. When I teach "for-else" to students in my Python courses, they are often surprised by the functionality, and doubly surprised that the word "else" is used. I often joke that it would be a great feature, if only they had chosen something a bit more intuitive and memorable instead of "else", such as "if_we_exited_the_block_without_encountering_a_break". Slightly more seriously: While I realize that adding a keyword to Python isn't in the cards, a word such as "nobreak" would be easier for people to understand, and would stress the point of the functionality.

The fact that Emacs always tries to indent the "else" of a "for-else" to align with an "if" inside of the loop, rather than the "for" with which it matches, speaks volumes. I mean, if Emacs is confused, then how are we mere mortals supposed to remember?

So when I use "for-else", it's almost always in code that I am writing for myself, and that I don't expect others to read or maintain.

Don't forget that there's also "while-else", although I can't remember the last time I saw that actually used.

2T1Qka0rEiPr• 8 years ago

Agree with everything here! As a Python novice I found the name terrible, but nowadays I make use of it pretty frequently, and like the power which comes with it. I also use `try-except-else` (though I appreciate the "else" here has completely different semantics, I think it's something few people know about)

toxik• 8 years ago

I would definitely expect a human to understand code intent (and indent) better than Emacs. Machine learning has some ways to go still. ;-)

monsieurbanana• 8 years ago

Emacs is really not a reference in terms of code indentation. I expect classic IDE to be much more robust at it, since emacs uses regex most of the time to determine indentation (the javascript mode is the only exception I remember), whereas I imagine a full-blown python IDE will actually parse the code.

SmirkingRevenge3• 8 years ago

I've used the loop -> else construct sparingly - there are times when it is really convenient.

But it is VERY confusing.

Its very confusing, and poor design - IMHO - because the presence of an "else" block, in the typical case, generally indicates that the preceding block was never executed.

When it comes to while/for blocks in python, the keyword literally indicates the opposite - that the preceding block executed without hiccups - and so also execute this block.

Its a great feature - but there should have been another keyword for it: "also" (or something like that)

wwwtyro• 8 years ago

Hold up. Stop. Read the parent closely.

This is a case where the right answer is only obvious once it's been stated.

Its a great feature - but there should have been another keyword for it: "also"

SmirkingRevenge - !@#$ing brilliant. You've stepped outside the box and presented an answer that will click as soon as it's read.

Someone make a PEP.

hueving• 8 years ago

"nobreak" also makes as much sense. Even Raymond Hettinger has suggested that, but getting a new keyword at this point in python is going to be really difficult.

gvx6• 8 years ago

Honestly, "else" wasn't confusing to me at all, but "also" would make me very confused.

SmirkingRevenge3• 8 years ago

That may be the nicest reply I've ever had on HN. Thanks!

Gibbon1• 8 years ago

Not a python programmer (I've used it off and on in a very slashy sort of way).

I'd much prefer syntax like

    da_thing = for ook in blahblah:
       if oook == something:
           break oook

    if da_thing is None:
       print ("Not found")
    else:
       print ('Found', da_thing)

gvx6• 8 years ago

That could be accomplished by doing:

  da_thing = None
  for oook in blahblah:
      if oook == something:
          da_thing = oook
          break

  if da_thing is None:
     print ("Not found")
  else:
     print ('Found', da_thing)

But it does not work if you sometimes want to find `None`, so better would be something like:

  da_thing = sentinel = object()
  for oook in blahblah:
      if oook == something:
          da_thing = oook
          break

  if da_thing is sentinel:
     print ("Not found")
  else:
     print ('Found', da_thing)

aiCeivi9• 8 years ago

I prefer to extract it to separate function and simply `return` instead of `break`.

jacob0193• 8 years ago

I've been using this for years and never thought twice about it, I'm shocked by all the negativity.

It's great for controlling iteration in a nested loop:

  for item in report():
      for event in in item['events']:
          if event in events_we_care_about:
              break
      else:
          continue
      act_upon(item)

I realize it's a trivial example that could be written without a nested loop, but there are often good reasons for nested loops and littering them with control variables and if statements gets messy quick. I have always found for-else to produce more elegant code.

Your criticisms may be quite valid, I just wanted to share my surprise.

ankrgyl• 8 years ago

I may be missing something... but how is that clearer than

  for item in report():
      for event in item['events']:
          if event in events_we_care_about:
              act_upon(event)
              break

jacob0193• 8 years ago

It's a trivial example. Just to demonstrate how for else helps to control an outer loop from within an inner loop.

rahimnathwani• 8 years ago

Your act_upon is passed values from the inner loop. GP's act_upon is passed values from the outer loop.

Asooka• 8 years ago

I would write that as

    for item in report():
        if any(event in events_we_care_about
               for event in item['events']):
            act_upon(item)

But obviously the features that enable this form didn't exist when for...else was added to the language.

jacob0193• 8 years ago

Clearly it was a poor example, I wouldn't structure simple code this way either but in more complex situations it can be the simplest solution.

random_throw• 8 years ago

This is discussed as item 12 in Effective Python. The author argues that you should avoid "else" blocks after "for" and "while" loops. The main argument is that the behavior is not intuitive and could be confusing upon reading given its somewhat obscure usage.

He suggests using a helper function with an early exit or setting a result variable and using a break in your loop instead.

hiccuphippo• 8 years ago

I had my first legitimate use of for else last week after knowing about it for years and it (the keyword) never making much sense.

I had to call an API for it to load data into a cache, but sometimes this wouldn't work so I made it try up to 3 times, otherwise it would show an error. So something like:

    for i in range(3):
        if load_cache():
            log("success")
            break
    else:
        log("failure")

Else made total sense here.

quickthrower2• 8 years ago

Else is a bit of a confusing name for the keyword IMO.

How about "ifcompleted"

cup-of-tea3• 8 years ago

For-else is nothing. The really weird one is the Try-else.

The For/While-else does exactly what I expect. I'm not sure why others find it confusing.

The Try-else does make some code more readable but is quite rare I would say.

Vendan4• 8 years ago

Well, for one thing, a few templating engines have a "for each item, print x, else if there are no items, print y". (for instance: https://handlebarsjs.com/builtin_helpers.html#iteration)

cup-of-tea3• 8 years ago

That's not intuitive at all. That's equivalent to:

    if len(items) == 0:
        print(y)
    else:
        for item in items:
            print(item)

Which means there's a whole extra implicit if. The for in Python is really this:

    it = iter(items)
    while True:
        try:
            item = next(it)
        except StopIteration:
            print("else")
            break
        print(item)

Where that try/except is like "if there is a next item do this, else do this", hence:

    for item in items:
        print(item)
    else:
        print("else")

blumomo• 8 years ago

I find this pattern very much better expressed with functional programming:

  item = next((item for item in container if search_something(item)), None)
  if item:
      process(item)
  else:
      not_found_in_container()

instead of as suggested in the blog post:

  for item in container:
      if search_something(item):
          # Found it!
          process(item)
          break
  else:
      # Didn't find anything..
      not_found_in_container()

gvx6• 8 years ago

Your suggestion contains bugs, though. To make it fully equivalent to the code in the blog post, it would need to be:

  sentinel = object()
  item = next((item for item in container if search_something(item)), sentinel)
  if item is not sentinel:
      process(item)
  else:
      not_found_in_container()

... because item could be None or another falsy value.

hajderr• 8 years ago

This is strongly advised against in the book Effective Python as the semantics are opposite to what one is used to. The else clause will always be executed unless there's a 'break' in the for-loop.

m4r71n• 8 years ago

One thing that for-else is very useful for is implementing an elegant and easy-to-understand retry mechanism:

  for _ in range(3):
      success = do_something()
      if success:
          break
  else:
      raise FailedToDoSomething

I generally like this feature of the for loop and it would be a shame if it was removed.

cup-of-tea3• 8 years ago

Indeed I have use this idiom a lot. The alternative is to store a state variable indicating success which isn't very nice.

OJFord• 8 years ago

I much more frequently wish that I could express 'or do this if zero iterations' than I use for-else as it is; I do so wish it had the former semantic.

That and the absence of do-while are the cause of a good deal of non-DRY python around loops.

nearmuse• 8 years ago

Or maybe it was a terrible "or else" pun that does not deserve much discussion.

bjourne• 8 years ago

This is coincidentally my highest rated Stackoverflow answer ever. :)

https://stackoverflow.com/questions/9979970/why-does-python-...

Tl;dr my highly opinionated opinion is that one should never use the construct

pure_ambition• 8 years ago

Well, that’s a dumb feature. Very counterintuitive, requires you to stop and think, and there’s a high probability that it’ll be misunderstood at first glance. I hate things like this - you’ll read it, think you understand it, experience a bug, spend hours debugging, then finally look up the documentation for ‘else’ and see that it means something different from what you thought.

julienfr112• 8 years ago

I write quite often something like that:

    for i in range(10):
      for j in range(10):
        if condition(i,j):
          dosomething
          break
      else:
        continue
      break

It's a pattern that ensure that dosometing is run at most once by "propagating" the break to the outer loop.

The alternative is use a function and do a return.

Any though of this ?

alkonaut• 8 years ago

I'm not a python programmer but I find the last 4 lines rather hard to read. Unless there is a performance reason to not do so, I'd argue that you are iterating over pairs (i,j) here and I'd make the code clear. There are 100 pairs, and once you find one that satisfies the condition you are done. Again, not a python programmer but it might look like

  (x, y) for x in range(10) for y in range(10)
     if condition(i,j)
        dosomething;
        break;

Edit, ("zip" is not the outer product... )

quietbritishjim• 8 years ago

The relevant function is itertools.product() [1]. It can give the Cartesian product of arbitrary iterables, but if you have the same iterable more than once, as in this example, you can take advantage of the repeat= optional parameter to simplify the call a little bit:

    for x, y in itertools.product(range(10), repeat=2):
        if condition(x, y):
            dosomething(x, y)
            break

Alternatively, you can use Python list comprehensions:

    prodlist = [x, y for x in range(10) for y in range(10)]
    for x, y in prodlist:
        if condition(x, y):
            dosomething(x, y)
            break

Overall, I still prefer refactoring into a function and using return, as the GP comment suggested.

[1] https://docs.python.org/3/library/itertools.html#itertools.p...

holografix• 8 years ago

I would never include this in my code. It’s a construct most devs have never seen in Python and it differs from anything I’ve seen in other languages.

Always KISS.

joshmkay• 8 years ago

I can't see this ever being used. As a non-python programmer, if I ran across this it would be very confusing. If it's simple enough to write the same code without the else block and have your code be more readable, why not do that?

Python’s For - Else

Related Stories