Как получить данные с сервера python

Как получать конкретные данные из сервера?

Я написал простой код клиента, с помощью его я отправляю запрос на сервер и хочу получить данные: Пользователь: текст. Как мне это сделать работая с библиотекой request? Код клиента:

import requests data = payload = response = requests.get('http://xx.xx.x.x:xxxx/getmessages',params=data, stream=False) if response: print('Соединение установлено') else: print('Соединение потерянно') print(response.text) 

Видите ли, я создаю веб чат сервер который соединен по локальному соединению. На одном компьютере написан код сервера, а на другом код клиента. Отправлять данные на сервер у меня получается. А вот принимать данные, чтобы они показывались в консоли — нет. Поэтому я прошу помощи и хочу узнать как принять данные отправленные с другого клиента на сервер и вывести их в консоли visual code

Как получить данные с сервера python

В запросе могут передаваться различные данных, например, через отправку каких-то значений в формате json. Рассмотрим, как получать подобные данные.

Body

Для получения данных из тела запроса можно использовать класс Body из пакета fastapi . Данный класс позволяет связать с параметром функции-обработчика запроса либо все тело запроса, либо какие-то отдельные его значения. Для примера для упрощения отправки данных определим в проекте папку public , в которой создадим новый файл index.html со следующим кодом:

      
Введите имя: 
 
 
Введите возраст: 
 
 Отправить    

В данном случае для ввода данных на веб-странице определено текстовое поле, в которое пользователь вводит свое имя. По нажатию на кнопку срабатывает функция send() , определенная в коде javascript. Эта функция получает введенное значение и с помощью функции fetch отправляет его по адресу «/hello» в запросе типа POST. При этом в теле запроса посылаются сериализованные в JSON данные. В частности, посылается объект, в котором свойство name хранит введенное имя.

После отправки запроса мы ожидаем, что сервер в ответ пришлет нам некоторые данные — некоторый объект JSON, в котором будет свойство «message». И значение этого свойства выводим на веб-страницу в элемент с >

Затем определим основной файл приложения main.py , который будет получать и обрабатывать запросы:

from fastapi import FastAPI, Body from fastapi.responses import FileResponse app = FastAPI() @app.get("/") def root(): return FileResponse("public/index.html") @app.post("/hello") #def hello(name = Body(embed=True)): def hello(data = Body()): name = data["name"] age = data["age"] return , ваш возраст - ">

Здесь при обращении по пути «/» клиенту будет отправляться страница index.html для ввода данных.

Для обработки полученных в POST-запросе данных по адресу «/hello» определена функция hello() . Эта функция имеет один параметр — data, который получает содержимое тела запроса:

data = Body()

То есть здесь data будет представлять весь объект, который отправляется с веб-страницы и который имеет свойства «name» и «age». Этот объект в python будет представлять словарь. Соответственно, чтобы получить значения свойства «name», обращаемся по одноименному ключу:

name = data["name"]

Подобным образом получаем значение свойства «age». Затем в ответ клиенту посылается словарь с элементом «message».

Получение отдельных значений

В примере выше мы получали все данные из тела запроса в один параметр. Однако, установив параметр embed=True , можно получать отдельные значения:

from fastapi import FastAPI, Body from fastapi.responses import FileResponse app = FastAPI() @app.get("/") def root(): return FileResponse("public/index.html") @app.post("/hello") def hello(name = Body(embed=True), age = Body(embed=True)): return , ваш возраст - ">

Валидация

Класс Body позволяет валидировать значения из тела запроса. В частности, через конструктор Body можно установить следующие параметры для валидации значений:

• min_length : устанавливает минимальное количество символов в значении параметра
• max_length : устанавливает максимальное количество символов в значении параметра
• regex : устанавливает регулярное выражение, которому должно соответствовать значение параметра
• lt : значение параметра должно быть меньше определенного значения
• le : значение параметра должно быть меньше или равно определенному значению
• gt : значение параметра должно быть больше определенного значения
• ge : значение параметра должно быть больше или равно определенному значению

Применим некотрые параметры:

from fastapi import FastAPI, Body from fastapi.responses import FileResponse app = FastAPI() @app.get("/") def root(): return FileResponse("public/index.html") @app.post("/hello") def hello(name:str = Body(embed=True, min_length=3, max_length=20), age: int = Body(embed=True, ge=18, lt=111)): return , ваш возраст - ">

В данном случае значение параметра name должно иметь не меньше 3 и не больше 20 символов, а параметр «age» должен представлять число в диапазоне от 18 (включительно) до 111 (не включая)

Пособие по HTTP-запросам в Python и Web API

В этой статье мы рассмотрим, что такое API и, в частности, REST API. Также мы разберем, что такое HTTP-запросы и какими они бывают. Кроме того, мы рассмотрим основные компоненты библиотеки requests и предоставим несколько примеров кода, которые помогут вам начать работу с ней.

Что такое API

Интерфейс прикладного программирования (API) — это посредник между программами; его работа заключается в том, чтобы разрешать приложениям взаимодействовать друг с другом. Эти неявные посредники постоянно появляются в нашей повседневной жизни, знаете вы об этом или нет. Например, если сегодня вы отправляли сообщение в мессенджере, то вы использовали API.

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

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

HTTP-запросы в Python делаются при помощи библиотеки requests. Это практически стандарт. Правда, в Python также есть встроенная библиотека urllib, но питонисты, как правило, предпочитают API библиотеки requests из-за ее удобочитаемости и того факта, что она полностью поддерживает REST API. Этого мы коснемся чуть позже.

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

REST API

Мы определили, что API — это посредник между программами. Иначе его можно представить как тип программного интерфейса, который предоставляет другим приложениям доступ к определенным данным и методам.

Одной из самых популярных архитектур, используемых для создания API, является шаблон REpresentational State Transfer (REST). Архитектура REST позволяет реализовывать приложения на стороне клиента и на стороне сервера независимо друг от друга. Это означает, что код на любой стороне можно изменить, не беспокоясь о том, как это изменение повлияет на другую сторону.

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

Данные из веб-служб REST доступны в Интернете через общедоступный URL-адрес, к которому можно обращаться, отправляя HTTP-запросы.

HTTP-запросы

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

Интерфейсы REST API точно такие же: они прослушивают HTTP-запросы, прежде чем предпринимать какие-либо действия. Протокол HTTP — это то, что определяет набор запросов, чтобы сообщить API, какие операции выполнять для данного ресурса. Он указывает, как взаимодействовать с ресурсами, расположенными в данной конечной точке.

С REST API обычно используются следующие HTTP-запросы:

HTTP-запросы	Их описание
GET	Получить данные
POST	Создать данные
PUT	Обновить существующие данные
PATCH	Частично обновить существующие данные
DELETE	Удалить данные

Весьма вероятно, что вы будете выполнять HTTP-запросы GET чаще, чем любые другие методы анализа данных. Это связано с тем, что GET — самый важный метод, необходимый для получения доступа к определенным наборам данных.

Когда вы выполняете запрос к веб-серверу, его API возвращает ответ. К ответу прилагается код состояния HTTP. Код состояния дает дополнительную информацию об ответе, чтобы клиент знал тип полученного запроса.

Конечные точки

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

Чтобы добавить больше контекста, REST API предоставляют набор общедоступных URL-адресов, которые могут быть запрошены клиентскими приложениями для доступа к ресурсам веб-службы. Общедоступные URL-адреса, предоставляемые REST API, называются конечными точками.

Использование Python для работы с API

API библиотеки requests позволяет разработчикам писать код для взаимодействия с REST API. Это дает им возможность отправлять HTTP-запросы с помощью Python, не беспокоясь о сложностях, которые обычно возникают при выполнении таких задач (например, ручное добавление строк запроса к URL-адресам, кодирование форм данных PUT и POST и т. д.).

Несмотря на то, что библиотека requests считается де-факто стандартом для создания HTTP-запросов в Python, она не является частью стандартной библиотеки Python и ее необходимо установить.

Наиболее естественно сделать это при помощи менеджера пакетов pip:

python -m pip install requests

Этот код представляет собой команду, которую можно запустить в терминале или в командной строке. Флаг -m указывает интерпретатору Python запустить модуль pip как скрипт, а request — это имя устанавливаемого пакета. После выполнения этой команды библиотека requests будет установлена ​​и доступна для использования в среде Python.

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

Теперь, когда у нас установлен модуль requests, давайте посмотрим, как он работает.

Делаем GET-запрос

Мы уже говорили, что GET — это один из наиболее распространенных HTTP-запросов, с которыми вы столкнетесь при работе с REST API. Он позволяет вам (то есть клиенту) получать данные с веб-серверов.

Важно отметить, что GET — это операция только для чтения. Это означает, что она подходит только для доступа к существующим ресурсам, но не должна использоваться для их изменения.

Чтобы продемонстрировать, как работает модуль запроса, мы будем использовать JSONPlaceholder — свободно доступный API, используемый для тестирования и прототипирования.

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

import requests # Конечная точка API url = "https://jsonplaceholder.typicode.com/posts/1" # GET-запрос к API response = requests.get(url) # Выводим ответ в консоль response_json = response.json() print(response_json) # Результат """ """

В приведенном выше коде мы сделали следующее:

1. Определили конечную точка API для извлечения данных.
2. Для получения данных из определенной конечной точки использовали метод request.get(url) .
3. Мы использовали метод response.json() для хранения данных ответа в объекте словаря. Обратите внимание, что это работает только потому, что результат записывается в формате JSON — иначе бы возникла ошибка.
4. Последний шаг — выводим данные ответа в консоль в формате JSON.

Код состояния, возвращенный нам API, мы можем проверить следующим образом:

# Print status code from original response (not JSON) print(response.status_code) # Результат """ 200 """

Результат показывает, что код состояния равен 200. Это значит, что запрос выполнен успешно.

В GET-запрос также можно передавать аргументы. Для этого нужно немного изменить приведенный выше код. Вот как теперь он будет выглядеть:

# Конечная точка API url = "https://jsonplaceholder.typicode.com/posts/" # Добавляем переменную payload payload = # GET-запрос к API response = requests.get(url, params=payload) # Выводим ответ в консоль response_json = response.json() for i in response_json: print(i, "\n") # Результат """   """

Вот что мы изменили:

1. Изменили конечную точку API. Обратите внимание, что в конце больше нет 1 .
2. Задали переменную payload в виде словаря.
3. Передали переменную payload в аргумент param метода request.get() .
4. Нам вернулся объект в виде списка. Поэтому мы его проитерировали при помощи цикла for и вывели каждый его элемент в новой строке.

Делаем POST-запрос

GET-запросы позволяют вам получать данные. HTTP-запросы POST позволяют создавать новые данные. Давайте посмотрим, как мы можем создавать новые данные на сервере JSONPlaceholder.

# Определяем новые данные new_data = < "userID": 1, "id": 1, "title": "Making a POST request", "body": "This is the data we created." ># Конечная точка API для связи url_post = "https://jsonplaceholder.typicode.com/posts" # POST-запрос к API post_response = requests.post(url_post, json=new_data) # Выводим ответ в консоль post_response_json = post_response.json() print(post_response_json) # Результат """ """

В приведенном выше коде мы сделали следующее:

1. Создали новые данные в виде словаря, который мы хотим добавить в JSONPlaceholder API.
2. Определили конечную точку для помещения новых данных при помощи POST-запроса.
3. Отправили POST-запрос при помощи метода request.post() . Обратите внимание, что в методе post() мы установили параметр json . Мы сделали это, чтобы в явном виде сообщить API, что мы отправляем данные в формате JSON.
4. Использовали метод response.json() для сохранения данных ответа в объекте словаря.
5. Последний шаг — выводим данные ответа в консоль в формате JSON.

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

Имейте ввиду, что на этот раз мы создали новые данные, а не просто их извлекли.

Ок, вот код ответа от сервера:

# Print status code from original response (not JSON) print(post_response.status_code) # Результат: """ 201 """

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

А вы угадали ответ?

Продвинутые темы

Запросы аутентификации

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

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

Вот простой способ сделать это с использованием модуля requests Python:

from requests.auth import HTTPBasicAuth private_url = "https://api.github.com/user" github_username = "username" token = "token" private_url_response = requests.get( url=private_url, auth=HTTPBasicAuth(github_username, token) ) private_url_response.status_code # Результат: """ 200 """

В данном коде мы сделали следующее:

1. Импортировали объект HTTPBasicAuth из request.auth . Этот объект прикрепляет базовую аутентификацию HTTP к нашему объекту запроса — это по сути то же самое, что и ввод вашего имени пользователя и пароля на сайте.
2. Задали конечную точку доступа в переменной private_url .
3. Создали переменную с именем пользователя GitHub (мы анонимизировали имя пользователя для конфиденциальности).
4. Создали переменную token с личным токеном доступа для аутентификации в Github.
5. Получили данные из нашей конечной точки и сохранили их в переменной private_url_response .
6. Отобразили код состояния, который говорит нам о том, что запрос был выполнен успешно.

Обработка ошибок

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

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

Давайте опять вернемся к API сервера JSONPlaceholder. Мы начнем с написания кода, а затем объясним, что происходит.

# В конечной точке "postz" вместо "posts". Была сделана преднамеренная опечатка. url = "https://jsonplaceholder.typicode.com/postz" # Attempt to GET data from provided endpoint try: response = requests.get(url) response.raise_for_status() # If the request fails (404) then print the error. except requests.exceptions.HTTPError as error: print(error) # Результат: """ 404 Client Error: Not Found for url: https://jsonplaceholder.typicode.com/postz """

В данном коде мы сделали следующее:

1. Определена конечная точка сервера JSONPlaceholder для извлечения данных, но мы сделали преднамеренную опечатку при построении URL-адреса — это должно вызвать ошибку 404.
2. Использована встроенная обработка исключений Python. try и except перехватывают любые ошибки, возникающие при попытке обратиться к серверу JSONPlaceholder. Обратите внимание, что метод raise_for_status() используется для возврата объекта HTTPError при возникновении ошибки во время процесса запроса.
3. В консоль выводится возникшая ошибка.

Хотя в этом примере мы продемонстрировали, как обрабатывать ошибку 404, тот же формат можно использовать для обработки любого кода состояния HTTP.

Работа со слишком большим количеством переадресаций (редиректов)

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

Для решения этой проблемы модуль requests предоставляет объект TooManyRedirects , который работает следующим образом:

""" Примечание: данный код здесь не вызовет ошибку, но его структура такова, что в нем есть несколько переадресаций """ url = "https://jsonplaceholder.typicode.com/posts" try: response = requests.get(url) response.raise_for_status() except requests.exceptions.TooManyRedirects as error: print(error)

Если переадресаций слишком много, метод raise_for_status() вызовет исключение TooManyRedirects , которое перехватывается блоком исключения и будет выведено сообщение об ошибке.

Вы также можете установить максимальное количество переадресаций в качестве параметра вашего метода HTTP-запроса:

# Решение 2 url = "https://jsonplaceholder.typicode.com/posts" session = requests.Session() session.max_redirects = 3 response = session.get(url)

Другой вариант — полностью отключить переадресацию:

# Решение 3 url = "https://jsonplaceholder.typicode.com/posts" session = requests.Session() session.allow_redirects = False response = session.get(url)

Строка session.allow_redirects = False устанавливает для атрибута allow_redirects объекта Session значение False , что означает, что сеанс не будет следовать никаким переадресациям, которые могут быть возвращены сервером.

Ошибки подключения

Это еще один тип ошибок, с которыми вы можете столкнуться при отправке запросов на сервер. Существует несколько причин, по которым вы можете не получить ответ от сервера. Например, сбой DNS, отказ в подключении, проблемы с подключением к Интернету и так далее. Но результат одинаков: возникает ошибка подключения.

Вы можете использовать объект ConnectionError модуля requests, чтобы обнаружить такого рода проблемы и обработать их соответствующим образом.

Вот как будет выглядеть код:

""" Примечание: данный код здесь не вызовет ошибку, но его структура такова, что если произойдет ошибка подключения, то она будет обработана. """ url = "https://jsonplaceholder.typicode.com/posts" try: response = requests.get(url) except requests.ConnectionError as error: print(error)

Таймаут

Когда API сервера принимает соединение, но не может выполнить ваш запрос в отведенное время, вы получите так называемую timeout error (ошибку таймаута).

Мы продемонстрируем, как справиться с этим случаем, установив для параметра timeout в методе request.get() очень маленькое число. Это вызовет ошибку, и мы ее обработаем с помощью объекта request.Timeout .

url = "https://jsonplaceholder.typicode.com/posts" try: response = requests.get(url, timeout=0.0001) except requests.Timeout as error: print(error)

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

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

Заключение

В данной статье мы рассмотрели, что такое API, и изучили общую архитектуру API, называемую REST. Мы также рассмотрели HTTP-запросы и то, как мы можем использовать библиотеку requests языка Python для взаимодействия с веб-сервисами.

Введение в работу с библиотекой Requests в Python

While we believe that this content benefits our community, we have not yet thoroughly reviewed it. If you have any suggestions for improvements, please let us know by clicking 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 с помощью pip . Если вы еще не создали виртуальную среду, стоит сделать это сейчас.

Наш первый запрос

Для начала мы используем библиотеку Requests для отправки запроса на сайт Scotch.io. Создайте файл с именем script.py и добавьте в него следующий код. В этой статье мы рассматриваем небольшое количество кода, поэтому если что-то изменится, вы можете просто обновить существующий код вместо добавления новых строк.

import requests res = requests.get('https://scotch.io') print(res) 

Этот код просто отправляет запрос GET на сайт Scotch.io. Это такой же тип запроса, какой используется вашим браузером для просмотра этой страницы, и единственное отличие заключается в том, что библиотека Requests не может выполнить рендеринг кода HTML, и поэтому вы получите просто код HTML и другую информацию, содержащуюся в ответе. Здесь мы используем функцию .get() , однако Requests также позволяет использовать при отправке запросов и другие функции, в том числе .post() и .put() . Для отправки запроса нужно запустить файл script.py.

Вот что вы получите в результате: запуск .

Коды состояния

• 1XX — информация
• 2XX — успешно
• 3XX — перенаправление
• 4XX — ошибка клиента (ошибка на вашей стороне)
• 5XX — ошибка сервера (ошибка на их стороне)

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

Библиотека Requests понимает, что коды состояния 4XX и 5XX сигнализируют об ошибках, и поэтому при возврате этих кодов состояния объекту ответа на запрос присваивается значение False .

Проверив истинность ответа, вы можете убедиться, что запрос успешно обработан. Например:

if res: print('Response OK') else: print('Response Failed') 

Сообщение Response Failed появится только при возврате кода состояния 400 или 500. Попробуйте заменить URL на несуществующий, чтобы увидеть ошибку ответа 404.

Чтобы посмотреть код состояния, добавьте следующую строку:

print(res.status_code) 

Так вы увидите код состояния и сможете сами его проверить.

Заголовки

Также в ответе вы можете получить заголовки. Вы можете посмотреть их, используя словарь headers для объекта response.

print(res.headers) 

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

Мы увидим в ответе несколько заголовков. Обычно информация из заголовков не требуется, однако если она вам нужна, вы можете ее получить.

Обычно требуется заголовок content type, поскольку он показывает формат данных, например HTML, JSON, PDF, обычный текст и т. д. Однако заголовок content type обрабатывается библиотекой Requests, и вы имеете доступ ко всем возвращаемым данным.

Текст ответа

Если мы посмотрим на файл res.text (это работает для текстовых данных, таких как просматриваемая нами страница HTML), мы увидим весь код HTML, требуемый для построения домашней страницы Scotch. Рендеринг выполняться не будет, но мы увидим, что он принадлежит Scotch. Если вы сохраните этот код в файл и откроете его, вы увидите что-то похожее на сайт Scotch. В реальных условиях для загрузки на одну веб-страницу изображений, скриптов, таблиц стилей и т. д. отправляется несколько запросов, так что если вы сохраните в файл только код HTML и откроете его в браузере, результат не будет похож на страницу Scotch.io, поскольку для получения данных HTML был отправлен только один запрос.

print(res.text) 

Использование Translate API

Теперь перейдем к чему-то более интересному. Мы используем API Яндекс.Перевод (Yandex Translate API) для выполнения запроса на перевод текста на другой язык.

Чтобы использовать API, нужно предварительно войти в систему. После входа в систему перейдите к Translate API и создайте ключ API. Когда у вас будет ключ API, добавьте его в свой файл в качестве константы. Далее приведена ссылка, с помощью которой вы можете сделать все перечисленное: https://tech.yandex.com/translate/

API_KEY = 'your yandex api key' 

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

Чтобы узнать, какой URL нам нужно отправить для использования API, посмотрим документацию Яндекса.

Там мы найдем всю информацию, необходимую для использования их Translate API для перевода текста.

Если вы видите URL с символами амперсанда (&), знаками вопроса (?) или знаками равенства (=), вы можете быть уверены, что это URL запроса GET. Эти символы задают сопутствующие параметры для URL.

Обычно все, что размещено в квадратных скобках ([]), будет необязательным. В данном случае для запроса необязательны формат, опции и обратная связь, но обязательны параметры key, text и lang.

Добавим код для отправки на этот URL. Замените первый созданный нами запрос на следующий:

url = 'https://translate.yandex.net/api/v1.5/tr.json/translate' res = requests.get(url) 

Существует два способа добавления параметров. Мы можем прямо добавить параметры в конец URL, или библиотека Requests может сделать это за нас. Для последнего нам потребуется создать словарь параметров. Нам нужно указать три элемента: ключ, текст и язык. Создадим словарь, используя ключ API, текст Hello и язык en-es , т. к. нам требуется перевод с английского на испанский.

Другие коды языков можно посмотреть здесь. Нам нужен столбец 639-1.

Мы создаем словарь параметров, используя функцию dict() , и передаем ключи и значения, которые хотим использовать в нашем словаре.

params = dict(key=API_KEY, text='Hello', lang='en-es') 

Теперь возьмем словарь параметров и передадим его функции .get() .

res = requests.get(url, params=params) 

Когда мы передаем параметры таким образом, Requests автоматически добавляет параметры в URL за нас.

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

print(res.text) 

Мы видим три вещи. Мы видим код состояния, который совпадает с кодом состояния ответа, мы видим заданный нами язык и мы видим переведенный текст внутри списка. Итак, мы должны увидеть переведенный текст Hola .

Повторите эту процедуру с кодом языка en-fr, и вы получите ответ Bonjour .

params = dict(key=API_KEY, text='Hello', lang='en-fr') 

Посмотрим заголовки полученного ответа.

print(res.headers) 

Разумеется, заголовки должны быть другими, поскольку мы взаимодействуем с другим сервером, но в данном случае мы видим тип контента application/json вместо text/html. Это означает, что эти данные могут быть интерпретированы в формате JSON.

Если ответ имеет тип контента application/json, библиотека Requests может конвертировать его в словарь и список, чтобы нам было удобнее просматривать данные.

Для обработки данных в формате JSON мы используем метод .json() на объекте response.

Если вы распечатаете его, вы увидите те же данные, но в немного другом формате.

json = res.json() print(json) 

Причина отличия заключается в том, что это уже не обычный текст, который мы получаем из файла res.text. В данном случае это печатная версия словаря.

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

print(json['text']) 

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

print(json['text'][0]) 

Теперь мы видим только переведенное слово.

Разумеется, если мы изменим параметры, мы получим другие результаты. Изменим переводимый текст с Hello на Goodbye , изменим язык перевода на испанский и снова отправим запрос.

params = dict(key=API_KEY, text='Goodbye', lang='en-es') 

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

Примеры ошибок Translate API

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

Попробуйте изменить ключ API, удалив один символ. Теперь ваш ключ API будет недействителен. Попробуйте отправить запрос.

Если вы посмотрите код состояния, вы увидите следующее:

print(res.status_code) 

При использовании API нужно проверять, был ли запрос успешно выполнен, чтобы вы могли обрабатывать ошибки в соответствии с требованиями вашего приложения.

Заключение

Мы узнали следующее:

• Принципы работы запросов HTTP
• Различные коды состояния, которые могут присутствовать в ответе
• Как отправлять запросы и получать ответы с помощью библиотеки Python Requests
• Как использовать API языкового перевода для перевода текста
• Как конвертировать ответы в формате application/JSON в словари

Если вы хотите узнать больше, посмотрите в этом списке различные доступные API и попробуйте использовать их с библиотекой Python Requests.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.