Как ускорить requests python
Как ускорить код на Python в тысячу раз
Обычно говорят, что Python очень медленный
В любых соревнованиях по скорости выполнения программ Python обычно занимает последние места. Кто-то говорит, что это из-за того, что Python является интерпретируемым языком. Все интерпретируемые языки медленные. Но мы знаем, что Java тоже язык такого типа, её байткод интерпретируется JVM. Как показано, в этом бенчмарке, Java намного быстрее, чем Python.
Вот пример, способный показать медленность Python. Используем традиционный цикл for для получения обратных величин:
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 множество тактов ЦП используется для проверки типа.
Даже простое присвоение числового значения — это долгий процесс.
Шаг 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, она будет выглядеть так:
Это преобразование не только повышает скорость, но и укорачивает код. Отгадаете, сколько теперь времени занимает его выполнение? 2,7 мс — быстрее, чем все упомянутые выше языки:
2,71 мс ± 50,8 мкс на цикл (среднее значение ± стандартное отклонение после =7 прогонов по 100 циклов каждый)
Здесь можно найти все операторы Ufunc.
Подводим итог
Если вы пользуетесь Python, то высока вероятность того, что вы работаете с данными и числами. Эти данные можно хранить в NumPy или DataFrame библиотеки Pandas, поскольку DataFrame реализован на основе NumPy. То есть с ним тоже работает Ufunc.
UFunc позволяет нам выполнять в Python повторяющиеся операции быстрее на порядки величин. Самый медленный Python может быть даже быстрее языка C. И это здорово.
Приложение — код тестов на C, C#, Java и NodeJS
На правах рекламы
Воплощайте любые идеи и проекты с помощью наших VDS с мгновенной активацией на Linux или Windows. Создавайте собственный конфиг в течение минуты!
Python и быстрые HTTP-клиенты
В наши дни, если вы пишете некое Python-приложение, то вам, скорее всего, придётся оснащать его функционалом HTTP-клиента, который способен общаться с HTTP-серверами. Повсеместное распространение REST API сделало HTTP-инструменты уважаемыми жителями бесчисленного множества программных проектов. Именно поэтому любому программисту необходимо владеть паттернами, направленными на организацию оптимальной работы с HTTP-соединениями.
Существует множество HTTP-клиентов для Python. Самым распространённым среди них, и, к тому же, таким, с которым легко работать, можно назвать requests. Сегодня этот клиент является стандартом де-факто.
Постоянные соединения
Соединения хранятся в пуле соединений (он, по умолчанию, рассчитан на 10 соединений). Размер пула можно настраивать:
Повторное использование TCP-соединения для отправки нескольких HTTP-запросов даёт приложению множество преимуществ в производительности:
Параллельная обработка запросов
У requests есть, кроме того, ещё один серьёзный недостаток. Это — синхронная библиотека. Вызов метода наподобие requests.get(«http://example.org») блокирует программу до получения полного ответа HTTP-сервера. То, что приложению приходится ждать и ничего не делать, можно счесть минусом данной схемы организации взаимодействия с сервером. Можно ли сделать так, чтобы программа занималась чем-нибудь полезным вместо того, чтобы просто ждать?
Этот весьма полезный паттерн реализован в библиотеке requests-futures. При этом использование объектов Session прозрачно для разработчика:
По умолчанию создаётся воркер с двумя потоками, но программа легко может это значение настроить, передав объекту FuturSession аргумент max_workers или даже собственный исполнитель. Например, это может выглядеть так:
Асинхронная работа с запросами
Как уже было сказано, библиотека requests полностью синхронна. Это приводит к блокировке приложения во время ожидания ответа от сервера, что плохо сказывается на производительности. Одно из решений этой проблемы — выполнение HTTP-запросов в отдельных потоках. Но использование потоков — это дополнительная нагрузка на систему. К тому же это означает введение в программу схемы параллельной обработки данных, что устраивает не всех.
Производительность
Вот какие результаты были получены после запуска этой программы:
Вот диаграмма результатов.
Результаты исследования производительности разных способов выполнения HTTP-запросов
Совершенно неудивительно то, что самой медленной оказалась простейшая синхронная схема выполнения запросов. Дело тут в том, что здесь запросы выполняются один за другим, без повторного использования соединения. Как результат, на то, чтобы выполнить 10 запросов, уходит 12 секунд.
Если ваша система и ваша программа позволяют работать с потоками, то это — веская причина для того, чтобы задуматься об использовании потоков для параллелизации запросов. Потоки, однако, создают некоторую дополнительную нагрузку на систему, они, так сказать, не «бесплатны». Их нужно создавать, запускать, нужно дожидаться завершения их работы.
Потоковая обработка данных
Вот как выглядит организация потоковой обработки данных с использованием requests :
Вот как организовать потоковую обработку данных с помощью aiohttp :
Избавление от необходимости одномоментной загрузки полного содержимого ответа важно в тех случаях, когда надо предотвратить потенциальную возможность бесполезного выделения сотен мегабайт памяти. Если программе не нужен доступ к ответу как к единому целому, если она может работать и с отдельными фрагментами ответа, то, вероятно, лучше всего будет прибегнуть именно к методам потоковой работы с запросами. Например, если вы собираетесь сохранить данные из ответа сервера в файл, то чтение и запись их по частям будет гораздо эффективнее в плане использования памяти, чем чтение всего тела ответа, выделение огромного объёма памяти и последующая запись всего этого на диск.
Итоги
Надеюсь, мой рассказ о разных способах оптимизации работы HTTP-клиентов поможет вам выбрать то, что лучше всего подойдёт именно вашему Python-приложению.
Уважаемые читатели! Если вам известны ещё какие-нибудь способы оптимизации работы с HTTP-запросами в Python-приложениях — просим ими поделиться.
Как ускорить отправку GET запроса
Поомогите найти решение. Подключаюсь через websocket к одной бирже, приходит большой поток информации,примерно 30-40 сообщений в секунду,каждое сообщение мне нужно сравнить с моими данными, если есть нужное, отправить GET запрос. Это нужно сделать максимально быстро, ускорил на сколько смог:
1) мои данный хранятся в словаре и запрашиваю их по ключу, вместо поиска в цикле(это оказалось примерно в 10 раз быстрее)
2) сообщение приходит типа str, но в формате json, нужные мне данные вырезаю что бы не созавать Json объект(это приблизительно в 15 раз быстрее)
3) get запросы отправляю через сессию(не могу оценить на сколько быстрее это происходит чем без сессии)
4) арендовал сервак в Торронто от туда самый маленький ping, тестировал через сервисы в интернете(запрос отправляется в 2 раза быстрее).
И это все мне ни как не помогло, другие боты все равно опережают. Среднее время анализа сообщения и сбор данных перед отправкой 0.0002 сек(до оптимизации было около 0.02), а время отправки запроса и получения ответа от 0.2 до 0.3 (но мне важно лишь получение ответа сервером, посчитать не знаю как, плюс оно еще всегда разное). Есть мысли реализовать это все в cython, либо вообще написать это на Си(пока не знаю как). Но перед тем как вновь тыкать пальцем в небо,решил поинтересоваться у людей которые возможно смогут направить меня на путь истинный.
P.S Скорее всего я оптимизировал не то что надо, потому-что понятно что основное время тратится именно на отправку запроса, пытался использовать библиотеки типа faster-than-requests,asincio,aiohttp,но ни что не помогло, возможно не умею гуглить, в общем буду рад любому совету.
Как реализовать отправку запроса с определенного ip адреса?
Добрый день, Подскажите, как реализовать такую штуку. Есть сайт, нужно, чтобы SOAP запрос.
Как ускорить время выполнения запроса
Здравствуйте, как можно ускорить данный запрос: SELECT id, surname, CASE WHEN ball 10
4elove4ko, сколько соединений позволяет иметь сервер?
Добавлено через 2 минуты
ага, я невнимательно прочитал. Оказывается, сначала приходят запросы. Тогда остаётся подключать многопоточную обработку
т е получается каждое сообщение которое приходит по веб сокету, проверяется по очереди? И из-за этого грубо говоря накапливается стэк сообщений, так?
Добавлено через 11 минут
Но блин, я даже не знаю если в момент придет 10 сообщений программе понадобится 0.001 сек что-бы их обработать, конечно все равно попробую. Но я больше думал о том что когда создается запрос на сервер, сначала вроде как по домену ищется IP и уже после этого отправляется запрос на IP(не уверен но почему-то у меня такое понимание было) и я вот думал что я же могу вбить IP вручную(тогда сократиться время на поиск(хотя возможно открытая сессия это и делает?)), но как это сделать и что из этого получится не понимаю, а возможно уже бред в голову приходит. Сижу уже 4 суток над этим вопросом голова взрывается
Запросы Python выполняются медленно и очень долго для выполнения запроса HTTP или HTTPS.
При запросе веб-ресурса, веб-сайта или веб-службы с помощью библиотеки запросов выполнение запроса занимает много времени. Код выглядит примерно так:
Этот запрос занимает более 2 минут (ровно 2 минуты 10 секунд)! Почему так медленно и как это исправить?
1 ответ
Для любой из них могут быть множество возможных решений. Есть множество ответов на стойку для любого из них, поэтому я постараюсь объединить их всех, чтобы спасти вас хлопот по поиску их.
В своих поисках я обнаружил следующие слои:
Вы также можете Отключить IPv6 для текущего сеанса только.
Для многих проблем активация ведения журнала может помочь вам обнаружить, что идет не так (источник):
Если результаты отладки не помогли вам решить проблему, читайте дальше.
Если вам нужно только проверить, работает ли сервер, попробуйте запрос HEAD или потоковую передачу.
Может быть быстрее не запрашивать все данные, а отправлять только запрос HEAD (источник):
Некоторые серверы не поддерживают это, тогда вы можете попробовать передать ответ в потоковом режиме (источник):
Для нескольких запросов подряд, попробуйте использовать сеанс
Чтобы распараллелить ваши запросы (попробуйте> 10 запросов), используйте запросы-фьючерсы
Если вы отправляете очень большое количество запросов одновременно, каждый запрос блокирует выполнение. Вы можете распараллелить это, используя, например, запросы-фьючерсы (идея из kederrac ):
Будьте осторожны, чтобы не сокрушить сервер с слишком многими запросами одновременно.
Причина может не лежать с запросами, но сервер или ваше соединение
Во многих случаях причина может заключаться в сервере, с которого вы запрашиваете. Сначала проверьте это, запросив любой другой URL таким же образом:
Если это работает нормально, вы можете сосредоточить свои усилия на следующих возможных проблемах:
Сервер разрешает только определенные строки пользовательского агента
Скорость сервера ограничивает вас
Если эта проблема возникает только иногда, например после нескольких запросов сервер может ограничивать вашу скорость. Проверьте ответ, чтобы узнать, читает ли он что-то в этих строках (например, «достигнут предел скорости», «превышена глубина рабочей очереди» или что-то подобное; источник).
Ответ сервера неправильно отформатирован, что приведет к разбору проблем
Вы можете проверить это, не читая ответ, который вы получаете от сервера. Если код по-прежнему медленный, это не ваша проблема, но если это исправило, проблема может заключаться в разборе ответа.
Чтобы исправить это, попробуйте:
IPv6 не работает, но IPv4 работает
Убедитесь, используя, например, <
В обоих случаях мы заставляем инструмент подключаться через IPv6, чтобы изолировать проблему. Если это время истечет, попробуйте еще раз принудительно настроить IPv4:
Если это работает нормально, вы нашли свою проблему! Но как это решить, вы спрашиваете?
ускорить HTTP-запрос Python и 500 ошибок
У меня есть код, который извлекает результаты новостей из этой газеты, используя запрос и временные рамки (может быть до года).
Результаты разбиты на страницы до 10 статей на странице, и, поскольку я не смог найти способ увеличить ее, я отправляю запрос на каждую страницу, затем извлекаю заголовок, URL и дату каждой статьи. Каждый цикл (HTTP-запрос и анализ) занимает от 30 секунд до минуты, и это очень медленно. И в конце концов он остановится с кодом ответа 500. Мне интересно, есть ли способы ускорить его или, возможно, сделать несколько запросов одновременно. Я просто хочу получить подробности статей на всех страницах. Вот код:
5 ответов
Это хорошая возможность попробовать gevent.
У вас должна быть отдельная подпрограмма для части request.get, чтобы вашему приложению не приходилось ждать блокировки ввода-вывода.
Затем вы можете создавать нескольких рабочих и иметь очереди для передачи запросов и статей. Может быть, что-то похожее на это:
Наиболее вероятным является замедление работы сервера, поэтому распараллеливание http-запросов было бы лучшим способом ускорить выполнение кода, хотя для ускорения ответа сервера можно сделать очень мало. В IBM есть хороший учебник, посвященный именно этому.
Если вы вообще можете избежать разбивки на страницы и разбора, я бы порекомендовал это. Если вы не можете, я рекомендую использовать gevent для простоты. Тем не менее, если они отправят вам обратно 500-е, ваш код, вероятно, меньше проблемы, и добавленный параллелизм может не помочь
Это может очень близко приблизиться к тому, что вы ищете.