Как уменьшить время выполнения программы в python

Как уменьшить время работы кода?

Имеется обученная модель, на основе которой необходимо проставить категорию текста из файла и записать данную категорию в другой файл. В файле более 20 000 строк.

for schetchik in range(list): text = descriptions[schetchik] tokenizer = Tokenizer() tokenizer = Tokenizer(num_words=num_words) tokenizer.fit_on_texts(descriptions) tokenizer.word_index sequences = tokenizer.texts_to_sequences(descriptions) sequence = tokenizer.texts_to_sequences([text]) data = pad_sequences(sequence, maxlen=max_review_len) result = model.predict(data) prediction = model.predict(np.array(data)) predicted_label = text_labels[np.argmax(prediction)] with open('PREDICT.csv', 'r+') as f: f.seek(0, 2) f.write(str(predicted_label)+"\n") print(text) print(predicted_label) 

Отслеживать

13.8k 12 12 золотых знаков 43 43 серебряных знака 76 76 бронзовых знаков

Как сократить время выполнения данной программы (Python)?

Есть одна неинтересная задача, которую мне вроде как удалось решить (условия снизу, код в конце).

Складывай и умножай.
Ограничение времени 2 секунды
Ограничение памяти 64Mb
Ввод стандартный ввод или input.txt
Вывод стандартный вывод или output.txt
Вам даны два массива одинаковой длины A и B.
Вы должны выполнять 3 типа запросов:
“* l r x”: прибавить целое число x ко всем Ai, где l≤i≤r.
“. l r x”: прибавить целое число x ко всем Bi, где l≤i≤r.
“? l r”: вычислить сумму Al⋅Bl + … + Ar⋅Br.
Массивы пронумерованы, начиная с единицы. Изначально оба массива заполнены нулями.
Формат ввода
Первая строка входа содержит два целых числа n и m, разделённых пробелами — длина массивов и количество запросов, соответственно (1≤n,m≤100000).
Последующие m содержат запросы в формате, описанном в условии. Для каждого запроса 1≤l≤r≤n и 1≤x <10**9+7.
Формат вывода
Для каждого запроса третьего типа выведите остаток от деления соответствующей суммы на 10**9 + 7.
Пример
Ввод:
5 4
* 1 4 10
. 2 5 8
? 1 3
? 2 5
Вывод:
160
240
Все вроде и ничего, но на одном из тестой выдает TL. Время работы — 2,081 с. вместо 2-х с..
Хотелось бы переделать программку так, чтобы этой ошибки не было. Код моего решения:

# Functions def func_1(l,r,x,S): for i in range(l-1,r): S[i] += x return S def func_2(l,r,A,B): s = 0 for i in range(l-1,r): s += A[i] * B[i] return s % (10**9 + 7) # End of functions In_0 = list(map(int,input().split())) L = In_0[0] N = In_0[1] A = [0] * L B = [0] * L for i in range(N): In = list(input().split()) if In[0] == '*': A = func_1(int(In[1]),int(In[2]),int(In[3]),A) elif In[0] == '.': B = func_1(int(In[1]),int(In[2]),int(In[3]),B) elif In[0] == '?': print(func_2(int(In[1]),int(In[2]),A,B))

• Вопрос задан более трёх лет назад
• 726 просмотров

Приёмы для ускорения кода на 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. Конечно, этот список не исчерпывающий: есть и другие способы, которые могут вам пригодиться. Обязательно ищите их и пишите код эффективно!

6 способов измерить скорость программы на Python

Недавно мы решали сложную задачу Эйнштейна с помощью кода на Python, а потом оптимизировали его, чтобы сократить время выполнения. Там всё было просто: с четырёх часов мы оптимизировали время выполнения до долей секунды, и это было явно заметно. Но бывает так, что даже полсекунды оптимизации — это очень хорошо, когда речь идёт о высоконагруженных сервисах. Например, в соцсетях, которыми пользуются сотни тысяч пользователей в минуту. Сегодня мы покажем целых 6 простых способов измерения времени работы кода, которые может использовать каждый.

Как измерять время выполнения кода

В большинстве случаев измерить время работы кода можно так:

1. Зафиксировать время начала работы.
2. Зафиксировать время окончания работы.
3. Вычесть первое значение из второго.

Ещё важно измерять время выполнения кода при одних и тех же условиях:

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

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

Если будете заниматься оптимизацией, вот вам на вырост: нужно различать понятия wall time («время на стене») и процессорное время. Первое показывает прошедшее время от начала до конца работы, второе — время, которое процессор затратил на выполнение кода. Их значения могут различаться, если программа ожидает высвобождение ресурсов для выполнения. Но сейчас можно без этих тонкостей.

Модуль datetime

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

# подключаем модуль datetime import datetime # фиксируем и выводим время старта работы кода start = datetime.datetime.now() print('Время старта: ' + str(start)) # код, время работы которого измеряем #фиксируем и выводим время окончания работы кода finish = datetime.datetime.now() print('Время окончания: ' + str(finish)) # вычитаем время старта из времени окончания print('Время работы: ' + str(finish - start))

Результат — 51 тысячная секунды. Неплохо, но что покажут другие способы?

Модуль time

Модуль time предоставляет разные возможности для измерения времени работы кода:

• time.time() поможет измерить время работы в секундах. Если нужно получить время в минутах, результат вычисления нужно разделить на 60, в миллисекундах — умножить на 1000.
• time.perf_counter() также можно использовать для измерения времени в секундах, но таймер не будет зависеть от системных часов. Функцию используют, чтобы избежать погрешностей. Функция time.perf_counter_ns() вернёт значение в наносекундах.
• time.monotonic() подходит для больших программ, поскольку эта функция не зависит от корректировки времени системы. Функция использует отдельный таймер, как и time.perf_counter(), но имеет более низкое разрешение. С помощью time.monotonic_ns() можно получить результат в наносекундах.
• time.process_time() поможет получить сумму системного и пользовательского процессорного времени в секундах, не включая время сна. Если процесс выполнения блокируется функцией time.sleep() или приостанавливается операционной системой, это время не включается в отчётное. Для наносекунд есть функция time.process_time_ns(), но её поддерживают не все платформы.
• time.thread_time() сообщит время выполнения текущего потока, а не процесса. Если в коде есть функция time.sleep(), время её выполнения не будет включено.

Time.time(). Давайте посчитаем время выполнения нашего кода с помощью функции time.time() в миллисекундах:

# подключаем модуль time import time # фиксируем время старта работы кода start = time.time() # код, время работы которого измеряем #фиксируем время окончания работы кода finish = time.time() # вычитаем время старта из времени окончания и получаем результат в миллисекундах res = finish - start res_msec = res * 1000 print('Время работы в миллисекундах: ', res_msec)

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

Time.perf_counter(). Посчитаем время выполнения нашего кода с помощью функции time.perf_counter() в секундах:

# подключаем модуль time import time # фиксируем время старта работы кода start = time.perf_counter() # код, время работы которого измеряем #фиксируем время окончания работы кода finish = time.perf_counter() # вычитаем время старта из времени окончания и выводим результат print('Время работы: ' + str(finish - start))

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

Time.monotonic_ns(). Посчитаем время выполнения нашего кода с помощью функции time.monotonic_ns() в наносекундах:

# подключаем модуль time import time # фиксируем время старта работы кода start = time.monotonic_ns() # код, время работы которого измеряем #фиксируем время окончания работы кода finish = time.monotonic_ns() # вычитаем время старта из времени окончания и получаем результат в наносекундах print('Время работы в наносекундах: ' + str(finish - start))

Результат примерно такой же — 52 тысячные секунды, но количество цифр в результате меньше, чем в предыдущем случае.

Time.process_time(). Посчитаем сумму системного и пользовательского процессорного времени в секундах:

# подключаем модуль time import time # фиксируем время старта работы кода start = time.process_time() # код, время работы которого измеряем #фиксируем время окончания работы кода finish = time.process_time() # вычитаем время старта из времени окончания и выводим результат print('Время работы: ' + str(finish - start))

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

Time.thread_time(). Наконец, посчитаем время выполнения кода с помощью time.thread_time():

# подключаем модуль time import time # фиксируем время старта работы кода start = time.thread_time() # код, время работы которого измеряем #фиксируем время окончания работы кода finish = time.thread_time() # вычитаем время старта из времени окончания и выводим результат print('Время работы: ' + str(finish - start))

Время работы снова выглядит правдоподобно в сравнении с предыдущим результатом.

Что дальше

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