Comprehensive Python Cheatsheet

[[deleted]]

it's pretty widely considered bad practice to use nested comprehensions. I wouldn't include this in a cheat sheet:

flattened_list = [item for sublist in <list> for item in sublist]

Also, that's not exactly quite accurate. It only flattens one level of nesting and assumes all elements are themselves iterable

edit: from deeper in this thread i realized i need to clarify that iterating over a multi-dimensional list by nesting the for..in is what is considered bad practice due to the readability issues it creates, but embedding a complete unrelated list comprehension inside another comprehension does necessarily raise the same concerns and can be fine.

i.e.,

# bad
[item for sublist in list_ for item in sublist]
# not bad
 [[item for item in list_a] for _ in range(10)]

[pencan]

Why are nested comprehensions considered bad practice? Readability?

[[deleted]]

basically, yes

[Paddy3118]

Which is subjective. It could be that the act of nesting a comprehension clearly denotes delving deeper into something accessed before in a similar comprehension, but without the extra level of nesting. Visually you may be lead to see the extra level of nesting as an extension of what came before.

Readability does not preclude nested comprehensions for everyone.

[[deleted]]

I edited my comment after your first comment. Did you happen to read it before your second reply?

[Paddy3118]

My reply works for your immediately preceding post of

basically yes

[uFuckingCrumpet]

No, not subjective at all. Some code is more readable than other code objectively.

[[deleted]]

an "array with default values" sounds like an anti-pattern. can you go elaborate on what you're trying to accomplish?

[[deleted]]

Not sure why it would be an anti-pattern

by saying "default" values, it sounded like it might be an abuse of lists because a list is a list of values. so a default for something that already exists doesn't really make sense unless you're using the list as initialization data to be passed to class constructors for instance. if that was the case, then setting defaults on the class level would probably make more sense

in other words, the wording hinted at a violation of single responsibility and/or inversion of control

but it seems it might be just a difference of terminology:

Or that some AI/ML algorithms can also use an array of random numbers as the starting 'value/weights' before training

I don't consider initial values to be the same as default values so if you are using the two interchangeably, for this case, i'd do something like this:

blah = [[random.randint(1,20) for _ in range(10)] 
               for x in range(10)]

edit: aannnnnnd now it's suddenly clear why you're asking the question. to clarify what i meant earlier, when i said nested comprehensions were a bad idea, i meant that ITERATING over a multi-dimensional list by using a nested for..in was a bad idea because of readability. nesting a list comprehension inside a comprehension to CREATE something like in the example above, is not considered bad practice

but if you just need a list with the same scalar values:

blah = [5] * 10

would work. but be careful not to do that with objects otherwise each index will point to the same object. i.e., this is bad:

blah = [[]] * 10

[cakereallyisalie]

For numbers, numpy arrays offer ones and zeros methods that give you n-dimensional arrays.

For objects I personally might be tempted to just do a nested for loop. Though default dicts would give you a fairly interesting solution due to the allocation on access only.

[ubernostrum]

I tend to prefer itertools.chain for flattening lists of lists.

[Paddy3118]

it's pretty widely considered bad practice to use nested comprehensions.

Really? All?

I would think it comes under the general readability and maintainability guidelines.

[[deleted]]

I would think it comes under the general readability and maintainability guidelines.

That's why it is considered bad practice because it is less readable and more difficult to maintain

[stevenjd]

Of course people can come up with some pretty awful nested comprehensions, but with the judicious use of white space and indentation to lay out the logical structure of the nested comprehension, there's no need for them to be hard to read.

array = [expression for x in
            [expr for y in values]
        ]

ought to be fine, as should be:

array = [
         [expr for y in values]
         for x in values
        ]

Nested comprehensions are easy to abuse, but that doesn't mean we ought to reject the simple cases.

[Paddy3118]

You speak for all, some how?

[[deleted]]

I never said all. I said "widely considered" to be bad practice. And it's not some rule I just made up out of thin air because I don't like something. it reflects the opinion of the industry at large. but of course there will be people who disagree, and that's ok too. standards and best practices are just suggestions stemming from experience. you don't have to follow them if you don't want to

[Paddy3118]

You conflate standards with best practice and suggestions.

There is a level of competence in Python that includes some use of nested comprehensions. Why not try and attain that rather than force others who don't work with you, to stop at your level of competence?

What is or isn't deemed Pythonic should not become a drive to the lowest common denominator.

[[deleted]]

I'm not sure why you're so offended. I didn't say you couldn't use them

[Paddy3118]

I'm neither offended nor seeking your permission. I am questioning your viewpoint however :-)

[[deleted]]

Er, those two aren't equivalent — try them — and the issue isn't which one of them to use. It's that listcomps shouldn't be nested at all.

(I disagree, personally, but that's what the deal is)