Работа с веб-данными с помощью Requests и Beautiful Soup в Python
Данный мануал научит работать с пакетами Requests и Beautiful Soup для использования данных с веб-страниц. Модуль Requests позволяет интегрировать программы Python с веб-сервисами, а модуль Beautiful Soup предназначен для ускорения анализа экранных данных. С помощью интерактивной консоли Python и этих библиотек можно проанализировать веб-страницу и работать с имеющейся там текстовой информацией.
Требования
Вам понадобится среда разработки Python 3. Чтобы создать такую среду, можно воспользоваться руководствами Настройка локальной среды разработки для Python 3 в Ubuntu 16.04 или Установка Python 3 и настройка среды разработки на сервере Ubuntu 16.04.
Также рекомендуем ознакомиться со следующими статьями:
Кроме того, вам нужно иметь базовые знания о структурах и тегах HTML.
Установка Requests
Разверните среду программирования Python 3. Убедитесь, что вы находитесь в каталоге, в котором находится ваша среда, и выполните следующую команду:
Чтобы работать с веб-страницами, их нужно будет запрашивать. Библиотека Requests позволяет использовать HTTP в своих программах Python.
Установите Requests в среду программирования.
pip install requests
Collecting requests
Downloading requests-2.18.1-py2.py3-none-any.whl (88kB)
100% |████████████████████████████████| 92kB 3.1MB/s
.
Installing collected packages: chardet, urllib3, certifi, idna, requests
Successfully installed certifi-2017.4.17 chardet-3.0.4 idna-2.5 requests-2.18.1 urllib3-1.21.1
Если библиотека Requests была установлена ранее, вы получите такой вывод:
Requirement already satisfied
.
Установка Beautiful Soup
Теперь нужно установить Beautiful Soup с помощью pip. На данный момент последней версией является Beautiful Soup 4.
pip install beautifulsoup4
Collecting beautifulsoup4
Downloading beautifulsoup4-4.6.0-py3-none-any.whl (86kB)
100% |████████████████████████████████| 92kB 4.4MB/s
Installing collected packages: beautifulsoup4
Successfully installed beautifulsoup4-4.6.0
Теперь можно приступать к работе с библиотеками.
Сбор данных веб-страницы с помощью Requests
С помощью этих двух библиотек Python, можно проанализировать веб-страницу.
Перейдите в Python Interactive Console:
Импортируйте модуль Requests, чтобы собрать данные с веб-страницы:
Присвойте URL-адрес тестовой страницы (в данном случае это mockturtle.html) переменной url.
Затем можно присвоить результат запроса этой страницы переменной page с помощью метода request.get(). Передайте URL-адрес страницы, который был присвоен переменной url, этому методу.
Переменная page присвоена объекту Response.
Объект Response сообщает свойство status_code в квадратных скобках (в данном случае это 200). Этот атрибут можно вызвать явно:
Возвращаемый код 200 сообщает, что страница загружена успешно. Коды, начинающиеся с номера 2, обычно указывают на успешное выполнение операции, а коды, начинающиеся с 4 или 5, сообщают об ошибке. Вы можете узнать больше о кодах состояния HTTP по этой ссылке.
Чтобы работать с веб-данными, нужно получить доступ к текстовому содержимому веб-файлов. Прочитать содержимое ответа сервера можно с помощью page.text (или page.content, чтобы получить значение в байтах).
‘ \n\n \n \n \n\n Turtle
Soup \n \n\n \n
Turtle Soup
id=»first»>Beautiful Soup, so rich and green,
\n Waiting in a hot tureen!
\n Who for
such dainties would not stoop?
\n Soup of the evening, beautiful Soup!
\n Soup of
the evening, beautiful Soup!
Beau—ootiful
Soo—oop!
\n Beau—ootiful Soo—oop!
\n Soo—oop of the e—e—evening,
\n
Beautiful, beautiful Soup!
Beautiful Soup! Who cares
for fish,
\n Game or any other dish?
\n Who would not give all else for two
\n
Pennyworth only of Beautiful Soup?
\n Pennyworth only of beautiful Soup?
Beau—ootiful Soo—oop!
\n Beau—ootiful Soo—oop!
\n
Soo—oop of the e—e—evening,
\n Beautiful, beauti—FUL SOUP!
/>
Знакомство с Python библиотекой requests
Подробное руководство по Python библиотеке requests с примерами использования.
Введение
Большая часть интернет-ресурсов взаимодействует с помощью HTTP-запросов. Эти HTTP-запросы выполняются устройствами или браузерами (клиентами) при обращении к веб-сервису.
В Python библиотека requests позволяет делать HTTP-запросы в нашем коде, и это очень востребовано, так как многие современные приложения используют данные сторонних сервисов с помощью API.
Python requests — отличная библиотека. Она позволяет выполнять GET и POST запросы с возможностью передачи параметров URL, добавления заголовков, размещения данных в форме и многое другое.
С помощью библиотеки можно делать запросы практически на каждый сайт/веб-страницу, но ее сила заключается в доступе к API для получения данных в виде JSON, с которыми можно работать в своем коде, приложениях и скриптах.
Установка библиотеки
Чтобы установить библиотеку requests, запустите команду:
Будет установлен модуль и зависимости, если таковые имеются.
Создание простого запроса
Давайте попробуем сделать простой запрос на мой сайт, https://egorovegor.ru (вы можете использовать любой сайт):
Для начала импортируем модуль requests. Из него мы используем функцию get() с переданным URL нашего сайта. В этой строке кода делается запрос на https://egorovegor.ru, а ответ сохраняется в переменную r.
Для выполнения запроса к удаленному ресурсу требуется подключение к сети интернет.
Теперь у нас есть объект ответа (response), присвоенный переменной r. Мы можем получить всю необходимую информацию из этого объекта.
После того, как запрос сделан, мы получаем ответ от веб-сервера на котором расположен сайт и можем прочитать его код:
Если ваш код состояния равен 200, это означает что запрос был выполнен успешно. С полным списком кодов состояния HTTP можно ознакомится на странице в Википедии. Вы можете получить доступ к исходному коду веб-страницы с помощью свойства .text:
Весь исходный код веб-страницы будет распечатан в вашей консоли.
Это полезно при выполнении сбора данных с веб страниц.
Выполнение запросов к API
Максимально раскрыться библиотеке позволяет взаимодействие с внешними API. В данном руководстве мы будем использовать API, который доступен на движке моего сайте. Мы выполним запрос, который должен вернуть информацию о сайте.
Теперь у нас есть объект response, сохраненный в переменную r. Мы можем получить из него всю необходимую информацию.
Содержимое ответа
Мы можем читать содержимое различными способами, используя атрибуты и функции, предоставляемые модулем requests.
r.status_code возвращает код, указывающий, был ли запрос успешным или нет. 200 означает успешный. Общие коды статусов, которые вы, вероятно, видели — 200, 404 и 500. 404 означает ошибку клиента, а 500 означает ошибку сервера.
r.encoding возвращает кодировку ответа, основанную на HTTP заголовках.
r.url возвращает запрошенный URL.
r.json возвращает разобранные JSON данные из ответа.
r.text возвращает ответ в текстовом формате
r.content возвращает ответ, отформатированный в байтах
Работа с JSON ответами
JSON-данные, полученные по ссылке https://egorovegor.ru/wp-json/, содержат много информации о сайте, давайте попробуем с ней поработать.
Ответ сервера:
Обратите внимание, я сократил ответ сервера из за большого количества информации в json.
r.json() разбирает ответ в Python-совместимый тип данных, т.е. словарь или список. Разберем на примере как использовать полученные JSON данные.
Выполнив данный сценарий мы получим результат указанный ниже.
Использование параметров в URL
При работе с запросами можно передавать параметры в строке запроса URL. Параметры URL — распространенный способ передачи данных, их часто можно увидеть после вопросительного знака в URL. Пример: https://egorovegor.ru/?s=Python — это URL для поиска статей с ключевым словом Python, получается что s=Python — это его параметр.
Заключение
Мы рассмотрели как использовать библиотеку requests в Python и научились парсить данные с сайтов.
Для более глубокого изучения библиотеки requests можно обратиться к официальной документации.
Как работать с библиотекой Requests в Python
Многие веб-приложения подключаются к различным сторонним сервисам с помощью API. Используя эти API, вы можете получить доступ к таким данным, как информация о погоде, результаты спортивных соревнований, списки фильмов, твиты, результаты поиска и изображения. Вы можете использовать API, чтобы расширить функции своего приложения, например, добавить платежи, планирование, электронные письма, переводы, карты и передачу файлов. Чтобы создать какую-либо из этих функций самостоятельно, вы потратили бы уйму времени, но с помощью API вы потратите на это всего несколько минут.
В этом мануале мы расскажем о библиотеке Requests Python, которая позволяет отправлять HTTP-запросы в Python.
Requests позволяет использовать API в Python, поскольку использование API – это не что иное, как отправка HTTP-запросов и получение ответов. В мануале мы покажем, как использовать API для перевода текста с одного языка на другой.
Краткий обзор HTTP-запросов
HTTP-запросы – это основа работы сети. Каждый раз, когда вы переходите на веб-страницу, ваш браузер отправляет несколько запросов на сервер веб-страницы. Сервер в ответ отправляет все данные, необходимые для отображения страницы, а затем ваш браузер фактически отображает страницу.
Общий процесс таков:
Часть данных, которую клиент отправляет в запросе, является методом запроса. Распространенными методами запросов являются GET, POST и PUT. GET-запросы, как правило, предназначены только для чтения данных без внесения каких-либо изменений, а POST и PUT-запросы обычно используются для изменения данных на сервере. Так, например, Stripe API позволяет использовать POST-запросы для создания нового счета, чтобы пользователь мог что-то купить в вашем приложении.
Примечание: В этом мануале мы не будем изменять какие-либо данные на сервере, потому рассматриваем только запросы GET.
Отправляя запрос из скрипта Python или из веб-приложения, разработчик решает, что будет отправлено в каждом запросе и что делать с ответом.
Давайте попробуем поработать с библиотекой Requests. В этом мануале для примера мы сначала отправим запрос в Scotch.io, а затем используем API перевода.
1: Установка библиотеки requests
Сначала нужно установить библиотеку. Давайте установим ее с помощью пакетного менеджера pip.
Примечание: Рекомендуем создать виртуальную среду, если у вас ее еще нет, и установить библиотеку в нее.
pip install requests
2: Отправка запроса
Сначала мы воспользуемся библиотекой Requests для запроса сайта Scotch.io. Создайте файл нем script.py и вставьте в него следующий код.
import requests
res = requests.get(‘https://scotch.io’)
print(res)
Примечание: В данном мануале мы будем работать с маленькими фрагментами кода, поэтому вы можете просто обновить существующий код вместо добавления новых строк.
Итак, этот код отправляет запрос GET на Scotch.io. Это тот же тип запроса, который ваш браузер отправил для просмотра этой страницы, единственное отличие состоит лишь в том, что библиотека Requests не может фактически отображать HTML, поэтому вы получите просто необработанный HTML и другую информацию ответа.
Вы можете запустить файл script.py с помощью команды:
И вот что вы получите:
3: Коды состояния
Первое, что мы должны сделать, – это проверить код состояния. Коды HTTP представлены в диапазоне от 1XX до 5XX. Вы, вероятно, встречали коды состояния 200, 404 и 500.
Вот что означает каждый код:
Как правило, выполняя свои запросы, вы должны получать коды состояния 2ХХ.
Библиотека Requests понимает, что 4XX и 5XX являются ошибками, поэтому если возвращаются эти коды состояния, объект ответа из запроса оценивается как False.
Вы можете убедиться, что запрос успешно обработан, проверив ответ так:
if res:
print(‘Response OK’)
else:
print(‘Response Failed’)
Сообщение «Response Failed» появится только в случае возврата кода состояния 400 или 500. Попробуйте указать неверный URL-адрес, и тогда вы получите ошибку 404 и увидите сообщение «Response Failed».
Вы можете взглянуть на код состояния напрямую, добавив в script.py строку:
Это покажет вам код состояния напрямую, чтобы вы могли все проверить самостоятельно.
>python script.py
Response Failed
404
>
4: Заголовки
Также в ответе на запрос вы можете найти заголовки.
Используйте в файле строку:
Затем запустите файл.
Заголовки отправляются вместе с запросом и возвращаются в ответе. Заголовки нужны, чтобы и клиент, и сервер знали, как интерпретировать данные, отправляемые и получаемые в ответах.
На экране вы увидите длинный список возвращаемых заголовков. Чаще всего вам не нужно напрямую использовать информацию заголовков, но вы можете получить ее, если она вам понадобилась. Обычно из всех заголовков вам может понадобиться только тип контента, поскольку он показывает формат данных, например HTML, JSON, PDF и так далее. Но тип контента обычно обрабатывается библиотекой Requests, поэтому вы можете получить доступ к возвращаемым данным.
5: Текст ответа
Обратите внимание на res.text (это касается текстовых данных, таких как HTML-страница, которую мы просматриваем). Здесь вы можете увидеть весь HTML-код, необходимый для создания домашней страницы Scotch. Он не будет обработан, но мы видим, что он принадлежит Scotch. Если вы сохраните этот код в файл и откроете его, вы увидите нечто похожее на сайт Scotch. В реальной ситуации на одну веб-страницу делается несколько запросов для загрузки разных компонентов (таких, как изображения, скрипты и таблицы стилей). Поэтому если вы сохраните в файл только HTML, страница не будет выглядеть так, как выглядит Scotch.io как в браузере, потому что для получения данных HTML был выполнен только один запрос.
6: Использование Translate API
Теперь давайте попробуем использовать Yandex Translate API для выполнения запроса на перевод текста на другой язык.
Чтобы использовать API, сначала необходимо зарегистрироваться. После регистрации перейдите в Translate API и создайте ключ API. Получив ключ, добавьте его в свой файл script.py как константу.
API_KEY = ‘your yandex api key’
Вот ссылка, по которой можно все сделать.
Ключ API нужен нам потому, что с его помощью Яндекс сможет аутентифицировать нас каждый раз, когда мы хотим использовать его API. Ключ API представляет собой упрощенную форму аутентификации, он добавляется в конец URL-адреса запроса при отправке.
Узнать, какой URL нужно отправить, чтобы использовать API, можно в документации Яндекса.
Там можно найти всю информацию, необходимую для использования Translate API для перевода текста.
Если в URL вы видите амперсанды (&), вопросительные знаки (?) и знаки равенства (=), вы можете быть уверены, что такой URL предназначен для запросов GET. Эти символы задают соответствующие параметры URL-адреса.
Обычно в квадратных скобках ([]) указываются опциональные фрагменты. В этом случае таковыми являются format, options и callback, в то время как key, text, and lang обязательно должны присутствовать в запросе.
Давайте добавим код для отправки запроса на этот URL. Вы можете заменить первый созданный нами запрос в файле script.py следующим кодом:
url = ‘https://translate.yandex.net/api/v1.5/tr.json/translate’
res = requests.get(url)
Есть два способа добавить параметры. Их можно добавить в конец URL-адреса напрямую, а можно сделать так, чтобы запросы делали это за нас. Чтобы сделать последнее, мы можем создать словарь для наших параметров. Обязательными элементами будут ключ, текст и язык. Давайте создадим словарь, используя ключ API, текст ‘Hello’ и языки ‘en-es’ (то есть текст нужно перевести с английского на испанский).
Другие языковые коды вы можете найти здесь в столбце 639-1.
Давайте создадим словарь параметров, используя функцию dict(), и передадим ей ключи и значения, которые должны быть в этом словаре. Добавьте в файл script.py:
params = dict(key=API_KEY, text=’Hello’, lang=’en-es’)
res = requests.get(url, params=params)
После этого запросы начнут добавляться к URL-адресу самостоятельно.
Теперь давайте добавим оператор print для текста ответа и посмотрим, что вернется в результате.
Здесь мы видим три вещи. Сначала идет код состояния, который в точности совпадает с кодом состояния самого ответа; затем идет язык, который мы выбрали; в конце мы видим переведенный текст.
Попробуйте еще раз, указав в качестве языка en-fr, и вы должны увидеть «Bonjour» в ответе.
params = dict(key=API_KEY, text=’Hello’, lang=’en-fr’)
Давайте посмотрим на заголовки для этого конкретного ответа.
Очевидно, заголовки будут отличаться, потому что мы обращаемся к другому серверу. В этом случае тип контента – application/json, а не text/html. Это означает, что данные могут быть интерпретированы как JSON.
Когда application/json является типом контента, мы можем сделать так, чтобы запросы преобразовывали ответ в словарь и список, чтобы легче получать доступ к данным.
Если вы отобразите его, вы увидите, что данные выглядят так же, но формат немного отличается.
json = res.json()
print(json)
Теперь это не простой текст, который вы получаете из res.text, а версия словаря.
Допустим, мы хотим получить доступ к тексту. Поскольку теперь это словарь, мы можем использовать ключ text.
И теперь мы увидим только данные для этого ключа. В этом случае мы получим список из одного элемента. Если вам нужно получить этот текст в списке, можно получить к нему доступ по индексу.
И теперь на экране будет только переведенное слово.
Меняя параметры, вы будете получать разные результаты. Давайте изменим текст, вместо Hello будет Goodbye, а также изменим целевой язык на испанский и отправим запрос снова.
params = dict(key=API_KEY, text=’Goodbye’, lang=’en-es’)
Также можно попробовать перевести более длинный текст на другие языки и посмотреть, какие ответы дает API.
7: Ошибки Translate API
Осталось рассмотреть ошибки.
Попробуйте изменить ключ API, удалив один символ. После этого ваш ключ API станет недействительным. Затем попробуйте отправить запрос.
Если вы посмотрите на код состояния, вот что вы получите:
print(res.status_code)
> python script.py
403
>
Когда вы используете API, вам нужно проверять выполнение некоторых операций, чтобы обрабатывать ошибки в соответствии с потребностями вашего приложения.
Заключение
В этом мануале вы узнали:
В этом списке вы найдете другие доступные API. Попробуйте использовать их с библиотекой Requests.
Requests в Python – Примеры выполнения HTTP запросов
Библиотека requests является стандартным инструментом для составления HTTP-запросов в Python. Простой и аккуратный API значительно облегчает трудоемкий процесс создания запросов. Таким образом, можно сосредоточиться на взаимодействии со службами и использовании данных в приложении.
Содержание статьи
В данной статье представлены наиболее полезные особенности requests. Показано, как изменить и приспособить requests к различным ситуациям, с которыми программисты сталкиваются чаще всего. Здесь также даются советы по эффективному использованию requests и предотвращению влияния сторонних служб, которые могут сильно замедлить работу используемого приложения. Мы использовали библиотек requests в уроке по парсингу html через библиотеку BeautifulSoup.
Ключевые аспекты инструкции:
В статье собран оптимальный набор информации, необходимый для понимания данных примеров и особенностей их использования. Информация представлена в доступной в форме. Тем не менее, стоит иметь в виду, что для оптимального разбора инструкции потребуются хотя бы базовые знания HTTP.
Далее будут показаны наиболее эффективные методы использования requests в разрабатываемом приложении.
Python установка библиотеки requests
Введение в работу с библиотекой Requests в Python
By Anthony Herbert
Published on February 20, 2020
While this tutorial has content that we believe is of great benefit to our community, we have not yet tested or edited it to ensure you have an error-free learning experience. It’s on our list, and we’re working on it! You can help us out by using the «report an issue» button at the bottom of the tutorial.
Введение
Многие веб-приложения используют API для подключения к различным сторонним сервисам. Используя API, вы можете получать доступ к таким данным как информация о погоде, результаты спортивных состязаний, рейтинги фильмов, твиты, результаты поиска в поисковых системах и изображения. Также вы можете использовать API для добавления функционала в ваше приложение, например платежей, планирования, отправки сообщений электронной почты, переводов, карт и передачи файлов. Самостоятельное создание таких инструментов может занять очень много времени, а API позволяют за считанные минуты подключиться к источнику и получить доступ к его функциям и данным.
Из этой статьи вы узнаете о библиотеке Python Requests, позволяющей отправлять запросы HTTP в Python.
Поскольку при использовании API отправляются запросы HTTP и получаются ответы, библиотека Requests открывает возможность использования API в Python. Мы продемонстрируем использование API для языкового перевода, чтобы вы увидели, как это работает.
Краткий обзор запросов HTTP
Запросы HTTP лежат в основе всемирной сети. Каждый раз, когда вы открываете веб-страницу, ваш браузер направляет множество запросов на сервер этой веб-страницы. Сервер отвечает на них, пересылая все необходимые данные для вывода страницы, и ваш браузер отображает страницу, чтобы вы могли увидеть ее.
В целом этот процесс выглядит так: клиент (например браузер или скрипт Python, использующий библиотеку Requests) отправляет данные на URL, а сервер с этим URL считывает данные, решает, что с ними делать, и отправляет клиенту ответ. После этого клиент может решить, что делать с полученными в ответе данными.
В составе запроса клиент отправляет данные по методу запроса. Наиболее распространенными методами запроса являются GET, POST и PUT. Запросы GET обычно предназначены только для чтения данных без их изменения, а запросы POST и PUT обычно предназначаются для изменения данных на сервере. Например, Stripe API позволяет использовать запросы POST для тарификации, чтобы пользователь мог купить что-нибудь в вашем приложении.
Примечание. В этой статье рассказывается о запросах GET, поскольку мы не собираемся изменять никакие данные на сервере.
При отправке запроса из скрипта Python или веб-приложения вы как разработчик решаете, что отправлять в каждом запросе и что делать с полученными ответами. Для начала отправим запрос на Scotch.io и используем API для перевода.
Установка Python Requests
Наш первый запрос
Для начала мы используем библиотеку Requests для отправки запроса на сайт Scotch.io. Создайте файл с именем script.py и добавьте в него следующий код. В этой статье мы рассматриваем небольшое количество кода, поэтому если что-то изменится, вы можете просто обновить существующий код вместо добавления новых строк.
Этот код просто отправляет запрос GET на сайт Scotch.io. Это такой же тип запроса, какой используется вашим браузером для просмотра этой страницы, и единственное отличие заключается в том, что библиотека Requests не может выполнить рендеринг кода HTML, и поэтому вы получите просто код HTML и другую информацию, содержащуюся в ответе.
Для отправки запроса нужно запустить файл script.py.
Вот что вы получите в результате: запуск 
.
Коды состояния
Прежде всего мы проверим код состояния. Коды HTTP находятся в диапазоне от 1XX до 5XX. Наверняка вы уже знакомы с кодами состояния 200, 404 и 500.
Далее мы приведем краткий обзор значений кодов состояния:
Обычно при выполнении наших собственных запросов мы хотим получить коды состояния в диапазоне 200.
Проверив истинность ответа, вы можете убедиться, что запрос успешно обработан. Например:
Сообщение Response Failed появится только при возврате кода состояния 400 или 500. Попробуйте заменить URL на несуществующий, чтобы увидеть ошибку ответа 404.
Чтобы посмотреть код состояния, добавьте следующую строку:
Так вы увидите код состояния и сможете сами его проверить.
Заголовки
Также в ответе вы можете получить заголовки. Вы можете посмотреть их, используя словарь headers для объекта response.
Заголовки отправляются вместе с запросом и возвращаются с ответом. Заголовки используются для того, чтобы клиент и сервер понимали, как интерпретировать данные, отправляемые и получаемые в запросе и ответе.
Мы увидим в ответе несколько заголовков. Обычно информация из заголовков не требуется, однако если она вам нужна, вы можете ее получить.
Обычно требуется заголовок content type, поскольку он показывает формат данных, например HTML, JSON, PDF, обычный текст и т. д. Однако заголовок content type обрабатывается библиотекой Requests, и вы имеете доступ ко всем возвращаемым данным.
Текст ответа
Если мы посмотрим на файл res.text (это работает для текстовых данных, таких как просматриваемая нами страница HTML), мы увидим весь код HTML, требуемый для построения домашней страницы Scotch. Рендеринг выполняться не будет, но мы увидим, что он принадлежит Scotch. Если вы сохраните этот код в файл и откроете его, вы увидите что-то похожее на сайт Scotch. В реальных условиях для загрузки на одну веб-страницу изображений, скриптов, таблиц стилей и т. д. отправляется несколько запросов, так что если вы сохраните в файл только код HTML и откроете его в браузере, результат не будет похож на страницу Scotch.io, поскольку для получения данных HTML был отправлен только один запрос.
Использование Translate API
Теперь перейдем к чему-то более интересному. Мы используем API Яндекс.Перевод (Yandex Translate API) для выполнения запроса на перевод текста на другой язык.
Чтобы использовать API, нужно предварительно войти в систему. После входа в систему перейдите к Translate API и создайте ключ API. Когда у вас будет ключ API, добавьте его в свой файл в качестве константы. Далее приведена ссылка, с помощью которой вы можете сделать все перечисленное: https://tech.yandex.com/translate/
Ключ API нужен, чтобы Яндекс мог проводить аутентификацию каждый раз, когда мы хотим использовать его API. Ключ API представляет собой облегченную форму аутентификации, поскольку он добавляется в конце URL запроса при отправке.
Чтобы узнать, какой URL нам нужно отправить для использования API, посмотрим документацию Яндекса.
Там мы найдем всю информацию, необходимую для использования их Translate API для перевода текста.
Если вы видите URL с символами амперсанда (&), знаками вопроса (?) или знаками равенства (=), вы можете быть уверены, что это URL запроса GET. Эти символы задают сопутствующие параметры для URL.
Обычно все, что размещено в квадратных скобках ([]), будет необязательным. В данном случае для запроса необязательны формат, опции и обратная связь, но обязательны параметры key, text и lang.
Добавим код для отправки на этот URL. Замените первый созданный нами запрос на следующий:
Другие коды языков можно посмотреть здесь. Нам нужен столбец 639-1.
Когда мы передаем параметры таким образом, Requests автоматически добавляет параметры в URL за нас.
Теперь добавим команду печати текста ответа и посмотрим, что мы получим в результате.
Посмотрим заголовки полученного ответа.
Разумеется, заголовки должны быть другими, поскольку мы взаимодействуем с другим сервером, но в данном случае мы видим тип контента application/json вместо text/html. Это означает, что эти данные могут быть интерпретированы в формате JSON.
Если ответ имеет тип контента application/json, библиотека Requests может конвертировать его в словарь и список, чтобы нам было удобнее просматривать данные.
Если вы распечатаете его, вы увидите те же данные, но в немного другом формате.
Причина отличия заключается в том, что это уже не обычный текст, который мы получаем из файла res.text. В данном случае это печатная версия словаря.
Допустим, нам нужно получить доступ к тексту. Поскольку сейчас это словарь, мы можем использовать ключ текста.
Теперь мы видим данные только для этого одного ключа. В данном случае мы видим список из одного элемента, так что если мы захотим напрямую получить текст в списке, мы можем использовать указатель для доступа к нему.
Теперь мы видим только переведенное слово.
Попробуйте перевести более длинный текст на другие языки и посмотрите, какие ответы будет вам присылать API.
Примеры ошибок Translate API
В заключение рассмотрим пример ошибки. Иногда что-то не работает, и нужно знать, что делать в подобных случаях.
Попробуйте изменить ключ API, удалив один символ. Теперь ваш ключ API будет недействителен. Попробуйте отправить запрос.
Если вы посмотрите код состояния, вы увидите следующее:
При использовании API нужно проверять, был ли запрос успешно выполнен, чтобы вы могли обрабатывать ошибки в соответствии с требованиями вашего приложения.
Заключение
Мы узнали следующее:
Если вы хотите узнать больше, посмотрите в этом списке различные доступные API и попробуйте использовать их с библиотекой Python Requests.
