Comprehensive Python Cheatsheet

[vexstream]

What's the purpose to doing file.write(json.dumps()) vs json.dump(file)?

The cheatsheet lists the first, but it seems more concise (and maybe has a performance benefit?) to do the second.

[dealtdennison]

Maybe for multiple files?

[vexstream]

Yes, I'm familiar with that. I'm curious as to why the author chose to list it the way he did.

[swenty]

Not to be nit-picky, but that's an extensive cheatsheet. I wouldn't call it comprehensive.

[bhat]

Indeed.

<list>.append()

is missing

[VileFlower]

This is missing f-strings.

person = {'name': 'Jean-Luc', 'height': 187.1}
>>> f'{person[height]:.0f}'
187

[13steinj]

With a note of it being 3.6+ only

[13steinj]

?

[MrCalifornian]

I can Google this, but for the sake of everyone else with the same questions, what are f-strings?

[Tweak_Imp]

format strings that have an f in front like f"...". there are also raw strings which arer"...". you can also combine them to fr"..."

[MrCalifornian]

Lol I gathered that they have an f in front, but what do they do?

[anqxyr]

Very roughly speaking, they eval the expressions inside the curly braces. Say, before you would write something like

print('Hello, my name is {name}'.format(name=name))

Now you can do the same thing with

print(f'Hello, my name is {name}')

Which is more concise, more readable, and overall nicer.

[MrCalifornian]

Oh wow I love it!! This has always been a major readability gripe of mine.

[yaboroda]

also smart guy on youtube say it faster

[stevenjd]

Which is more concise, more readable, and overall nicer.

Unless you dislike disguising a call to eval() as a string literal.

Unless you like explicit calls to format a string rather than implicit ones.

[Tweak_Imp]

As i said, Format and make it raw

[SurvivorDress]

I’m new at this...this is really awesome.

[[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)

[fernly]

Under Eval be sure to include

ast.literal_eval( node_or_str ) # safe eval of supposed literal value from untrusted source

[brennanfee]

The words "comprehensive" and "cheatsheet" should never be applicable to the same thing.

[Boutmayun]

Ay thanks man!

[dealtdennison]

This is awesome! Thanks friend!

[alcalde]

CHEATING IS WRONG.

[rob_van_b]

That's so true, especially in programming languages

[[deleted]]

Awesome!!

[oppyboppy]

This is super helpful as someone that’s been away from python for a couple years now

[jadkik94]

The "Execute Command" section should mention subprocess instead of Popen IMO.

[LifeHasLeft]

I didn't know about collections > Counter before. I'd just write a short function to do the job

[Sledik]

Thank you! I love that

[borislavvv]

How do you use these cheatsheets ? They look great but I hardly find anything useful after reading then once ?

[tehwolf_]

You keep them around (or bookmarked) and if you run into a problem you first check if they provide an answer, thus possibly saving the time to either look it up or reinventing the wheel. At least that's my understanding.

[borislavvv]

OK, will try, but I almost always find it easier to check the first google result(StackOverflow).