I got curious about what actually is a blocker in terms of time complexity, for python. I’ve always known that the smaller the complexity the better, but it’s never quantitative. How bad is n^2? How bad is n^n? How much of an improvement is sqrt(n) or log(n)? What is outrageous to write and is absolutely no-go?

Either with pip:

pip install git+https://github.com/psf/black.git@1aa4d5b

Or with pipx, which looks like a python equivalent of npx, and allows direct runs without installation, or for multiple versions to co-exist:

pipx install git+https://github.com/psf/black.git@1aa4d5b

Ref: [1]

A bit of a hack. So that whenever there is a request, its response will be recorded:

@pytest.fixture(autouse=True)
def stripe_vcr(vcr, request):
    filename = f"{request.function.__module__}/{request.node.name}.yaml"
    with vcr._use_cassette(path=filename):
        yield

https://pytest-vcr.readthedocs.io/en/latest/configuration/#vcr

A string identifier is attached to every function at creation time

• Which is nice for debug:

>>> dance.__name__
'dance'

Functions capture local state

• Just like JavaScript, (lexical) closure:
• A closure remembers the values from its enclosing scope when it was created

To check whether something is callable

• Objects can be made callable, by being assigned function as value
• So, to check whether an object is callable:

>>> callable(foo)
True/False

Benefit of functions being first class

• We are able to abstract and pass around behaviours

2 Errors that were painful to debug.