In [1]:
%autosave 60
%matplotlib inline

Autosaving every 60 seconds
In [2]:
import matplotlib.pyplot as plt
import numpy as np
In [4]:
%timeit 3 + 5
%timeit 3 / 5

8.9 ns ± 0.0277 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
8.95 ns ± 0.0798 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)
In [6]:
%%timeit a = np.random.rand(1000)
a /= a.max()
np.sum(a)

25.7 µs ± 396 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
In [13]:
# import cProfile
from time import perf_counter_ns
from functools import wraps

def my_timeit(f):
    n = 1000
    
    @wraps(f)
    def timed_f(*args, **kwargs):
        t1 = perf_counter_ns()
        for _ in range(n):
            return_value = f(*args, **kwargs)
        dt = perf_counter_ns() - t1
        print(f'Execution time is {dt / n} ns')
        return return_value
    
    return timed_f


@my_timeit
def integrate(f, a, b, n):
    """Очень плохая функция"""
    x, dx = np.linspace(a, b, n, retstep=True, endpoint=False)
    s = 0
    for x_ in x:
        s += f(x_)
    return s * dx

integrate(lambda x: x**2, 0, 1, 1000)

Execution time is 730437.197 ns
Out[13]:
0.33283349999999995
In [16]:
%%timeit
for i in range(100_000_000):
    pass

2.39 s ± 8.11 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
In [17]:
%%timeit
li = []
for i in range(1000):
    li.append(i)

77.6 µs ± 252 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
In [18]:
%timeit li = [i for i in range(1000)]
%timeit li = list(range(1000))

34.9 µs ± 96.9 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
16.6 µs ± 97.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
In [19]:
%%timeit
li = []
for i in range(1000):
    li.append(i**3)

309 µs ± 443 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)
In [20]:
%timeit li = [i**3 for i in range(1000)]

275 µs ± 12.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
In [26]:
%%timeit
def double(x):
    return 2 * x

for i in range(1_000_000):
    double(i)

121 ms ± 395 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
In [27]:
%%timeit
for i in range(1_000_000):
    2 * i

58.1 ms ± 309 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
In [29]:
%timeit [2 * i for i in range(1_000_000)]

107 ms ± 2 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
In [32]:
n = 10

a = np.random.rand(n)
li = a.tolist()

%timeit [x + 1 for x in a]
%timeit [x + 1 for x in li]
%timeit a + 1
%timeit np.array(li) + 1

5.99 µs ± 28 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
829 ns ± 6.74 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
1.79 µs ± 4.69 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
4.66 µs ± 24.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
In [33]:
import math as m

%timeit m.sin(1)
%timeit np.sin(1)

130 ns ± 0.563 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
1.87 µs ± 9.35 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [36]:
from functools import reduce
from operator import add

n = 10_000

a = np.random.rand(n)
li = a.tolist()

%timeit sum(li)
%timeit np.sum(li)
%timeit np.sum(a)
%timeit reduce(lambda s, x: s + x, li)
%timeit reduce(add, li)

52.6 µs ± 506 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)
456 µs ± 2.35 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
16.5 µs ± 189 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
923 µs ± 10.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
528 µs ± 905 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)
In [35]:
%%timeit li = np.random.rand(n).tolist()

s = 0
for x in li:
    s += x

344 µs ± 16.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
In [45]:
from base64 import b64encode


def random_str(n=64):
    return b64encode(np.random.bytes(64)).decode()

li = [random_str() for _ in range(3)]
# print(f'{li[0]}\n{li[1]}\n{li[2]}')

s = li[0]
for x in li[1:]:
    s += f'\n{x}'
print(s)

dHT/tU988Dzjlxe8Ue3S02MlZRkWgd2/55VFtLXhfaCvxDZzSGO0m5Z4t47nKFJIuagej8uD1VPJrSG9B/i+Gg==
AE+uwAJTYTA2mBPOoy2HBLNXrsOADU5F8xTHIzjcj5ptYus5ehcFhD3ZUJsWmtMWN3amo5MQmFJe9Ih+0h4IrQ==
xKvgsuH38mbRC3D38Jb9C/GmrVHMn2WSIpcCHUPZGgjCg4SbVnpmqS8shCk2DvyMbTf8tct28KTGyHM3jQJFhg==
In [46]:
%%timeit li = [random_str() for _ in range(1000)]
s = li[0]
for x in li[1:]:
    s += f'\n{x}'

167 µs ± 1.11 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
In [52]:
%timeit reduce(add, li)  # не тот результат
%timeit reduce(lambda s, x: f'{s}\n{x}', li)

372 ns ± 1.91 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
562 ns ± 1.78 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
In [53]:
%timeit '\n'.join(li)

134 ns ± 0.987 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
In [59]:
import numba

def golden_ratio(n):
    s = 1.0
    for _ in range(n):
        s = 1.0 + 1.0 / s
    return s


@numba.jit
def golden_ratio_numba(n):
    s = 1
    for _ in range(n):
        s = 1 + 1 / s
    return s


%timeit golden_ratio(1_000_000)
golden_ratio_numba(1)
%timeit golden_ratio_numba(1_000_000)

68.8 ms ± 2.86 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
7.86 ms ± 2.19 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
In [63]:
def cont_frac(a):
    s = a[-1]
    for x in a[-2::-1]:
        s = x + 1.0 / s
    return s

cont_frac_numba = numba.jit(cont_frac, nopython=True)


a = np.ones(1000)


%timeit cont_frac(a)
%timeit cont_frac_numba(a)

342 µs ± 6.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
8.2 µs ± 13.7 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)
In [ ]: