Thread by @reuvenmlerner

One of the hardest things for people to learn in #Python is list comprehensions. Some quick tips that make them easier to work with:

(1) Break them up into multiple lines! It drives me batty to see people writing comprehensions on a single line.

You can then reason about each line separately:

[int(x)
for x in '1 2 b 3'.split()
if x is.digit()]

Line 1: Expression
Line 2: Iteration
Line 3: Condition

Or if you're a fan of SQL:

Line 1: SELECT
Line 2: FROM
Line 3: WHERE

(2) The expression can be literally any Python expression. Any operator, function, or method. Including functions that you write.

(3) Don't use print as an expression. Comprehensions create lists. Print displays data on the screen. Also, print returns None — not what you want.

(4) The source in line 2 can be a list, but also a tuple, dict, set, file, or anything else.

(5) Comprehensions don't modify the data on which they run. They create new data structures.

(6) There are several kinds of comprehensions:

- List comprehensions create a new list
- Dict comprehensions create a new dict
- Set comprehensions create a new set

There are also generator expressions, which return a generator object.

(7) The "for" loop (line 2) runs first, then the "if" condition. If the condition returns True, then the expression (line 1) runs, and its value is placed into the output list.

(8) The condition can be as simple or as complex as you want.

(9) You can have more than one "if" condition! Those are joined (anded, if you will) together. So you can say

[int(x)
for x in '1 2 b 3'.split()
if x is.digit()
if len(x) < 2]

This isn't needed for simple joined conditions, but can make things much easier to read.

(10) Nested comprehensions are really hard to read and understand... until/unless you do them on multiple lines. They are written as:

[expression
for #1
optional if #1
for #2
optional if #2
etc.]

Consider:

mylist = [[10, 20, 30], [40, 50], [60, 70, 85]]

We can say:

[x
for sublist in mylist
for x in sublist]

We get:

[10, 20, 30, 40, 50, 60, 70, 85]

But what about:

[x
for sublist in mylist
for x in sublist
if x % 2]

Now we get:

[85]

Since only one number is odd.

We can also say:

[x
for sublist in mylist
if len(sublist) < 3
for x in sublist
if not x % 2]

and we get:

[40, 50]

All even numbers in the only sublist with fewer than 3 elements.

Once you internalize how to write comprehensions, they become natural to write (and even read). Until that, it's natural to say, "Who needs this?" But make an effort to try them, and it will pay off!

BTW, I love comprehensions so much, I have a course about them: store.lerner.co.il/comprehending-…

And comprehensions are an important part of my corporate training... so if your company needs help understanding them (or anything else in Python), let me know!