scripts/datatypes_microbench.py at master · davidhyman/scripts · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
import dataclasses
import textwrap
from enum import IntEnum
from typing import NamedTuple, TypedDict


class EnumIndex(IntEnum):
    a = 0
    b = 1
    c = 2
    d = 3
    e = 4
    f = 5

class NTobj(NamedTuple):
    a: float
    b: float
    c: float
    d: float
    e: float
    f: float

@dataclasses.dataclass
class DCobj:
    a: float
    b: float
    c: float
    d: float
    e: float
    f: float

@dataclasses.dataclass(slots=True)
class DCSobj:
    a: float
    b: float
    c: float
    d: float
    e: float
    f: float

class TDobj(TypedDict):
    a: float
    b: float
    c: float
    d: float
    e: float
    f: float

def readattr(obj, items):
    x = None
    for item in items:
        x = getattr(obj, item)

def keys() -> tuple:
    return ('a', 'b', 'c', 'd', 'e', 'f')

def values() -> tuple:
    return (
        42, 43, 44, 1, 2, 3
    )

def result(task, entrant, score):
    print(f"{task:20s} | {entrant:16s} | {score:.4f}")

if __name__ == '__main__':
    import timeit

    # attribute access

    setup = textwrap.dedent("""
    k, v = keys(), values()
    target = DCobj(*v)
    """)
    t = timeit.timeit('[getattr(target, _) for _ in k]', setup=setup, number=10000, globals=globals())
    result('read every attribute', 'data class', t)

    setup = textwrap.dedent("""
    k, v = keys(), values()
    target = DCSobj(*v)
    """)
    t = timeit.timeit('[getattr(target, _) for _ in k]', setup=setup, number=10000, globals=globals())
    result('read every attribute','data class slots', t)

    setup = textwrap.dedent("""
    k, v = keys(), values()
    target = TDobj(dict(zip(k, v)))
    """)
    t = timeit.timeit('[target[_] for _ in k]', setup=setup, number=10000, globals=globals())
    result('read every attribute','typed dict', t)

    setup = textwrap.dedent("""
    k, v = keys(), values()
    target = NTobj(*v)
    """)
    t = timeit.timeit('[getattr(target, _) for _ in k]', setup=setup, number=10000, globals=globals())
    result('read every attribute','named tuple', t)

    setup = textwrap.dedent("""
    k, v = keys(), values()
    target = v
    """)
    t = timeit.timeit('[target[getattr(EnumIndex, _)] for _ in k]', setup=setup, number=10000, globals=globals())
    result('read every attribute','enum lookup', t)

    # creating many instances
    setup = textwrap.dedent("""
    k, v = keys(), [values() for v in range(100)]
    """)
    t = timeit.timeit('[DCobj(*_) for _ in v]', setup=setup, number=10000, globals=globals())
    result('make 100 instances','data class', t)

    t = timeit.timeit('[DCSobj(*_) for _ in v]', setup=setup, number=10000, globals=globals())
    result('make 100 instances','data class slots', t)

    t = timeit.timeit('[TDobj(zip(k, _)) for _ in v]', setup=setup, number=10000, globals=globals())
    result('make 100 instances','typed dict', t)

    t = timeit.timeit('[NTobj(*_) for _ in v]', setup=setup, number=10000, globals=globals())
    result('make 100 instances','named tuple', t)

    t = timeit.timeit('[_ for _ in v]', setup=setup, number=10000, globals=globals())
    result('make 100 instances','tuple (baseline)', t)