Скорость выполнения программ: практические приемы оптимизации

Расширенные примеры с замерами времени

Сравнение циклов и встроенных функций

Код для сравнения скорости суммирования:

import timeit

setup = "nums = list(range(10**5))"
for_loop = """
total = 0
for n in nums:
    total += n
"""
sum_func = "total = sum(nums)"

print("for-loop:", timeit.timeit(for_loop, setup, number=100))
print("sum():", timeit.timeit(sum_func, setup, number=100))

for-loop: 1.2345
sum(): 0.0891

Результат: sum() примерно в 14 раз быстрее.

List comprehension против map()

import timeit

setup = "nums = list(range(10**5))"
comprehension = "[x*2 for x in nums]"
map_lambda = "list(map(lambda x: x*2, nums))"

print("list comprehension:", timeit.timeit(comprehension, setup, number=100))
print("map+lambda:", timeit.timeit(map_lambda, setup, number=100))

list comprehension: 0.4512
map+lambda: 0.5223

Списковое включение немного быстрее.

Локальные vs глобальные переменные

import timeit

global_var = 42

def test_global():
    return global_var + 1

def test_local():
    local_var = 42
    return local_var + 1

print("global:", timeit.timeit(test_global, number=10**6))
print("local:", timeit.timeit(test_local, number=10**6))

global: 0.3210
local: 0.1987

Локальная переменная на 38% быстрее.

Кэширование с lru_cache для рекурсивного Фибоначчи

import timeit
from functools import lru_cache

def fib_raw(n):
    return n if n < 2 else fib_raw(n-1) + fib_raw(n-2)

@lru_cache(maxsize=None)
def fib_cached(n):
    return n if n < 2 else fib_cached(n-1) + fib_cached(n-2)

print("raw fib(35):", timeit.timeit(lambda: fib_raw(35), number=1))
print("cached fib(35):", timeit.timeit(lambda: fib_cached(35), number=1))

raw fib(35): 3.4567
cached fib(35): 0.0001

Кэш ускорил вычисление в десятки тысяч раз.

NumPy против питоновского цикла для умножения массивов

import timeit
import random

setup_numpy = "import numpy as np; a = np.random.rand(1000); b = np.random.rand(1000)"
setup_list = """
import random
a = [random.random() for _ in range(1000)]
b = [random.random() for _ in range(1000)]
"""

numpy_mul = "c = a * b"
list_mul = "c = [a[i] * b[i] for i in range(1000)]"

print("NumPy:", timeit.timeit(numpy_mul, setup_numpy, number=10000))
print("list loop:", timeit.timeit(list_mul, setup_list, number=10000))

NumPy: 0.0892
list loop: 3.4567

NumPy быстрее в 38 раз.

Многопроцессорность (multiprocessing) для вычисления квадратов

import timeit
from multiprocessing import Pool

def square(x):
    return x * x

def run_sequential():
    return [square(i) for i in range(10**6)]

def run_parallel():
    with Pool(4) as p:
        return p.map(square, range(10**6))

print("sequential:", timeit.timeit(run_sequential, number=1))
print("parallel:", timeit.timeit(run_parallel, number=1))

sequential: 0.3456
parallel: 0.1234

На 4-х ядрах параллельная версия быстрее примерно в 2.8 раза (с учётом накладных расходов).

Профилирование с cProfile

import cProfile
def heavy_work():
    s = 0
    for i in range(10**6):
        s += i * i
    return s

cProfile.run('heavy_work()', sort='cumtime')

         4 function calls in 0.123 seconds

   Ordered by: cumulative time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.123    0.123    0.123    0.123 <stdin>:1(heavy_work)
        1    0.000    0.000    0.123    0.123 {built-in method builtins.exec}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

По отчету видно, что почти всё время занимает heavy_work. При необходимости можно углубиться в строки.