In [33]:

    

%autosave 2
import numpy as np
# import timeit
# import profile
from time import sleep
import numba


    

    















    




Autosaving every 2 seconds

In [5]:

    

%timeit 3+4


    

    




14.4 ns ± 0.0229 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

In [8]:

    

%timeit sleep(1)


    

    




1 s ± 336 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

In [9]:

    

%%timeit
a = np.random.uniform(0,1,size=(10,10))
np.sum(a)


    

    




14.3 µs ± 69.7 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [13]:

    

n = int(1e5)
a = np.random.rand(n)
t = tuple(a)

def my_sum(t):
    s = 0
    for x in t:
        s += x
    return s

%timeit my_sum(t)
%timeit sum(t)
%timeit sum(a)
%timeit np.sum(a)


    

    




8.58 ms ± 14.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
6.96 ms ± 10.1 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
10.7 ms ± 13.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
74 µs ± 466 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [25]:

    

import base64
from functools import reduce

n = int(1e4)
lines = [base64.b64encode(np.random.bytes(16)) for _ in range(n)]
# 'abc' + 'def' 

def lines_cont(lines):
    cont = b''
    for line in lines:
        cont += line + b'\n'
    return cont

%timeit lines_cont(lines)
%timeit reduce(lambda x,y: x+b'\n'+y, lines)
%timeit b'\n'.join(lines)


    

    




73.8 ms ± 489 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)
163 ms ± 4.46 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
288 µs ± 881 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [37]:

    

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

@numba.jit(locals={'n': numba.int32, 's': numba.float32})
def numba_golden_ratio(n):
    s = 1
    for _ in range(n):
        s = 1 + 1/s
    return s

n = int(1e5)
%timeit golden_ratio(n)
%timeit numba_golden_ratio(n)


    

    




10.1 ms ± 13.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
919 µs ± 1.06 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [ ]: