Uitvoeringstijd onderzoeken

Efficiënte Python-code schrijven

Logan Thomas

Scientific Software Technical Trainer, Enthought

Waarom code timen?

Helpt ons de optimale code-aanpak te kiezen
Snellere code == efficiëntere code!

Hoe timen we code?

Berekent looptijd met de IPython magic-opdracht %timeit
Magic-opdrachten: uitbreidingen bovenop de normale Python-syntax
- Voorafgegaan door het teken "%"
- Link naar docs (hier)
- Zie alle beschikbare magic-opdrachten met %lsmagic

%timeit gebruiken

Code om te timen

import numpy as np

rand_nums = np.random.rand(1000)

Timen met %timeit

%timeit rand_nums = np.random.rand(1000)

8.61 µs ± 69.1 ns per loop (gem. ± std. dev. van 7 runs, 100000 loops elk)

%timeit-uitvoer

alt="Uitvoer van magic-opdracht timeit"

%timeit-uitvoer

alt="Uitvoer van magic-opdracht timeit met gemiddelde en standaarddeviatie gemarkeerd"

%timeit-uitvoer

alt="Uitvoer van magic-opdracht timeit met aantal runs en aantal loops gemarkeerd"

Aantal runs/loops opgeven

Het aantal runs (-r) en/of loops (-n) instellen

# Aantal runs op 2 zetten (-r2)
# Aantal loops op 10 zetten (-n10)

%timeit -r2 -n10 rand_nums = np.random.rand(1000)

16.9 µs ± 5.14 µs per loop (gem. ± std. dev. van 2 runs, 10 loops elk)

%timeit in line magic-modus gebruiken

Line magic (%timeit)

# Eén regel code

%timeit nums = [x for x in range(10)]

914 ns ± 7.33 ns per loop (gem. ± std. dev. van 7 runs, 1000000 loops elk)

%timeit in cell magic-modus gebruiken

Cell magic (%%timeit)

# Meerdere regels code

%%timeit
nums = []
for x in range(10):
    nums.append(x)

1.17 µs ± 3.26 ns per loop (gem. ± std. dev. van 7 runs, 1000000 loops elk)

Uitvoer opslaan

De uitvoer in een variabele opslaan (-o)

times = %timeit -o rand_nums = np.random.rand(1000)

8.69 µs ± 91.4 ns per loop (gem. ± std. dev. van 7 runs, 100000 loops elk)

times.timings

[8.697893059998023e-06,
 8.651204760008113e-06,
 8.634270530001232e-06,
 8.66847825998775e-06,
 8.619398139999247e-06,
 8.902550710008654e-06,
 8.633500570012985e-06]

times.best

8.619398139999247e-06

times.worst

8.902550710008654e-06

Tijden vergelijken

Python-datastructuren kun je maken met de formele naam

formal_list = list()
formal_dict = dict()
formal_tuple = tuple()

Python-datastructuren kun je maken met letterlijke syntax

literal_list = []
literal_dict = {}
literal_tuple = ()

f_time = %timeit -o formal_dict = dict()

145 ns ± 1.5 ns per loop (gem. ± std. dev. van 7 runs, 10000000 loops elk)

l_time = %timeit -o literal_dict = {}

93.3 ns ± 1.88 ns per loop (gem. ± std. dev. van 7 runs, 10000000 loops elk)

diff = (f_time.average - l_time.average) * (10**9)
print('l_time beter dan f_time met {} ns'.format(diff))

l_time beter dan f_time met 51.90819192857814 ns

Tijden vergelijken

%timeit formal_dict = dict()

145 ns ± 1.5 ns per loop (gem. ± std. dev. van 7 runs, 10000000 loops elk)

%timeit literal_dict = {}

93.3 ns ± 1.88 ns per loop (gem. ± std. dev. van 7 runs, 10000000 loops elk)

Klaar voor de start!

Efficiënte Python-code schrijven