python -m json.tool

Just wanna throw it out there that python 3.15 was just released and has support for flattening using unpacking in comprehensions:

lists = [[1, 2], [3, 4], [5]]
[*L for L in lists]  # equivalent to [x for L in lists for x in L]

sets = [{1, 2}, {2, 3}, {3, 4}]
{*s for s in sets}  # equivalent to {x for s in sets for x in s}

dicts = [{'a': 1}, {'b': 2}, {'a': 3}]
{**d for d in dicts}  # equivalent to {k: v for d in dicts for k,v in d.items()}

(examples from https://docs.python.org/3/whatsnew/3.15.html)

I've used `flattened = sum(nested_list, [])` , it's funny how it works! Sum has a second argument for default starting value to add the values into. It uses the fact that lists have `__add__` or `__iadd__` operand defined as list.extend and will put each nested element into that empty initial list!

Same, not only that, Counter is much faster than other methods

defaultdict.

defaultdict is a very bad idea. You end up with something that looks like a dict, typing-wise is a dict, but never throws a KeyError. One day it gets passed through your system and ends up somewhere it isn't expected.

I've seen this cause intermittent issues in two very different codebases.

Use dict.setdefault instead.

You can do what?!?

I felt like a wizard when I saw that this was doable in C++, interesting to see the python method.

I was so happy when this came out

Can you do this in python 2.5 (defense work)?

Cython is a dead library walking.

The issue is simple - to get the really big speedups, you have to stop writing in Python, and use their weird Cython language. Now you can't ever run this code in Python again.

And you still don't get the same speedup as simply writing in Rust, C++ or C.

Now, this made a lot of sense in the past, because changing Python to Cython isn't too bad.

But now, you just prompt your coding assistant to port your Python library to Rust, and provide Python bindings at the same time, have a cup of coffee and it's done. Cython is simply an impediment.

I started with Python 2.6, over twenty years ago.

I read these sorts of threads to brush up, but in the last few years, I've really been seeing nothing surprising...

Until this. How did I not know? It's a conspiracy!!!

The worst is that it's completely logical and Pythonic. Had I ever thought about it, I'd have guessed that since this was the logical way to do it, it might work that way, and would have tried it out.

Bah! (Thanks!)

This works most every place. The parentheses for a tuple are a disambiguating syntax in some places, and in others you don't need them. x = 'a', 1 sets x to a 2-tuple. The only places you need parentheses are in places that take commas, like in function argument lists or in list / dict / set literals for example.

Whatt is this for when you have tuples as dict keys? are tuples really hashable? i guess so if they're immutable but... why

Although this is not that viable anymore (that is good though).

Can you show an example of walrus?

set intersection in math is associative and commutative so I would expect that to work anyway.

Yes! Then the ease you can check and create the path if it doesn’t exist.

My code is littered with @contextmanager def chdir(...): ... because I keep forgetting that contextlib already has one!

suppress() is also something I keep forgetting about.

Just python -m json is enough since Python 3.14.

Pretty good when you're on some remote server and don't have jq available.

Use sparingly!

I'm still vaguely pissed off that this works, just because I don't understand how it's legal.

It's cute and all, but it's such a departure from most languages that I'm not sure how to feel about it. Breaking it up signals intent better, imho. Yes, if you're experienced with Python, this will not confuse you... But this still packs too much implicit knowledge of operator binding/precedence, and there's too many to watch out for. It doesn't cost much to write (5 < x) and (x < 10) instead

Btw. there’s SimpleNamespace for exactly that purpose. 

Woah, dont do that.

If you want arbitrary key-value pairs, you should just use a dictionary. The only reason to do this is if you really want dot notation over indexing, but that isn't a good enough reason to use this outside of personal or one-off script or projects.

How could you?? There are children that read this sub!

But, kinda neat.

You rarely need, it, but when you do, nothing else will do.

If you use it a lot, it's probably a mistake.

Most of the time I see it, it's just a mistake.

Sometimes it could still be made more reasonable by using a local class:

def make_stringed(str_method: Callable[[Any], str]) -> type:
    class Stringed(BaseClass):
        __str__ = str_method

    return Stringed

But the above example would likely be better using type, because you can set the name:

def make_stringed(str_method: Callable[[Any], str], name: str) -> type:
    return type(name, (BaseClass,), {'__str__': str_method})

Cool. I always used x = object() / setattr

type("",(),{"foo":3})

I think I've seen this pattern suggested for implementing singletons. Definitely niche

I've used it during tool building to automatically generates classes on the fly based on a data structures (a syntax tree) for missing nodes, but that really pretty niche (and I've ended up dropping it)

I get the rationale for this but I’ve never used it. Typically it feels more Pythonic to use classes with instance vars than functions within functions.

list(reversed(liste)) (or just reversed(liste) if you just need the iterator) is typically nicer to read. I would only do the above on the rare occasion I needed to reverse a string instead of a list.

I was waiting for the 3.7 release specifically for this, and I was so happy when it came out!

On a related note, if you ever need an ordered set, just just a dict where the values are all None, and call set(d.keys()) when you're done adding to it and ready to read.

There's also a subclasses iterator for every class, but IIRC it's a little fragile for registry construction. Like it won't return subsubclasses, IIRC

This is one AI taught me.

When would you need to manually do it? Python does it for you automatically

Please don’t use “I” as a variable.. probably the worst choice..

I hate that python decided to go this route with operator overloading instead of clearly named methods a the standard. 

Except a few bytecode optimizations who barely make a difference there's 0 advantage for it

I used this once in a leetcode problem and that’s it lol

That's not a feature of Python!

Do not show it Guido, he’ll have nervous breakdown if not heart attack :)

This reminds me…

Theorem of Unforeseen Reuse: For any function f written with a single intended use case, there exists at least one other programmer who will apply f in a way its author never anticipated.

ඞ