CODEWITHSUNDEEP
pythonfor-loopsyntaxgeneratorlist-comprehension
Pintun
Pintun

Reputation: 736

Compound conditions in a for loop

Python allows an "if" condition in list comprehensions, e.g.:

[l for l in lines if l.startswith('example')]

This feature is missing in regular "for" loop, so in absence of:

for line in lines if line.startswith('example'):
    statements

one needs to assess the condition in the loop:

for line in lines:
    if line.startswith('example'):
        statements

or to embed the generator expression, like:

for line in [l for l in lines if l.startswith('example')]:
    statements

Is my understanding correct? Is there a better or more pythonic way than ones I listed above to achieve the same result of adding a condition in the for loop?

Please notice "lines" was chosen just as an example, any collection or generator could be there.

Upvotes: 5

Views: 3211

Answers (4)

Pintun
Pintun

Reputation: 736

Several nice ideas came from other answers and comments, but I think this recent discussion on Python-ideas and its continuation are the best answer to this question.

To summarize: the idea was already discussed in the past, and the benefits did not seem enough to motivate the syntax change, considering:

  • increased language complexity and impact on learning curve

  • technical changes in all implementations: CPython, Jython, Pypy..

  • possible weird situations that extreme use of the synthax could lead

One point that people seem to highly consider is to avoid bringing Perl-alike complexity that compromise maintainability.

This message and this one nicely summarize possible alternatives (almost already appeared in this page as well) to a compound if-statement in for-loop:

# nested if
for l in lines:
    if l.startswith('example'):
        body

# continue, to put an accent on exceptional case
for l in lines:
    if not l.startswith('example'):
        continue
    body

# hacky way of generator expression
# (better than comprehension as does not store a list)
for l in (l for l in lines if l.startswith('example')):
    body()

# and its named version
def gen(lines):
    return (l for l in lines if l.startswith('example'))
for line in gen(lines):
    body

# functional style
for line in filter(lambda l: l.startswith('example'), lines):
    body()

Upvotes: 1

Dimitris Fasarakis Hilliard
Dimitris Fasarakis Hilliard

Reputation: 160667

Is there a better or more pythonic way than ones I listed above to achieve the same result of adding a condition in the for loop?

No, there is not, and there shouldn't be; that was the rationale for why list comprehensions got here in the first place. From the corresponding PEP:

List comprehensions provide a more concise way to create lists in situations where map() and filter() and/or nested loops would currently be used.

List comprehensions constitute an alternative for nested for, ifs; why would you want an alternative to the alternative?

If you need to use an if with a for, you nest it inside it, if you don't want to do that, you use a list comprehension. Flat is better than nested but readability counts; allowing an if there would result in long ugly lines that are harder to visually parse.

Upvotes: 0

tdelaney
tdelaney

Reputation: 77407

Its not that the feature is missing, I can't think of any way it could be done except in some special cases. (l for l in lines if l.startswith('example')) is a generator object and the l variable is local to that object. The for only sees what was returned by the generator's __next__ method.

The for is very different because the result of the generator needs to be bound to a variable in the caller's scope. You could have written

for line in (line for line in lines if l.startswith('example')):
    foo(line)

safely because those two line's are in different scopes.

Further, the generator doesn't have to return just its local variable. It can evaluate any expression. How would you shortcut this?

for line in (foo(line)+'bar' for line in lines if line.startswith('example')):
    statements

Suppose you have a list of lists

for l in (l[:] for l in list_of_lists if l):
    l.append('modified')

That shouldn't append to the original lists.

Upvotes: 0

OneCricketeer
OneCricketeer

Reputation: 191983

Maybe not Pythonic, but you could filter the lines. 

for line in filter(lambda l: l.startswith('example'), lines):
    print(line)

And you could define your own filter function, of course, if that lambda bothers you, or you want more complex filtering. 

def my_filter(line):
    return line.startswith('example') or line.startswith('sample')

for line in filter(my_filter, lines):
    print(line)

I would say that having the condition within the loop is better because you aren't maintaining the "filtered" list in memory as you iterate over the lines.

So, that'd just be 

for line in file:
    if not my_filter(line):
        continue
    # statements

Upvotes: 1

Related Questions