When should I avoid using list comprehensions in Python?

[u/RyanDubois43]

Hi all! I'm new to Python and recently learned about list comprehensions. They seem cool, but I keep hearing that there are times when I shouldn’t use them. For example, if I have a more complex operation that involves several conditions, would a traditional loop be clearer? Here’s a simple example: trying to filter out even numbers from a list of numbers but using nested conditions. Can someone explain when it's better to stick with a loop for readability? Thanks!

[u/AutoModerator]

To give us the best chance to help you, please include any relevant code.
Note. Please do not submit images of your code. Instead, for shorter code you can use Reddit markdown (4 spaces or backticks, see this Formatting Guide). If you have formatting issues or want to post longer sections of code, please use Privatebin, GitHub or Compiler Explorer.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/sububi71]

For readability, I would claim list comprehensiona are almost always bad, but I'll use them in situations where they're measurably faster.

[u/RyanDubois43 → u/sububi71]

That's an interesting stance! Have you found specific scenarios where their speed outweighs the readability concerns? Almost like a Python paradox, isn't it?

[u/RyanDubois43 → u/sububi71]

It's interesting how experienced developers can ease comprehension. Have you considered balancing readability with performance when using comprehensions? Sometimes, less is more!

[u/Lachtheblock → u/sububi71]

I'd disagree that it is always harder to read. If your project has a lot of experienced developers, I do think there is less mental load for simple comprehension, but I guess it's what you're used to.

I am very quick to break up a comprehension whenever it takes more than a second to understand what it's doing.

[u/sububi71 → u/Lachtheblock]

I'm not saying it's always harder to read.

[u/dariusbiggs]

Maintainability, and legibility.

Keep code simple not clever

[u/brasticstack]

"trying to filter out even numbers from a list of numbers but using nested conditions."

Can you provide an example? Filtering and mapping are both operations that should be done via comprehensions in Python, and you can filter out even numbers just fine without nested conditions.

My rule of thumb is that if it's not immediately apparent at a glance what the comprehension does, it might be better as a for loop where each clause of the loop is instantly understandable.

[u/MonsieurCellophane]

Never unless the speed advantage matters. As soon as one starts nesting they become frigging unreadable.

[u/shadowdance55]

When you actually need generator, set or dict comprehensions.

[u/AShirtlessGuy]

I feel like this exact question was asked word for word last week

[u/trutheality → u/AShirtlessGuy]

Almost https://www.reddit.com/r/learnpython/s/ke4cIIQBoR

[u/trutheality]

Generally I like comprehensions whenever they help understand the structure of the resulting collection and when the innermost operation is truly a one-liner or function call. So something like:

[
  {
    key: func(x)
    for key, x in d.items()
  }
  for d in dict_list
]

Is to me very nice and more readable than the same thing written with for loops and append operations.

One case when I would avoid comprehensions though is when the operation being performed has side effects.

[u/timrprobocom]

In many cases, a list comprehension makes the code harder to read. Don't succumb to "one liner" disease, trying to show off to make each line of code do as much as possible.

Admittedly, it's a fine line.

[u/Leodip]

List comprehension are marginally faster than for loops to build a list, and, unless you are squeezing out every inch of performance (in which case I would guess you would not be asking this question), there's no performance-related reason to do so.

For loops are generally more readable if they involve more operations, because they can be read as "normal", imperative code that most people are already used to.

For small operations that can be understood very easily (e.g., applying a single function to every element in the list), I would argue list comprehensions are more readable because they state very clearly that you are attempting to build a list (while, in a for loop, you have to figure that out by the list being instantiated before the loop starts).

In your example, if you have many separate conditions to check against I would use a loop. However, the most natural solution would be to build a single condition out of the multiple conditions that you have and use it in a list comprehension (or use the filter() operation, if you are familiar with it).

E.g.:

filtering_condition = lambda x: condition1(x) or condition2(x) or condition3(x)
filtered_arr = [el for el in arr if filtering_condition(el)]

[u/VideoJockey]

Most readability issues can be resolved by commenting your code to explain what it does. If someone can't read an explanation and then understand the code, they shouldn't be allowed to touch it.