Как ускорить python 3
Перейти к содержимому

Как ускорить python 3

  • автор:

Приёмы для ускорения кода на Python

Для ускорения кода на Python программисты могут использовать много приемов. Мы собрали несколько самых простых и при этом самых эффективных из них.

Python – один из самых популярных языков программирования в мире. Этим он обязан своему простому синтаксису и богатой экосистеме. В последнее время он используется в соревновательном программировании, где большое значение имеет скорость выполнения программ.

Большинство из наших читателей, вероятно, уже начали писать на Python. Сперва всё кажется простым и очевидным. Но при решении задач со сложными алгоритмами начинается головная боль с Time Limit Exceeded . Однако, в этом нет вины Python – это вина программиста. Да, Python медленный, но если программист напишет эффективную программу, она точно выполнится без подобных загвоздок.

Представляем вам несколько приемов и подходов для ускорения кода и повышения его эффективности.

Используйте подходящие структуры данных

Применение правильных структур данных значительно ускоряет выполнение кода.

В Python встроены такие структуры данных, как список ( list ), кортеж ( tuple ), множество ( set ) и словарь ( dictionary ). Несмотря на это, большинство людей хорошо помнят только про списки. Это неправильный подход.

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

Избегайте циклов for

В случаях, когда цикл for обрабатывает диапазон непостоянного размера, его выполнение в Python происходит медленнее, чем выполнение цикла while . Поэтому в таких случаях лучше прибегайте к while .

Применяйте списковые включения (list comprehension)

Не обращайтесь ни к какой другой технике, если можно использовать списковые включения. Например, этот код заносит в список все числа между 1 и 1000, кратные 3:

L = [] for i in range (1, 1000): if i%3 == 0: L.append (i)

Со списковыми включениями код трансформируется в одну строку:

L = [i for i in range (1, 1000) if i%3 == 0]

Этот приём работает быстрее, чем просто метод append() .

Не пренебрегайте множественным присваиванием

Не стоит инициализировать несколько переменных так:

a = 2 b = 3 c = 5 d = 7

Лучше придерживайтесь следующего синтаксиса:

a, b, c, d = 2, 3, 5, 7

[python_ad_block]

Не создавайте глобальные переменные

Да, в Python есть ключевое слово global для объявления таких переменных. Но операции с ними требуют больше времени, чем с локальными. Потому не создавайте глобальные переменные без крайней необходимости.

Применяйте библиотечные функции

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

Соединяйте строки методом join

В Python конкатенацию строк можно производить при помощи знака + .

concatenatedString = "Программирование " + "это " + "весело."

Но также для этого есть метод join() .

concatenatedString = " ".join (["Программирование", "это", "весело."])

Всё дело в том, что оператор + каждый раз создаёт новую строку, а затем копирует в неё исходные. join() устроен иначе и обеспечивает выигрыш во времени.

Используйте генераторы

Если у вас в списке хранится много данных, которые требуется использовать все за раз, применяйте generator . Это сэкономит ваше время.

Будьте бдительны

Взгляните на следующий код:

L = [] for element in set(L): .

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

for element in L: .

Избегайте точек

Старайтесь не пользоваться ими. Взгляните на пример:

import math val = math.sqrt(60)

Вместо этого можно применить следующий синтаксис:

from math import sqrt val = sqrt(60)

Всё потому, что когда вы вызываете функцию с помощью точки, она сперва обращается к методу __getattribute()__ или __getattr()__ . Эти методы, в свою очередь, используют операции со словарями, отнимающие время. Поэтому старайтесь писать: from module import function .

Используйте 1 в бесконечных циклах

Пишите while 1 вместо while True . Это выиграет вам немного времени.

Попробуйте другие подходы

Не бойтесь применять новые практики для повышения эффективности кода.

Допустим, у вас есть код:

if a_condition: if another_condition: do_something else: raise exception

Вместо этого стоит попробовать:

if (not a_condition) or (not another_condition): raise exception do_something

Используйте ускорители

Медлительность Python послужила вдохновением для различных проектов, сокращающих его время работы. На большинстве соревнований по программированию вы встретитесь с pypy (там, где можно писать на Python).

Эти средства помогут уменьшить время выполнения Python-программ.

Для больших датасетов используйте специальные библиотеки

C/C++ быстрее Python. Поэтому многие пакеты и модули, которые можно использовать в программах на Python, пишутся на C/C++. Среди таких модулей – Numpy, Scipy и Pandas, столь необходимые при обработке больших массивов данных.

Используйте последнюю версию Python

Python регулярно обновляется и совершенствуется и с каждым релизом становится всё быстрее и оптимизированнее. Поэтому для ускорения кода всегда пишите его на новейшей версии языка.

Заключение

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

Как ускорить ваш код на Python

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

Одной из основных причин его популярности является простота и удобочитаемость, что облегчает разработчикам написание и понимание кода. Однако одним из недостатков Python является его производительность, которая относительно ниже по сравнению с другими языками программирования, такими как C или Java. Поэтому очень важно писать эффективный код для обеспечения оптимальной производительности.

В этой статье мы рассмотрим некоторые советы и рекомендации о том, как писать более качественный и эффективный код на Python. Эти методы могут помочь вам оптимизировать код, сократить время его выполнения и улучшить его общее состояние. Давайте начинать!

1. Использование понимания списков

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

squares = [] for i in range(10): squares.append(i**2)

Этот код создает список квадратов чисел от 0 до 9, используя цикл for. Мы можем переписать его, используя понимание списка, следующим образом:

squares = [i**2 for i in range(10)]

Этот код более лаконичен и легче читается, и он делает то же самое, что и предыдущий. Более того, понимание списка происходит быстрее, чем использование цикла for, особенно для больших списков.

2. Использование генераторов вместо списков

В Python генератор — это тип итератора, который генерирует последовательность значений на лету. Генераторы более эффективно используют память, чем списки, потому что они не сохраняют все значения в памяти сразу. Вместо этого они генерируют значения одно за другим по мере необходимости, что может значительно сократить объем памяти, занимаемый вашим кодом. Например, рассмотрим следующий код:

numbers = [1, 2, 3, 4, 5] def square_numbers(numbers): result = [] for number in numbers: result.append(number**2) return result squared_numbers = square_numbers(numbers)

Этот код создает список квадратов чисел в списке numbers, используя цикл for. Мы можем переписать этот код с помощью генератора следующим образом:

numbers = [1, 2, 3, 4, 5] def square_numbers(numbers): for number in numbers: yield number**2 squared_numbers = square_numbers(numbers)

Этот код использует генератор вместо списка для генерации квадратов чисел в списке numbers. Ключевое слово yield используется для генерации каждого значения на лету, что может уменьшить объем памяти, занимаемой кодом. Более того, генераторы часто работают быстрее, чем списки для больших наборов данных.

3. Использование функции enumerate()

Функция enumerate()— это встроенная функция Python, которая позволяет перебирать последовательность (например, список или кортеж) и отслеживать индекс текущего элемента. Функция возвращает кортеж вида (index, value), где index— индекс текущего элемента, а value— значение текущего элемента. Эта функция может быть очень полезна, когда вам нужно перебрать последовательность, а также отслеживать индекс текущего элемента. Например, рассмотрим следующий код:

fruits = [‘apple’, ‘banana’, ‘cherry’, ‘date’] for i in range(len(fruits)): print(i, fruits[i])

Этот код выполняет итерацию по списку fruits и выводит индекс и значение каждого элемента в списке. Мы можем переписать этот код с помощью функции enumerate() следующим образом:

fruits = [‘apple’, ‘banana’, ‘cherry’, ‘date’] for i, fruit in enumerate(fruits): print(i, fruit)

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

4. Использование функции zip()

Функция zip()— это еще одна встроенная функция Python, которая позволяет вам параллельно перебирать несколько последовательностей (таких как списки или кортежи). Функция возвращает кортеж вида (value1, value2, . ), где value1— значение текущего элемента в первой последовательности, value2— значение текущего элемента во второй последовательности и так далее. Эта функция может быть очень полезна, когда вам нужно параллельно перебирать несколько последовательностей и обрабатывать их значения вместе. Рассмотрим следующий код:

names = [‘Alice’, ‘Bob’, ‘Charlie’] ages = [25, 30, 35] for i in range(len(names)): print(names[i], ages[i])

Этот код перебирает списки names и ages, перечисляет их элементы и выводит имя и возраст каждого человека. Мы можем переписать этот код с помощью функции zip() следующим образом:

names = [‘Alice’, ‘Bob’, ‘Charlie’] ages = [25, 30, 35] for name, age in zip(names, ages): print(name, age)

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

5. Использование оператора in для проверки членства

Оператор in— это встроенный оператор Python, позволяющий проверить, является ли элемент членом последовательности (например, списка или кортежа). Оператор возвращает значение True, если элемент находится в последовательности и False в противном случае. Этот оператор может быть очень полезен, когда вам нужно проверить, находится ли элемент в последовательности перед его обработкой. Например, рассмотрим следующий код:

numbers = [1, 2, 3, 4, 5] if len(numbers) > 0: first_number = numbers[0] else: first_number = None

Этот код проверяет, не пуст ли список numbers, и присваивает переменной first_number значение первого элемента. Мы можем переписать этот код с помощью оператора in следующим образом:

numbers = [1, 2, 3, 4, 5] if numbers: first_number = numbers[0] else: first_number = None

В этом коде используется оператор in, чтобы проверить, не пуст ли список numbers перед его обработкой. Он более лаконичен и легче читается, чем предыдущий код, но делает то же самое.

6. Использование аргументов функций вместо глобальных переменных

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

Рассмотрим следующий пример:

total = 0 def add_numbers(numbers): global total for number in numbers: total += number return total result = add_numbers([1, 2, 3, 4, 5]) print(result)

Этот код определяет глобальную переменную total и функцию add_numbers, которая добавляет к переменной значения списка чисел total. Затем функция возвращает значение переменной total. Этот код работает, но у него есть несколько проблем. Во-первых, он использует глобальную переменную, что может быть проблематично в больших программах. Во-вторых, он изменяет глобальную переменную внутри функции, что может затруднить анализ поведения кода.

Мы можем переписать этот код, используя аргументы функции, следующим образом:

def add_numbers(numbers): total = 0 for number in numbers: total += number return total result = add_numbers([1, 2, 3, 4, 5]) print(result)

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

7. Использование списковых включений

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

new_list = [expression for item in iterable if condition]

где expression— выражение, которое оценивается для каждого элемента в iterable, item— текущий элемент в iterable, и condition— необязательное условие, фильтрующее элементы, включенные в новый список. Рассмотрим следующий код:

numbers = [1, 2, 3, 4, 5] squares = [] for number in numbers: square = number ** 2 squares.append(square) print(squares)

Этот код создает список квадратов чисел в списке numbers. Мы можем переписать этот код следующим образом:

numbers = [1, 2, 3, 4, 5] squares = [number ** 2 for number in numbers]

Этот код более лаконичен и легче читается, чем предыдущий код, и он делает то же самое.

8. Использование выражений-генераторов

Выражения-генераторы похожи на генераторы списков, но вместо списков они создают генераторы. Генераторы — это объекты, которые генерируют значения на лету и более эффективно используют память, чем списки. Синтаксис выражения генератора такой же, как у генератора списка, но вместо квадратных скобок используются круглые. Например, рассмотрим следующий код:

numbers = [1, 2, 3, 4, 5] squares = (number ** 2 for number in numbers) for square in squares: print(square)

Этот код создает генератор, который генерирует квадраты чисел в списке numbers и перебирает генератор для вывода квадратов. Мы можем переписать этот код следующим образом:

numbers = [1, 2, 3, 4, 5] squares = [number ** 2 for number in numbers] for square in squares: print(square)

Этот код использует понимание списка для создания списка квадратов чисел в списке numbers, а затем выполняет итерацию по списку для вывода квадратов. Этот код работает, но он создает список в памяти, что может быть неэффективно для больших наборов данных. Мы можем переписать этот код, используя выражение-генератор, следующим образом:

numbers = [1, 2, 3, 4, 5] squares = (number ** 2 for number in numbers) for square in squares: print(square)

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

9. Использование функции map

Функция map— это встроенная в Python функция, которая применяет функцию к каждому элементу итерируемого объекта и возвращает новый итерируемый объект с результатами. Синтаксис функции map следующий:

map(function, iterable)

где function— функция, применяемая к каждому элементу массива iterable, и iterable— итерация, к которой применяется функция. Например, рассмотрим следующий код:

numbers = [1, 2, 3, 4, 5] def square(number): return number ** 2 squares = map(square, numbers) for square in squares: print(square)

Этот код использует функцию map для применения функции square к каждому числу в списке numbers и создания новой итерации квадратов. Этот код более лаконичен и легче читается, чем предыдущий.

10. Использование функции filter

Функция filter— это встроенная в Python функция, которая фильтрует итерируемый объект на основе функции, возвращающей логическое значение. Синтаксис функции filter следующий:

filter(function, iterable)

где function — функция , которая фильтрует iterable, а iterable является итератором для фильтрации. Например, рассмотрим следующий код:

numbers = [1, 2, 3, 4, 5] def is_even(number): return number % 2 == 0 evens = filter(is_even, numbers) for even in evens: print(even)

Этот код использует функцию filter для фильтрации списка numbers на основе функции is_even и создания новой итерации четных чисел. Этот код более лаконичен и легче читается, чем предыдущий код, но делает он то же самое.

Заключение

В этой статье мы обсудили некоторые советы и рекомендации по написанию лучшего и более эффективного кода Python. Эти советы и рекомендации включают в себя использование функции enumerate, функции zip и других встроенных функций, таких как понимание списков, выражения-генератора, map и filter. Используя эти методы, вы можете писать более краткий, модульный и читаемый код, который также является более эффективным и масштабируемым.

Однако написание эффективного кода Python — это не только использование правильных методов. Это также требует хороших методов программирования, таких как написание ясного и лаконичного кода, использование осмысленных имен переменных и функций, комментирование кода и регулярное его тестирование. Следуя этим практикам и используя методы, которые мы обсуждали в этой статье, вы можете стать более эффективным и действенным программистом на Python.

Как ускорить код на Python в тысячу раз

В любых соревнованиях по скорости выполнения программ Python обычно занимает последние места. Кто-то говорит, что это из-за того, что Python является интерпретируемым языком. Все интерпретируемые языки медленные. Но мы знаем, что Java тоже язык такого типа, её байткод интерпретируется JVM. Как показано, в этом бенчмарке, Java намного быстрее, чем Python.

Вот пример, способный показать медленность Python. Используем традиционный цикл for для получения обратных величин:

import numpy as np np.random.seed(0) values = np.random.randint(1, 100, size=1000000) def get_reciprocal(values): output = np.empty(len(values)) for i in range(len(values)): output[i] = 1.0/values[i] %timeit get_reciprocal(values)

3,37 с ± 582 мс на цикл (среднее значение ± стандартное отклонение после 7 прогонов по 1 циклу)

Ничего себе, на вычисление всего 1 000 000 обратных величин требуется 3,37 с. Та же логика на C выполняется за считанные мгновения: 9 мс; C# требуется 19 мс; Nodejs требуется 26 мс; Java требуется 5 мс(!), а Python требуется аж целых 3,37 СЕКУНДЫ. (Весь код тестов приведён в конце).

Первопричина такой медленности

Обычно мы называем Python языком программирования с динамической типизацией. В программе на Python всё представляет собой объекты; иными словами, каждый раз, когда код на Python обрабатывает данные, ему нужно распаковывать обёртку объекта. Внутри цикла for каждой итерации требуется распаковывать объекты, проверять тип и вычислять обратную величину. Все эти 3 секунды тратятся на проверку типов.

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

Даже простое присвоение числового значения — это долгий процесс.

a = 1

Шаг 1. Задаём a->PyObject_HEAD->typecode тип integer

Шаг 2. Присваиваем a->val =1

Подробнее о том, почему Python медленный, стоит прочитать в чудесной статье Джейка: Why Python is Slow: Looking Under the Hood

Итак, существует ли способ, позволяющий обойти проверку типов, а значит, и повысить производительность?

Решение: универсальные функции NumPy

В отличие list языка Python, массив NumPy — это объект, созданный на основе массива C. Доступ к элементу в NumPy не требует шагов для проверки типов. Это даёт нам намёк на решение, а именно на Universal Functions (универсальные функции) NumPy, или UFunc.

Если вкратце, благодаря UFunc мы можем проделывать арифметические операции непосредственно с целым массивом. Перепишем первый медленный пример на Python в версию на UFunc, она будет выглядеть так:

import numpy as np np.random.seed(0) values = np.random.randint(1, 100, size=1000000) %timeit result = 1.0/values

Это преобразование не только повышает скорость, но и укорачивает код. Отгадаете, сколько теперь времени занимает его выполнение? 2,7 мс — быстрее, чем все упомянутые выше языки:

2,71 мс ± 50,8 мкс на цикл (среднее значение ± стандартное отклонение после =7 прогонов по 100 циклов каждый)

Вернёмся к коду: самое важное здесь — это 1.0/values . values — это не число, а массив NumPy. Наряду с оператором деления есть множество других.

Здесь можно найти все операторы Ufunc.

Подводим итог

Если вы пользуетесь Python, то высока вероятность того, что вы работаете с данными и числами. Эти данные можно хранить в NumPy или DataFrame библиотеки Pandas, поскольку DataFrame реализован на основе NumPy. То есть с ним тоже работает Ufunc.

UFunc позволяет нам выполнять в Python повторяющиеся операции быстрее на порядки величин. Самый медленный Python может быть даже быстрее языка C. И это здорово.

Приложение — код тестов на C, C#, Java и NodeJS

#include #include #include int main() < struct timeval stop, start; int length = 1000000; int rand_array[length]; float output_array[length]; for(int i = 0; igettimeofday(&start, NULL); for(int i = 0; i gettimeofday(&stop, NULL); printf("took %lu us\n", (stop.tv_sec - start.tv_sec) * 1000000 + stop.tv_usec - start.tv_usec); printf("done\n"); return 0; >
using System; namespace speed_test < class Program< static void Main(string[] args)< int length = 1000000; double[] rand_array =new double[length]; double[] output = new double[length]; var rand = new Random(); for(int i =0; ilong start = DateTimeOffset.Now.ToUnixTimeMilliseconds(); for(int i =0;i long end = DateTimeOffset.Now.ToUnixTimeMilliseconds(); Console.WriteLine(end - start); > > >
import java.util.Random; public class speed_test < public static void main(String[] args)< int length = 1000000; long[] rand_array = new long[length]; double[] output = new double[length]; Random rand = new Random (); for(int i =0; ilong start = System.currentTimeMillis(); for(int i = 0;i long end = System.currentTimeMillis(); System.out.println(end - start); > >
let length = 1000000; let rand_array = []; let output = []; for(var i=0;i let start = (new Date()).getMilliseconds(); for(var i=0;i let end = (new Date()).getMilliseconds(); console.log(end - start);
На правах рекламы

Воплощайте любые идеи и проекты с помощью наших VDS с мгновенной активацией на Linux или Windows. Создавайте собственный конфиг в течение минуты!

  • Python
  • скорость выполнения

Как ускорить приложения на Python

Рассказываем, как проанализировать и ускорить имеющийся код на Python, чтобы приложение работало так же быстро, как на C++.

На Python пишут как десктопные программы, так и высокопрофессиональные web-приложения. Он является интерпретируемым языком и благодаря этому можно использовать продвинутые инструменты. Например, интроспекцию и метапрограммирование.

Но Python накладывает и некоторые ограничения, одно из них — снижение скорости работы по сравнению с программами, написанными на компилируемых языках программирования (C++ и др).

Аватарка эксперта Андрей Смирнов

Андрей Смирнов
Python-разработчик, преподаватель по финансовой грамотности в Московской школе программистов (МШП)

В статье я разберу интересный кейс, чтобы проанализировать и ускорить имеющийся код на Python.

Исходные данные (демо-приложение)

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

А в качестве стартового кода мы возьмём задачу: имеется магазин, продающий определенные товары. Товар характеризуется тремя величинами: название, цена, валюта. Необходимо реализовать хранилище товаров, заполнить его некими товарами.

На языке Python такая задача решается быстро:

Как ускорить приложения на Python 1

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

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

Казалось бы, необходимо оптимизировать код, но как понять, что именно необходимо менять? Для этого нужно собрать с приложения определённые метрики, показывающие, насколько хорошо оно работает.

Процесс сбора этих метрик называется профилированием приложения. Проводить процесс профилирования можно как по времени работы, так и по памяти.

Профилирование по времени

Сначала добавим в нашу программу измерение скорости её работы. Для этого в Python есть специальная функция time, находящаяся в одноименном модуле. Идея использования этой функции очень проста: мы изменяем текущее время в начале работы программы и в конце. Далее считаем дельту, которая будет являться длительностью работы программы.

Как ускорить приложения на Python 2

И ещё несколько пунктов, которые обязательно нужно сказать про этот код:

  1. В ходе профилирования нет смысла измерять время работы кода, ответственного за ввод данных с клавиатуры, чтение из файла, получение данных из сетевого хранилища и т.д. Эти операции априори будут медленными из-за низкой скорости передачи данных по сравнению с аналогичной скоростью в передачи данных в ОЗУ компьютера. Если вы понимаете, что проблема низкой скорости кроется в коде ввода данных, тогда его нужно профилировать отдельно от основной программы.
  2. Одна и та же программа, запущенная два раза, практически никогда не выдаст идентичное время выполнения. Это происходит из-за того, что программа выполняется в операционной системе, в которой постоянно работают фоновые процессы. И чаще всего отключить все лишние процессы невозможно. В таком случае, чтобы минимизировать их влияние, достаточно всего лишь запустить программу многократно и посчитать среднее время выполнения (что и сделано в коде).

Этот код при запуске показал следующие тайминги:

Как ускорить приложения на Python 3

Сразу можно заметить, что отклонение по времени доходит до половины секунды. Запускал код я на системе со следующей конфигурацией:

  • Intel Core i7-7700HQ
  • 16Gb RAM
  • KUbuntu 22.04

Ещё немного про профилирование по времени и сразу же первая оптимизация

Если у вас “тормозит” программа, в которой сотни и тысячи строк кода и сама архитектура этого кода состоит их множества функций и классов, тогда использовать замер таймингов в том виде, в котором я написал выше, будет крайне неудобно.

Но эта проблема решаема с помощью встроенного в Python средства профилирования, идеально подходящего для такой ситуации — утилиты cProfile. Она способна не просто запустить код и рассчитать время его работы, но и рассчитать время работы каждого отдельного метода (включая даже низкоуровневые методы создания списков, выделения памяти, добавления объектов и т.д.).

Для того, чтобы запустить cProfile, не требуется менять код. Достаточно просто запустить программу на исполнение с подключением дополнительного модуля:

python3 -m cProfile main.py 

В таком случае вся программа выполнится и после неё будет выведена детальная информация о времени выполнения каждой функции:

Как ускорить приложения на Python 4

Сразу же есть две мысли:

  1. Наличие любого дополнительного профилировщика замедляет программу. Это происходит, потому что любой профилировщик добавляет свой исполняемый код, благодаря которому и собирается статистика выполнения. В результате этого среднее время выполнения нашей программы увеличилось с 2.46 до 3.26 секунд.
  2. Сразу же можно заметить, что больше всего раз вызывается метод list.append, который добавляет новый объект в список. И именно на этом месте появляется идея для оптимизации: если мы заранее знаем, что объектов будет добавляться именно три миллиона, что мешает нам создать заранее список такого размера?

Попробуем изменить код так, чтобы список создавался сразу:

Как ускорить приложения на Python 5

Запустим его также с использованием cProfile. И что же мы видим?

Как ускорить приложения на Python 6

Среднее время уменьшилось до 2.06 секунд, и это со включённым профилировщиком. А без него будет так вообще 1.66! И всё путём простейшей оптимизации.

Профилирование по памяти

Также сразу же добавим в наш код профилирование по памяти, так как очень интересно узнать “сколько же занимает в памяти три миллиона товаров”. Для подсчёта памяти будем использовать библиотеку pympler.

Как ускорить приложения на Python 7

И такой код при размере хранилища в три миллиона товаров показал следующие результаты:

Размер хранилища: 176000864 байт или 167.85 мегабайт 

Вы можете заметить, что я убрал из кода подсчёт по времени. Причина проста: pympler для подсчёта количества занимаемой памяти проходит по всем имеющимся структурам данных, и во время подсчёта скорость выполнения увеличивается раз в пять, делая профилирование по времени неоправданным.

А теперь, когда мы достаточно знаем о поведении нашего приложения (и во времени, и в памяти) – приступим к его последовательной оптимизации.

Способы оптимизации

Оптимизация структур данных

Начнём мы с несколько нестандартной оптимизации, а именно — залезем внутрь нашего объекта товара и основательно там покопаемся.

Сейчас объект представлен в виде обыкновенного класса. Давайте подумаем, а возможно ли здесь использовать какую-нибудь иную структуру данных, которая построена на основе класса, но имеет дополнительный функционал? И такая структура есть, она называется датакласс. Правда, сразу стоит оговориться, что обычный датакласс является небольшой надстройкой над обычным классом, в которой разработчики языка чётко указали, какие будут поля и какие они будут иметь типы данных. А нам будет интересен датакласс с фиксированными полями, в который невозможно добавить новые поля.

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

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

Реализуем эту идею (для этого определим кортеж __slots__).

Как ускорить приложения на Python 8

Если этот код запустить и проверить время выполнения, то мы получим ускорение в среднем на 25 процентов

Как ускорить приложения на Python 9

А если директиву __slots__ указать в коде, который мы профилировали по памяти, то результаты получатся ещё более сногсшибательными:

Размер хранилища: 80000504 байт или 76.29 мегабайт 

То есть, путём отказа от динамического добавления элементов мы сразу уменьшили расходы памяти нашего приложения вдвое!

И на этом мы не остановимся.

Оптимизация интерпретатора

Следующая оптимизация, которая может помочь нам в достижении нашей цели — замена интерпретатора Python на интерпретатор PyPy.

Согласно определению из Википедии, PyPy – это интерпретатор языка Python, написанный на языке Python. Однако в него встроен трассирующий JIT-компилятор, способный преобразовывать код на Python в машинный код прямо во время выполнения программы. Эта особенность позволяет ему существенно ускорить процесс исполнения программы без каких либо изменений кода.

Установим pypy следующей командой:

sudo apt install pypy3 

А после этого запустим код с его помощью:

pypy3 main.py 

Результаты говорят сами за себя: скомпилированный код априори выполняется намного быстрее, нежели интерпретируемый код. Время исполнения уменьшилось ещё на 68%. И для такого запуска абсолютно не потребовалось менять исходный код.

Справедливости ради нужно заметить, что за счёт глубинной оптимизации некоторые сторонние библиотеки, которыми вы можете пользоваться, не смогут запуститься в pypy. И для них придётся искать аналоги. Но самые популярные библиотеки (такие как twisted, django, numpy, scikit-learn и другие) им полностью поддерживаются и работоспособны.

А как ещё можно оптимизировать?

В мире существуют и другие способы оптимизации, но они уже относятся к категории радикальных, подразумевающих кардинальное изменение структуры кода и (или) даже языка программирования. Среди них:

  • изменение структуры хранимых данных со списка объектов на pandas.DataFrame.
  • добавление строгой типизации и адаптация кода под компилятор cython
  • распараллеливание программы на потоки при помощи Nvidia CUDA.
  • И, наконец, если затраты от потерь производительности существенно превышают затраты от кардинальной переработки кода, можно попробовать переписать критичные части кода на языке C++ и оформить их в виде библиотеки, функции из которой можно запустить из Python-кода.

Итоги

Итак, в ходе нашего увлекательного путешествия мы

  • написали код
  • измерили его производительность (по памяти и по времени)
  • оптимизировали его несколько раз
  • результаты в виде графиков приведены ниже.

Как ускорить приложения на Python 10

Как ускорить приложения на Python 11

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

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *