Как стать автором
Обновить
2619.82
Рейтинг
RUVDS.com
VDS/VPS-хостинг. Скидка 10% по коду HABR10

Разработка чрезвычайно быстрых программ на Python

Блог компании RUVDS.comPythonПрограммирование
Перевод
Автор оригинала: Martin Heinz
Ненавистники Python всегда говорят, что одной из причин того, что они не хотят использовать этот язык, является то, что Python — это медленно. Но то, что некая программа, независимо от используемого языка программирования, может считаться быстрой или медленной, очень сильно зависит от разработчика, который её написал, от его знаний и от умения создавать оптимизированный и высокопроизводительный код.



Автор статьи, перевод которой мы сегодня публикуем, предлагает доказать то, что те, кто называет Python медленным, неправы. Он хочет рассказать о том, как улучшить производительность Python-программ и сделать их по-настоящему быстрыми.

Измерение времени и профилирование


Прежде чем приступить к оптимизации какого-либо кода, сначала надо выяснить то, какие его части замедляют всю программу. Иногда узкое место программы может быть очевидным, но если программист не знает, где оно находится, он может воспользоваться некоторыми возможностями по его выявлению.

Ниже представлен код программы, который я буду использовать в демонстрационных целях. Он взят из документации к Python. Этот код возводит e в степень x:

# slow_program.py
from decimal import *

def exp(x):
    getcontext().prec += 2
    i, lasts, s, fact, num = 0, 0, 1, 1, 1
    while s != lasts:
        lasts = s
        i += 1
        fact *= i
        num *= x
        s += num / fact
    getcontext().prec -= 2
    return +s

exp(Decimal(150))
exp(Decimal(400))
exp(Decimal(3000))

Самый лёгкий способ «профилирования» кода


Для начала рассмотрим самый простой способ профилирования кода. Так сказать, «профилирование для ленивых». Он заключается в использовании команды Unix time:

~ $ time python3.8 slow_program.py

real 0m11,058s
user 0m11,050s
sys  0m0,008s

Такое профилирование вполне может дать программисту некие полезные сведения — в том случае, если ему нужно замерить время выполнения всей программы. Но обычно этого недостаточно.

Самый точный способ профилирования


На другом конце спектра методов профилирования кода лежит инструмент cProfile, который даёт программисту, надо признать, слишком много сведений:

~ $ python3.8 -m cProfile -s time slow_program.py
         1297 function calls (1272 primitive calls) in 11.081 seconds

   Ordered by: internal time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        3   11.079    3.693   11.079    3.693 slow_program.py:4(exp)
        1    0.000    0.000    0.002    0.002 {built-in method _imp.create_dynamic}
      4/1    0.000    0.000   11.081   11.081 {built-in method builtins.exec}
        6    0.000    0.000    0.000    0.000 {built-in method __new__ of type object at 0x9d12c0}
        6    0.000    0.000    0.000    0.000 abc.py:132(__new__)
       23    0.000    0.000    0.000    0.000 _weakrefset.py:36(__init__)
      245    0.000    0.000    0.000    0.000 {built-in method builtins.getattr}
        2    0.000    0.000    0.000    0.000 {built-in method marshal.loads}
       10    0.000    0.000    0.000    0.000 <frozen importlib._bootstrap_external>:1233(find_spec)
      8/4    0.000    0.000    0.000    0.000 abc.py:196(__subclasscheck__)
       15    0.000    0.000    0.000    0.000 {built-in method posix.stat}
        6    0.000    0.000    0.000    0.000 {built-in method builtins.__build_class__}
        1    0.000    0.000    0.000    0.000 __init__.py:357(namedtuple)
       48    0.000    0.000    0.000    0.000 <frozen importlib._bootstrap_external>:57(_path_join)
       48    0.000    0.000    0.000    0.000 <frozen importlib._bootstrap_external>:59(<listcomp>)
        1    0.000    0.000   11.081   11.081 slow_program.py:1(<module>)

Тут мы запускаем исследуемый скрипт с использованием модуля cProfile и применяем аргумент time. В результате строки вывода упорядочены по внутреннему времени (cumtime). Это даёт нам очень много информации. На самом деле то, что показано выше, это лишь около 10% вывода cProfile.

Проанализировав эти данные, мы можем увидеть, что причиной медленной работы программы является функция exp (вот уж неожиданность!). После этого мы можем заняться профилированием кода, используя более точные инструменты.

Исследование временных показателей выполнения конкретной функции


Теперь мы знаем о том месте программы, куда нужно направить наше внимание. Поэтому мы можем решить заняться исследованием медленной функции, не профилируя другой код программы. Для этого можно воспользоваться простым декоратором:

def timeit_wrapper(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()  # В качестве альтернативы тут можно использовать time.process_time()
        func_return_val = func(*args, **kwargs)
        end = time.perf_counter()
        print('{0:<10}.{1:<8} : {2:<8}'.format(func.__module__, func.__name__, end - start))
        return func_return_val
    return wrapper

Этот декоратор можно применить к функции, которую нужно исследовать:

@timeit_wrapper
def exp(x):
    ...


print('{0:<10} {1:<8} {2:^8}'.format('module', 'function', 'time'))
exp(Decimal(150))
exp(Decimal(400))
exp(Decimal(3000))

Теперь после запуска программы мы получим следующие сведения:

~ $ python3.8 slow_program.py
module     function   time
__main__  .exp      : 0.003267502994276583
__main__  .exp      : 0.038535295985639095
__main__  .exp      : 11.728486061969306

Тут стоит обратить внимание на то, какое именно время мы планируем измерять. Соответствующий пакет предоставляет нам такие показатели, как time.perf_counter и time.process_time. Разница между ними заключается в том, что perf_counter возвращает абсолютное значение, в которое входит и то время, в течение которого процесс Python-программы не выполняется. Это значит, что на этот показатель может повлиять нагрузка на компьютер, создаваемая другими программами. Показатель process_time возвращает только пользовательское время (user time). В него не входит системное время (system time). Это даёт нам только сведения о времени выполнения нашего процесса.

Ускорение кода


А теперь переходим к самому интересному. Поработаем над ускорением программы. Я (по большей части) не собираюсь показывать тут всякие хаки, трюки и таинственные фрагменты кода, которые волшебным образом решают проблемы производительности. Я, в основном, хочу поговорить об общих идеях и стратегиях, которые, если ими пользоваться, могут очень сильно повлиять на производительность. В некоторых случаях речь идёт о 30% повышении скорости выполнения кода.

▍Используйте встроенные типы данных


Использование встроенных типов данных — это совершенно очевидный подход к ускорению кода. Встроенные типы данных чрезвычайно быстры, в особенности — если сравнить их с пользовательскими типами, вроде деревьев или связных списков. Дело тут, в основном, в том, что встроенные механизмы языка реализованы средствами C. Если описывать нечто средствами Python — нельзя добиться того же уровня производительности.

▍Применяйте кэширование (мемоизацию) с помощью lru_cache


Кэширование — популярный подход к повышению производительности кода. О нём я уже писал, но полагаю, что о нём стоит рассказать и здесь:

import functools
import time

# кэширование до 12 различных результатов
@functools.lru_cache(maxsize=12)
def slow_func(x):
    time.sleep(2)  # Имитируем длительные вычисления
    return x

slow_func(1)  # ... ждём 2 секунды до возврата результата
slow_func(1)  # результат уже кэширован - он возвращается немедленно!

slow_func(3)  # ... опять ждём 2 секунды до возврата результата

Вышеприведённая функция имитирует сложные вычисления, используя time.sleep. Когда её в первый раз вызывают с параметром 1 — она ждёт 2 секунды и возвращает результат только после этого. Когда же её снова вызывают с тем же параметром, оказывается, что результат её работы уже кэширован. Тело функции в такой ситуации не выполняется, а результат возвращается немедленно. Здесь можно найти примеры применения кэширования, более близкие к реальности.

▍Используйте локальные переменные


Применяя локальные переменные, мы учитываем скорость поиска переменной в каждой области видимости. Я говорю именно о «каждой области видимости», так как тут я имею в виду не только сопоставление скорости работы с локальными и глобальными переменными. На самом деле, разница в работе с переменными наблюдается даже, скажем, между локальными переменными в функции (самая высокая скорость), атрибутами уровня класса (например — self.name, это уже медленнее), и глобальными импортированными сущностями наподобие time.time (самый медленный из этих трёх механизмов).

Улучшить производительность можно, используя следующие подходы к присваиванию значений, которые несведущему человеку могут показаться совершенно ненужными и бесполезными:

#  Пример #1
class FastClass:

    def do_stuff(self):
        temp = self.value  # это ускорит цикл
        for i in range(10000):
            ...  # Выполняем тут некие операции с `temp`

#  Пример #2
import random

def fast_function():
    r = random.random
    for i in range(10000):
        print(r())  # здесь вызов `r()` быстрее, чем был бы вызов random.random()

▍Оборачивайте код в функции


Этот совет может показаться противоречащим здравому смыслу, так как при вызове функции в стек попадают некие данные и система испытывает дополнительную нагрузку, обрабатывая операцию возврата из функции. Однако эта рекомендация связана с предыдущей. Если вы просто поместите весь свой код в один файл, не оформив в виде функции, он будет выполняться гораздо медленнее из-за использования глобальных переменных. Это значит, что код можно ускорить, просто обернув его в функцию main() и один раз её вызвав:

def main():
    ...  # Весь код, который раньше был глобальным

main()

▍Не обращайтесь к атрибутам


Ещё один механизм, способный замедлить программу — это оператор точка (.), который используется для доступа к атрибутам объектов. Этот оператор вызывает выполнение процедуры поиска по словарю с использованием __getattribute__, что создаёт дополнительную нагрузку на систему. Как ограничить влияние этой особенности Python на производительность?

#  Медленно:
import re

def slow_func():
    for i in range(10000):
        re.findall(regex, line)  # Медленно!

#  Быстро:
from re import findall

def fast_func():
    for i in range(10000):
        findall(regex, line)  # Быстрее!

▍Остерегайтесь строк


Операции на строках могут сильно замедлить программу в том случае, если выполняются в циклах. В частности, речь идёт о форматировании строк с использованием %s и .format(). Можно ли их чем-то заменить? Если взглянуть на недавний твит Раймонда Хеттингера, то можно понять, что единственный механизм, который надо использовать в подобных ситуациях — это f-строки. Это — самый читабельный, лаконичный и самый быстрый метод форматирования строк. Вот, в соответствии с тем твитом, список методов, которые можно использовать для работы со строками — от самого быстрого к самому медленному:

f'{s} {t}'  # Быстро!
s + '  ' + t
' '.join((s, t))
'%s %s' % (s, t)
'{} {}'.format(s, t)
Template('$s $t').substitute(s=s, t=t)  # Медленно!

▍Знайте о том, что и генераторы могут работать быстро


Генераторы — это не те механизмы, которые, по своей природе, являются быстрыми. Дело в том, что они были созданы для выполнения «ленивых» вычислений, что экономит не время, а память. Однако экономия памяти может привести к тому, что программы будут выполняться быстрее. Как это возможно? Дело в том, что при обработке большого набора данных без использования генераторов (итераторов) данные могут привести к переполнению L1-кэша процессора, что значительно замедлит операции по поиску значений в памяти.

Если речь идёт о производительности, очень важно стремиться к тому, чтобы процессор мог бы быстро обращаться к обрабатываемым им данным, чтобы они находились бы как можно ближе к нему. А это значит, что такие данные должны помещаться в процессорном кэше. Этот вопрос затрагивается в данном выступлении Раймонда Хеттингера.

Итоги


Первое правило оптимизации заключается в том, что оптимизацией заниматься не нужно. Но если без оптимизации никак не обойтись, тогда я надеюсь, что советы, которыми я поделился, вам в этом помогут.

Уважаемые читатели! Как вы подходите к оптимизации производительности своего Python-кода?

Теги:Pythonразработка
Хабы: Блог компании RUVDS.com Python Программирование
Всего голосов 90: ↑83 и ↓7+76
Просмотры62K

Похожие публикации

Лучшие публикации за сутки