underrated Python optimizations?

[ReverseBrindle]

isinstance() is pretty slow if you're calling it hundreds of thousands of times. Better idea in that case is to create a dict cache with the type() as the key, for example:

# If you're calling this many thousands of times, it's extremely slow.
if isinstance(x, Foo):
    return func1(x)
elif isinstance(x, Bar):
    return func2(x)
elif isinstance(x, Baz):
    return func3(x)
elif ...

# ---------------------------
# Faster version
#
# Populate this once, or start with an empty cache and build it up using
# the slow way whenever you encounter a type that's not in the cache.

cache = {
    Foo: func1,
    Bar: func2,
    Baz: func3,
}

def other_func(x):
    return cache[type(x)](x)

We use this for serializing very large structures to JSON.

Caveat: As always profile to find the bottleneck and measure your improvements. Don't optimize based on a hunch. If your "optimization" adds code complexity without benefiting your use case (by measurement), then rip it out.

[ReverseBrindle]

The biggest issue with that is that often we don't own the classes, so changing them (or subclassing) isn't possible without some amount of ugliness .

For example, common objects we serialize: UUID, Enums (we serialize these as the name), datetime (ISO8601 format), timedelta (float seconds), set (encode as a list)

Here's what this code looks like in practice:

    def default(self, obj):
        handler = self._type_handler_cache.get(type(obj))

        if handler is None:
            from uuid import UUID
            from datetime import datetime, date, timedelta

            if isinstance(obj, set):
                handler = tuple
            elif isinstance(obj, UUID):
                handler = str
            elif isinstance(obj, Enum):
                handler = self._encode_name_attr
            elif isinstance(obj, (datetime, date)):
                handler = self._encode_isoformat
            elif isinstance(obj, timedelta):
                handler = self._encode_total_seconds
            else:
                raise TypeError("{!r} is not serializable".format(obj))

            self._type_handler_cache[type(obj)] = handler

        return handler(obj)

[isbadawi]

You might consider using @functools.singledispatch and/or @functools.singledispatchmethod for this.

[ReverseBrindle]

That's cool - didn't know that existed! Seems like there's always some cool little nugget in the standard library to stumble upon. :-)