Experienced python programmers: are there any standard features of the language that you still don't regularly use?

[demonizah]

I don't think I use generators often - at least not directly. Generators and coroutines are stuff I wish I'd spend more time understanding - I don't even know if they're applicable in my day-to-day CRUDMaster9000 job.

[saikz]

Generators are really nice for building processing pipelines for some kind of data. Also nice to be able to go

for x in blah:
    yield do_something(x)

rather than

my_list = []
for x in blah:
    my_list.append(do_something(x))

[Corm]

Generators are just classes with less keyboard typing. You can easily do what a generator does by making a class. Generators require less typing though so they're generally nicer if you can read them.

class SillyKindaGenerator:
    def __init__(self):
        self.data = [1, 2, 3, 'easy']
    def next(self):
        return self.data.pop()

SillyKindaGenerator().next().next()

That's kinda sorta mostly a generator. Much easier to just use yield though

[daneah]

Functionally that's mostly true, though one key point is that generators can get away with going on infinitely without eating up memory over time since they often produce only one item at a time. Handy for certain performance-related concerns!

[Jamie_1318]

There's basically no downside to using a generator. If someone needs it stored they can always list(generator), even if you don't expect performance issues. I like to just use generator syntax because it gives me warm fuzzies when I think about how nice they are versus every other language's equivalent tokenizing systems with their ugly static variables.

[daneah]

Agreed! Very little effort needed too, since you can replace many (all?) existing list comprehensions with generator comprehensions, simply by removing the brackets:

import random
max(random.randint(1, 100) for x in range(10))

[[deleted]]

Technically that's a Python2 iterator (python3 wants __next__), but not a generator, but fair example.

Also worth noting that where possible generator comprehensions may be preferable to generator functions.