from timeit import timeit
from statistics import mean, stdev
from inspect import getattr_static

class Foo:
    @property
    def x(self) -> int:
        return 42

class Bar:
    x = 42

class WithParentClassX(Bar): ...

class Baz:
    def __init__(self):
        self.x = 42

class WithParentX(Baz): ...

class Missing: ...

class Slotted:
    __slots__ = ('x',)
    def __init__(self):
        self.x = 42

class Method:
    def x(self): ...

class ClsMethod:
    @classmethod
    def x(cls): ...

class StMethod:
    @staticmethod
    def x(): ...

import gc
gc.disable()

times = []
def stats():
    ts = [t * 1e8 for t in sorted(times)[:5]]
    return f'{round(mean(ts)):4} ± {round(stdev(ts)):2} ns '

def bench(obj):
    # Warmup:
    for _ in range(5):
        number = 100
        timeit(lambda: getattr_static(obj, 'x', None), number=number)

    # Actual bench:
    for _ in range(50):
        number = 1000
        t = timeit(lambda: getattr_static(obj, 'x', None), number=number) / number
        times.append(t)

    bench_name = (
        f'type[{obj.__name__}]'
        if isinstance(obj, type)
        else obj.__class__.__name__
    )
    print(f"{bench_name: <25}: {stats()}")
    times.clear()


bench(Foo)
bench(Foo())
bench(Bar)
bench(Bar())
bench(WithParentClassX())
bench(Baz())
bench(WithParentX())
bench(Missing)
bench(Missing())
bench(Slotted())
bench(Method())
bench(StMethod())
bench(ClsMethod())

type[Foo]                :   26 ±  1 ns 
Foo                      :   44 ±  0 ns 
type[Bar]                :   26 ±  0 ns 
Bar                      :   40 ±  0 ns 
WithParentClassX         :   52 ±  0 ns 
Baz                      :   49 ±  0 ns 
WithParentX              :   59 ±  0 ns 
type[Missing]            :   56 ±  0 ns 
Missing                  :   50 ±  0 ns 
Slotted                  :   57 ±  0 ns 
Method                   :   39 ±  0 ns 
StMethod                 :   39 ±  0 ns 
ClsMethod                :   39 ±  0 ns

type[Foo]                :   39 ±  0 ns 
Foo                      :   60 ±  1 ns 
type[Bar]                :   33 ±  0 ns 
Bar                      :   56 ±  0 ns 
WithParentClassX         :   79 ±  0 ns 
Baz                      :   72 ±  0 ns 
WithParentX              :   92 ±  0 ns 
type[Missing]            :   86 ±  0 ns 
Missing                  :   74 ±  0 ns 
Slotted                  :   74 ±  0 ns 
Method                   :   56 ±  0 ns 
StMethod                 :   56 ±  0 ns 
ClsMethod                :   56 ±  0 ns

type[Foo]                :   43 ±  0 ns 
Foo                      :   66 ±  1 ns 
type[Bar]                :   37 ±  0 ns 
Bar                      :   65 ±  0 ns 
WithParentClassX         :   91 ±  0 ns 
Baz                      :   84 ±  0 ns 
WithParentX              :  111 ±  0 ns 
type[Missing]            :  103 ±  0 ns 
Missing                  :   85 ±  0 ns 
Slotted                  :   78 ±  0 ns 
Method                   :   65 ±  0 ns 
StMethod                 :   65 ±  0 ns 
ClsMethod                :   65 ±  0 ns

from typing import Protocol, runtime_checkable

@runtime_checkable
class Foo(Protocol):
    a: int
    b: int
    c: int
    d: int
    e: int
    f: int
    g: int
    h: int
    i: int
    j: int
    k: int
    l: int
    m: int
    n: int
    o: int
    p: int
    q: int
    r: int
    s: int
    t: int
    u: int
    v: int
    w: int
    x: int
    y: int
    z: int

class Bar:
    def __init__(self):
        for attrname in 'abcdefghijklmnopqrstuvwxyz':
            setattr(self, attrname, 42)

bars = [Bar() for _ in range(100_000)]

import time
start = time.perf_counter()
for bar in bars:
    isinstance(bar, Foo)
print(time.perf_counter() - start)