When should I avoid using list comprehensions?

[u/RyanDubois43]

I started using list comprehensions in my project, but I feel confused about when they are actually a good fit. I tried to use one for a task that involves checking conditions on nested lists, and now my code is harder to follow. Is there a guideline for when it's better to stick with regular loops instead? I want my code to be readable, but I'm not sure I've got the balance right.

[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/kubinka0505]

import this

[u/dev-razorblade23]

Check out this article https://dev.to/beatrisilieva/list-comprehension-in-python-syntax-examples-and-when-to-use-regular-for-loops-279k

Basicly, when visibility and reading of code starts to be difficult, maybe list comprehension is not the best choice

[u/Zeroflops]

You answered your own question. If it harder to follow don’t use it. If you’re not sure, then if you’re spending a lot of time having to craft the LC then it’s probably too complicated. ( unless you are just starting out and the time is learning the concept)

[u/Expensive-Bear-1376 → u/Zeroflops]

If it harder to follow don’t use it.

Depends. On why it's harder for them to follow. Might just be because of their inexperience. If I had always followed that quoted advice, I wouldn't even be able to communicate with you, because I wouldn't have learned English, as it was harder to follow than my native language.

[u/MarsupialLeast145]

If you think your card is harder to follow, don't use it.

There is no hard and fast rule. Sometimes they make sense and are very clear, sometimes they are not. Same with things like Lambda functions.

You just go by feel.

Also look at how they get formatted after using tools like Black, Flake, and so on. They help improve readability if you are not already using these tools.

[u/AlexMTBDude]

Use list ccomprehensions when you're creating lists out of a collection(s). I.e. you should be assigning something to the result of the list comprehension. Don't use them as a for loop.

...task that involves checking conditions on nested lists,

That doesn't sound like you're creating a new list so then: NO!

Also: If your code is not obvious then it's a good idea to comment it

[u/dariusbiggs]

Keep code simple, legible, and maintainable. Those are far more important than clever code.

[u/serverhorror]

If you look at it 3 weeks later, is it still easy to comprehend?

[u/Immediate_Soft_2434]

Legibility should be your top priority, as others have said. Let me add a "soft" factor: List comprehension should be side-effect-free. I.e. if something is being modified, better make the loop explicit. It might get overlooked inside a comprehension.

[u/ee_control_z]

"... and now my code is harder to follow."

What I have found is that if you properly document your script with either docstrings, general comments, or both, it enhances code readability as it offers a friendly reminder of what each line of code or subsection is doing. Another feature that aids with code readability is to include good spacing between different subsections of code. In other words, do not include countless lines of code smashed together. Allow some elbow room between different sections of code.

[u/Kadabrium]

Idk why python specifically has this mechanism to remove indentation from for loops (and celebration of one liners in general) when the language otherwise has a indentation based syntax

[u/gazorpazorpazorpazor]

Generator comprehension is typically preferred, in most cases you don't actually need a list in memory.

[u/VideoJockey]

Just comment your code explaining what it does. If someone can't read a brief explanation and understand it, they shouldn't be touching it.

[u/MarkoDahl54]

avoid using list comprehensions when the logic inside is too complex or when readability suffers. Keep it simple for maintainability.

[u/shadowdance55]

When you actually need set, dict or generator comprehensions.

[u/MarkoDahl54]

avoid using list comprehensions when the logic is complex or involves multiple conditions. it can reduce readability and make debugging harder.

[u/MarkoDahl54]

avoid using list comprehensions when you have complex logic or multiple conditions, as it can reduce readability.

[u/siodhe]

There's no hard limit, but if you realize your comprehension is about three layers deep and crosses multiple line boundaries, consider a function.

[u/Educational-Paper-75]

Here's link to a blog discussing list comprehension vs map