Python и API: Выигрышная комбинация для чтения общедоступных данных

$ python -m pip install requests


Примеры в этом руководстве были протестированы с использованием Python 3.13.1 и requests 2.32.3. Однако любая поддерживаемая версия Python и requests должна давать аналогичные результаты.
Вызов Вашего первого API с помощью Python
Хватит болтать — пора сделать свой первый вызов API! В первом примере вы будете вызывать популярный API для генерации случайных пользовательских данных.
На протяжении всего урока вы будете видеть новые API-интерфейсы, представленные в блоках оповещений, подобных приведенному ниже. Это удобный способ просмотреть их позже и быстро найти все новые API-интерфейсы, о которых вы узнали.
 API генератора случайных пользователей:  Это отличный инструмент для  генерации случайных пользовательских данных. Вы можете использовать его для генерации любого количества случайных пользователей и связанных с ними данных, а также для указания пола, национальности и многих других фильтров, которые могут быть действительно полезны при тестировании приложений или, в данном случае, API.
Все, что вам нужно, чтобы начать работу с API генератора случайных пользователей, - это знать, с помощью какого URL его вызывать. В этом примере используется URL-адрес https://randomuser.me/api/, и это самый простой вызов API, который вы можете выполнить:

>>> import requests
>>> requests.get("https://randomuser.me/api/")
<Response [200]>


В этом небольшом примере вы  импортируете библиотеку requests, а затем извлекаете данные из URL-адреса для API генератора случайных пользователей. Но на самом деле вы не видите возвращенных данных. Вместо этого вы получаете Response [200], что в терминах API означает, что все прошло нормально.
Если вы хотите увидеть фактические данные, то вы можете использовать .text из возвращаемого Response объекта:

>>> import requests
>>> response = requests.get("https://randomuser.me/api/")
>>> response.text
'{"results":[{"gender":"female",
"name":{"title":"Ms","first":"Isobel","last":"Wang"}...'


Вот и все! Теперь вы знаете все основы использования API. Вам удалось выбрать своего первого случайного пользователя из API генератора случайных пользователей, используя Python и библиотеку requests.
Конечные точки и ресурсы
Как вы видели выше, первой частью информации, необходимой для использования API, является URL API, обычно называемый базовый URL. Структура базовых URL-адресов ничем не отличается от URL-адресов, которые вы используете для просмотра Google, YouTube или Facebook, хотя обычно они содержат слово api. Это не обязательно, это скорее эмпирическое правило.
Например, вот базовые URL-адреса для нескольких известных проигрывателей API:

https://api.twitter.com
https://api.github.com
https://api.stripe.com

Как вы можете видеть, все вышеперечисленное начинается с https://api и включает остальные официальные домены, такие как .twitter.com или .github.com. Нет определенного стандарта для того, как должен выглядеть базовый URL API, но довольно часто он имитирует эту структуру.
Если вы попытаетесь открыть любую из приведенных выше ссылок, то заметите, что большинство из них выдают сообщение об ошибке или запрашивают учетные данные. Это связано с тем, что API-интерфейсы иногда требуют выполнения шагов аутентификации, прежде чем вы сможете их использовать. Вы узнаете больше об этом чуть позже в руководстве.
 Cat API:  Этот API довольно забавный, но также и действительно хороший пример хорошо выполненного API с отличной документацией . С его   помощью вы можете выбрать различные породы кошек и некоторые изображения, но если вы зарегистрируетесь, вы также сможете проголосовать за своих любимых кошек.
Далее, используя Cat API, вы попытаетесь выполнить базовый запрос, чтобы увидеть, чем он может отличаться от API генератора случайных пользователей, который вы пробовали выше:

>>> import requests
>>> response = requests.get("https://api.thecatapi.com/")
>>> response.text
'{"message":"The Cat API","version":"1.3.9"}'


В этом случае при вызове базового URL-адреса вы получаете общее сообщение "The Cat API". Это происходит потому, что вы вызываете базовый URL-адрес, который обычно используется для получения самой базовой информации об API, а не реальных данных.
Вызов базового URL-адреса сам по себе не доставляет особого удовольствия, но именно здесь пригодятся конечные точки. Конечная точка - это часть URL-адреса, которая указывает, какой ресурс вы хотите получить. Хорошо документированные API-интерфейсы обычно содержат Ссылку на API, которая чрезвычайно полезна для точного определения того, какие конечные точки и ресурсы есть у API и как их использовать.
Вы можете ознакомиться с официальной документацией, чтобы узнать больше о том, как использовать Cat API и какие конечные точки доступны. Там вы найдете /breeds конечную точку, которую вы можете использовать для извлечения всех доступных ресурсов или объектов breed.
Теперь попробуйте это в локальном коде, используя конечную точку breeds и некоторые знания API, которые у вас уже есть:

>>> response = requests.get("https://api.thecatapi.com/v1/breeds")
>>> response.text
'[{"weight":{"imperial":"7  -  10","metric":"3 - 5"},"id":"abys",...}]'


Вот, пожалуйста, ваш первый список пород с использованием Cat API!
Если вы любитель собак, не волнуйтесь. Для вас тоже есть API с той же конечной точкой, но другим базовым URL:

>>> response = requests.get("https://api.thedogapi.com/v1/breeds")
>>> response.text
'[{...,"id":1,"name":"Affenpinscher",...}]'


Держу пари, вы уже думаете о различных способах использования этих API для создания какого-нибудь симпатичного побочного проекта, и это самое замечательное в API. Как только вы начнете ими пользоваться, ничто не помешает вам превратить хобби или страсть в увлекательный проект.
Прежде чем двигаться дальше, вам нужно знать одну вещь о конечных точках - это разница между http:// и https://. В двух http://  словах, https://  HTTPS 
  - это зашифрованная версия HTTP, которая делает весь трафик между клиентом и сервером намного более безопасным. При использовании общедоступных API-интерфейсов вам определенно следует избегать отправки какой-либо частной или конфиденциальной информации на конечные точки и использовать только те API-интерфейсы, которые предоставляют безопасный базовый URL-адрес.
Для получения дополнительной информации о том, почему важно придерживаться HTTPS при просмотре онлайн, ознакомьтесь с Изучение HTTPS с помощью Python..
В следующем разделе вы немного подробнее познакомитесь с основными компонентами вызова API.
Запрос и ответ
Как вы вкратце прочитали выше, все взаимодействия между клиентом — в данном случае, вашей консолью Python — и API делятся на запрос и ответ:

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

Снова используя Cat API, вы можете немного подробнее разобраться в том, что именно находится внутри объектов Request и Response:

>>> response = requests.get("https://api.thecatapi.com/v1/breeds")
>>> response
<Response [200]>
>>> response.status_code
200
>>> response.text
'[{"weight":{"imperial":"7  -  10","metric":"3 - 5"},
"id":"abys","name":"Abyssinian","origin":"Egypt",
"temperament":"Active, Energetic, Independent, Intelligent, Gentle",...}]'
>>> response.headers
{'content-type': 'application/json; charset=utf-8',
'x-response-time': '1ms',  'Date': 'Mon, 24 Jul 2023 12:37:59 GMT',
'Server': 'Google Frontend', 'Content-Length': '76734', ...}

>>> response.request
<PreparedRequest [GET]>
>>> request = response.request
>>> request.url
'https://api.thecatapi.com/v1/breeds'
>>> request.path_url
'/v1/breeds'
>>> request.method
'GET'
>>> request.headers
{'User-Agent': 'python-requests/2.32.3', 'Accept-Encoding': 'gzip, deflate',
'Accept': '*/*', 'Connection': 'keep-alive'}


Здесь вы получили доступ к нескольким наиболее важным атрибутам, которые доступны для объектов Request и Response.
Вы узнаете больше о некоторых из этих атрибутов в этом руководстве, но если вы хотите копнуть еще глубже, то можете ознакомиться с документацией Mozilla по HTTP-сообщениям для получения более подробного объяснения каждого атрибута.
Коды состояния
 Коды состояния являются одной из наиболее важных частей информации, которую следует искать в любом ответе API. Они сообщают вам, был ли ваш запрос выполнен успешно, отсутствуют ли данные, не указаны ли учетные данные и так далее.
Со временем вы научитесь распознавать различные коды состояния без посторонней помощи. Но пока что вот список с некоторыми наиболее распространенными кодами состояния, которые вы найдете:



Status code
Description




200 OK
Your request was successful!


201 Created
Your request was accepted, and the resource was created.


400 Bad Request
Your request is either wrong or missing some information.


401 Unauthorized
Your request requires some additional permissions.


404 Not Found
The requested resource doesn’t exist.


405 Method Not Allowed
The endpoint doesn’t allow for that specific HTTP method.


500 Internal Server Error
Your request wasn’t expected and probably broke something on the server side.



Вы видели 200 OK ранее в примерах, которые вы выполнили, и, возможно, даже узнаете 404 Not Found, просматривая веб-страницы.
 Забавный факт: Компании, как правило, используют 404 страницы с ошибками для личных шуток или просто для развлечения, как в приведенных ниже примерах:

404 страницы с ошибками в www.mantralabsglobal.com и www.pixar.com
Однако в мире API у разработчиков есть ограниченное пространство в ответах для такого рода развлечений. Но они компенсируют это в других местах, например, в заголовках HTTP. Совсем скоро вы увидите несколько примеров!
Вы можете проверить статус ответа, используя .status_code и .reason. Библиотека requests также выводит код состояния в представлении объекта Response:

>>> response = requests.get("https://api.thecatapi.com/v1/breeds")
>>> response
<Response [200]>
>>> response.status_code
200
>>> response.reason
'OK'


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

>>> response = requests.get("https://api.thecatapi.com/v1/breedz")
>>> response
<Response [404]>
>>> response.status_code
404
>>> response.reason
'Not Found'


Как вы можете видеть, конечная точка /breedz не существует, поэтому API возвращает код состояния 404 Not Found.
Вы можете использовать эти коды статуса, чтобы быстро узнать, нужно ли вам изменить свой запрос, или еще раз проверить документацию на наличие опечаток или пропущенных фрагментов.
HTTP-заголовки
HTTP-заголовки могут определять несколько параметров, управляющих запросами и ответами:



HTTP Header
Description




Accept
What type of content the client can accept


Content-Type
What type of content the server will respond with


User-Agent
What software the client is using to communicate with the server


Server
What software the server is using to communicate with the client


Authentication
Who’s calling the API and what credentials they have



Существует множество других заголовков, которые вы можете найти при проверке запроса или ответа. Взгляните на  Расширенный список Mozilla,  если вам интересно, как конкретно используется каждый из них.
Чтобы просмотреть заголовки ответа, вы можете использовать response.headers:

>>> response = requests.get("https://api.thecatapi.com/v1/breeds/abys")
>>> response.headers
{'content-type': 'application/json; charset=utf-8',
'x-response-time': '1ms',  'Date': 'Mon, 24 Jul 2023 12:41:34 GMT',
'Server': 'Google Frontend', 'Content-Length': '1041', ...}


Чтобы сделать то же самое с заголовками запроса, вы можете использовать response.request.headers, поскольку request является атрибутом объекта Response:

>>> response = requests.get("https://api.thecatapi.com/v1/breeds/abys")
>>> response.request.headers
{'User-Agent': 'python-requests/2.32.3',
'Accept-Encoding': 'gzip, deflate', 'Accept': '*/*',
'Connection': 'keep-alive'}


В этом случае вы не определяете какие-либо конкретные заголовки при отправке запроса, поэтому Python возвращает заголовки по умолчанию.
Пользовательские заголовки
Еще один стандарт, с которым вы можете столкнуться при использовании API, - это использование пользовательских заголовков. Обычно они начинаются с X-, но это не является обязательным требованием. Разработчики API обычно используют пользовательские заголовки для отправки или запроса дополнительной пользовательской информации от клиентов.
 Забавный факт: Некоторые компании идут на все, чтобы быть забавными и инновационными, используя HTTP-заголовки так, как они  не должны были использоваться, например, для получения заявок на работу.
Вы можете использовать словарь для определения заголовков, и вы можете отправить их вместе с вашим запросом, используя headers параметр .get().
Например, предположим, вы хотите отправить некоторый идентификатор запроса на сервер API, и вы знаете, что можете сделать это с помощью X-Request-Id:

>>> headers = {"X-Request-Id": "<my-request-id>"}
>>> response = requests.get("https://example.org", headers=headers)
>>> response.request.headers
{'User-Agent': 'python-requests/2.32.3', 'Accept-Encoding': 'gzip, deflate',
'Accept': '*/*', 'Connection': 'keep-alive',
'X-Request-Id': '<my-request-id>'}


Если вы пройдетесь по словарю request.headers, то найдете X-Request-Id в самом конце, среди нескольких других заголовков, которые по умолчанию добавляются к любому запросу API.
В ответе может быть много полезных типов заголовков, но одним из наиболее важных является Content-Type, который определяет тип содержимого, возвращаемого в ответе.
Content-Type
В наши дни большинство API-интерфейсов используют JSON в качестве типа контента по умолчанию, но вам может потребоваться использовать API, который возвращает XML или другие типы мультимедиа, такие как изображения или видео. В этом случае тип контента будет отличаться.
Если вы вернетесь к одному из предыдущих примеров с использованием Cat API и попытаетесь проверить заголовок Content-Type, то заметите, что он был определен как application/json:

>>> response = requests.get("https://api.thecatapi.com/v1/breeds/abys")
>>> response.headers.get("Content-Type")
'application/json; charset=utf-8'


Заголовок возвращает определенный тип содержимого, который в данном случае равен application/json. Он также может возвращать указанную кодировку для содержимого ответа.
Изображение диаграмм по API: это полезный API, который можно использовать для создания графики в различных размеров, которые вы можете использовать на вашем сайте.
Если, например, вы попытаетесь получить диаграмму из API графических диаграмм, то вы заметите, что тип контента больше не application/json, а вместо этого это определяется как image/png:

>>> url = "https://image-charts.com/chart?chs=700x125&cht=ls&chd=t:23,15,28"
>>> response = requests.get(url)
>>> response
<Response [200]>
>>> response.headers.get("Content-Type")
'image/png'


В этом случае в заголовке Content-Type указано, что возвращаемый контент представляет собой изображение в формате PNG. Как просмотреть этот контент, вы узнаете в следующем разделе.
Заголовок Content-Type очень важен для того, чтобы вы знали, как обрабатывать ответ и что делать с его содержимым. Существуют сотни других допустимых типов контента, включая аудио, видео, шрифты и многое другое.
Содержание ответа
Как вы только что узнали, тип содержимого, которое вы найдете в ответе API, будет варьироваться в зависимости от заголовка Content-Type. Чтобы правильно прочитать содержимое ответа в соответствии с различными заголовками Content-Type, пакет requests поставляется с несколькими различными атрибутами Response, которые вы можете использовать для манипулирования данными ответа:

.text возвращает содержимое ответа в формате Unicode.
.content возвращает содержимое ответа в байтах.

Вы уже использовали атрибут .text, указанный выше. Но для некоторых специфических типов данных, таких как изображения и другие нетекстовые данные, использование .content обычно является лучшим подходом, даже если оно возвращает результат, очень похожий на .text:

>>> response = requests.get("https://api.thecatapi.com/v1/breeds/abys")
>>> response.headers.get("Content-Type")
'application/json; charset=utf-8'
>>> response.content
b'{"weight":{"imperial":"7  -  10","metric":"3 - 5"},"id":"abys",...'


Как вы можете видеть, нет большой разницы между .content и ранее использовавшимся .text, хотя b указывает на то, что возвращаемое значение состоит из необработанные байты вместо строки.
Взглянув на заголовок ответа Content-Type, вы можете увидеть, что его содержимым является application/json, объект JSON. Для такого рода контента библиотека requests содержит специальный метод .json(), который вы можете использовать для немедленного преобразования ответа API bytes в структуру данных Python :

>>> response = requests.get("https://api.thecatapi.com/v1/breeds/abys")
>>> response.headers.get("Content-Type")
'application/json; charset=utf-8'
>>> response.json()
{'weight': {'imperial': '7  -  10', 'metric': '3 - 5'},
 'id': 'abys', 'name': 'Abyssinian', ...}
>>> response.json()["name"]
'Abyssinian'


Как вы можете видеть, после выполнения response.json() вы получаете словарь, который можете использовать так же, как и любой другой словарь в Python.
Теперь, оглядываясь на недавний пример, который вы запустили с помощью API графических диаграмм, попробуйте извлечь ту же линейную диаграмму и взглянуть на ее содержимое:

>>> url = "https://image-charts.com/chart?chs=700x125&cht=ls&chd=t:23,15,28"
>>> response = requests.get(url)
>>> response
<Response [200]>

>>> response.headers.get("Content-Type")
'image/png'

>>> response.content
b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x02\xbc\x00\x00\x00...'


В данном случае, поскольку вы запрашиваете изображение, .content не очень полезно. На самом деле, это почти невозможно понять. Однако вы знаете, что это изображение в формате PNG, поэтому можете попробовать сохранить его в  файле и посмотреть, что получится:

>>> with open("chart.png", mode="wb") as file:
...     file.write(response.content)
...


Теперь, если вы откроете папку, с которой работаете, то увидите файл chart.png, представляющий собой изображение линейной диаграммы, которое вы только что извлекли с помощью API. Разве это не удивительно?
HTTP-методы
При вызове API существует несколько различных методов, также называемых глаголами, которые вы можете использовать, чтобы указать, какое действие вы хотите выполнить. Например, если вы хотите получить какие-то данные, то вам следует использовать метод GET, а если вы хотите создать какие-то данные, то вам следует использовать метод POST.
При использовании только данных с использованием API-интерфейсов вы обычно будете придерживаться GET запросов, но вот список наиболее распространенных методов и их типичных вариантов использования:



HTTP Method
Description
Requests method




POST
Create a new resource.
requests.post()


GET
Read an existing resource.
requests.get()


PUT
Update an existing resource.
requests.put()


DELETE
Delete an existing resource.
requests.delete()



Обычно вы называете эти четыре метода CRUD-операциями, поскольку они позволяют создавать, считывать, обновлять и удалять ресурсы.
 Примечание:  Существует дополнительный метод PATCH, который также связан с CRUD-операциями, но он немного менее распространен, чем четыре вышеперечисленных. Он используется для внесения частичных изменений вместо полной замены ресурса с использованием PUT. 
Вы можете прочитать немного больше о различиях  между PUT и PATCH, чтобы понять их различные потребности.
Если вам интересны остальные HTTP-методы или вы просто хотите узнать немного больше о тех, которые вы уже открыли, ознакомьтесь с Документацией Mozilla.
До сих пор вы использовали только .get() для извлечения данных, но вы можете использовать пакет requests также и для всех других HTTP-методов:

>>> requests.post("https://api.thecatapi.com/v1/breeds/abys")
<Response [405]>

>>> requests.get("https://api.thecatapi.com/v1/breeds/abys")
<Response [200]>

>>> requests.put("https://api.thecatapi.com/v1/breeds/abys")
<Response [405]>

>>> requests.delete("https://api.thecatapi.com/v1/breeds/abys")
<Response [405]>


Если вы попробуете выполнить эти действия на своей консоли, то заметите, что большинство из них возвращает код состояния 405 Method Not Allowed . Это связано с тем, что не все конечные точки допускают использование методов POST, PUT, или DELETE. Особенно, когда вы читаете данные с помощью общедоступных API, вы обнаружите, что большинство API разрешают только запросы GET, поскольку вам не разрешено создавать или изменять существующие данные.
Параметры запроса
Иногда, когда вы вызываете API, вы получаете массу данных, которые вам не нужны. Например, при вызове конечной точки API для кошек /breeds вы получаете много информации о данной породе. Но в некоторых случаях вам может потребоваться извлечь только определенную информацию о данной породе. Вот тут-то и пригодятся параметры запроса!
Возможно, вы видели или использовали параметры запроса при просмотре онлайн. Например, при просмотре видео на YouTube у вас есть URL-адрес, подобный https://www.youtube.com/watch?v=aL5GK2LVMWI. v= в URL-адресе - это то, что вы называете параметром запроса. Обычно он указывается после базового URL-адреса и конечной точки.
Чтобы добавить параметр запроса к заданному URL-адресу, вы должны добавить вопросительный знак (?) перед первым параметром запроса. Если вы хотите, чтобы в вашем запросе было несколько параметров запроса, вы можете разделить их с помощью амперсанда (&).
Тот же URL-адрес YouTube, указанный выше, с несколькими параметрами запроса будет выглядеть следующим образом: https://www.youtube.com/watch?v=aL5GK2LVMWI&t=75.
 Примечание: Если вы внимательно посмотрите на URL, который ранее использовали для вызова API графических диаграмм, то заметите, что он также содержит несколько параметров запроса.
В мире API параметры запроса - это фильтры, которые вы можете отправлять вместе с вашим запросом к API, чтобы еще больше сузить количество ответов. Например, возвращаясь к API генератора случайных пользователей, вы знаете, как генерировать случайного пользователя:

>>> requests.get("https://randomuser.me/api/").json()
{'results': [{'gender': 'male', 'name':
{'title': 'Mr', 'first': 'Silvijn', 'last': 'Van Bekkum'},
'location': {'street': {'number': 2480, 'name': 'Hooijengastrjitte'},
'city': 'Terherne', 'state': 'Drenthe',
'country': 'Netherlands', 'postcode': 59904...}


Однако, допустим, вы специально хотите генерировать только случайных пользователей женского пола. Согласно документации , вы можете использовать параметр запроса gender= для этого:

>>> requests.get("https://randomuser.me/api/?gender=female").json()
{'results': [{'gender': 'female', 'name':
{'title': 'Mrs', 'first': 'Marjoleine', 'last': 'Van Huffelen'},
'location': {'street': {'number': 8993, 'name': 'De Teebus'},
'city': 'West-Terschelling', 'state': 'Limburg',
'country': 'Netherlands', 'postcode': 24241...}


Это здорово! Теперь предположим, что вы хотите привлечь только пользователей женского пола из Германии. И снова, просматривая документацию, вы находите раздел, посвященный национальности, и для этого вы можете использовать параметр запроса nat=:

>>> requests.get("https://randomuser.me/api/?gender=female&nat=de").json()
{'results': [{'gender': 'female', 'name':
{'title': 'Ms', 'first': 'Marita', 'last': 'Hertwig'},
'location': {'street': {'number': 1430, 'name': 'Waldstraße'},
'city': 'Velden', 'state': 'Rheinland-Pfalz',
'country': 'Germany', 'postcode': 30737...}


Используя параметры запроса, вы можете начать получать более конкретные данные из API, что в большей степени адаптирует весь процесс к вашим потребностям.
Чтобы избежать необходимости перестраивать URL-адрес снова и снова, вы можете использовать атрибут params для отправки словаря всех параметров запроса для добавления к URL-адресу:

>>> query_params = {"gender": "female", "nat": "de"}
>>> requests.get("https://randomuser.me/api/", params=query_params).json()
{'results': [{'gender': 'female', 'name':
{'title': 'Ms', 'first': 'Janet', 'last': 'Weyer'},
'location': {'street': {'number': 2582, 'name': 'Meisenweg'},
'city': 'Garding', 'state': 'Mecklenburg-Vorpommern',
'country': 'Germany', 'postcode': 56953...}


Вы можете применить описанное выше к любому другому API, который вам нравится. Если вы вернетесь к Cat API, вы сможете вернуть только те породы, которые соответствуют определенному названию. Например, если вы хотите найти породу Оборванец, то вы можете сделать это с помощью параметра запроса q=:

>>> query_params = {"q": "ragamuffin"}
>>> endpoint = "https://api.thecatapi.com/v1/breeds/search"
>>> requests.get(endpoint, params=query_params).json()
[{'weight': {'imperial': '8 - 20', 'metric': '4 - 9'},
'id': 'raga', 'name': 'Ragamuffin',
'temperament': 'Affectionate, Friendly, Gentle, Calm',...}]


Вот и все! Отправив параметру запроса q= значение ragamuffin, вы сможете отфильтровать все породы, соответствующие этому конкретному значению.
Совет: Когда вы повторно один и тот же конечную точку, лучше всего определить его в качестве переменная в верхней части вашего кода. Это облегчит вам жизнь при многократном взаимодействии с API.
С помощью параметров запроса вы можете еще больше сузить свои запросы и указать именно то, что вы ищете. Большинство API, которые вы найдете в Интернете, будут иметь какие-то параметры запроса, которые вы можете использовать для фильтрации данных. Не забудьте просмотреть документацию и ссылки на API, чтобы найти их.
Изучение передовых концепций API
Теперь, когда вы хорошо разбираетесь в основах использования API с помощью Python, есть несколько более сложных тем, которые стоит затронуть, хотя бы вкратце, таких как аутентификация, разбивка на страницы и ограничение скорости.
Аутентификация
Аутентификация API - это, пожалуй, самая сложная тема, которую вы изучите в этом руководстве. Несмотря на то, что многие общедоступные API бесплатны и полностью общедоступны, еще больше API-интерфейсов доступно за той или иной формой аутентификации. Многие API-интерфейсы требуют аутентификации, но вот несколько хороших примеров:

 API GitHub
 Twitter API
Instagram API

Подходы к аутентификации варьируются от простых и понятных, таких как использование ключей API или базовой аутентификации, до гораздо более сложных и безопасных методов, таких как OAuth.
Как правило, при вызове API без учетных данных или с неправильными учетными данными возвращается код состояния 401 Unauthorized или 403 Forbidden.
Ключи API
Наиболее распространенным уровнем аутентификации является Ключ API. Эти ключи используются для идентификации вас как пользователя или заказчика API и отслеживания использования вами API. Ключи API обычно отправляются в виде заголовка запроса или в качестве параметра запроса.
 API-интерфейсы NASA: Одна из самых крутых коллекций общедоступных API-интерфейсов - это та, которую предоставляет NASA. Вы можете найти API-интерфейсы для получения астрономической картинки дня или снимков, сделанных с помощью  Камеры полихроматического изображения Земли (EPIC) и других.
В этом примере вы воспользуетесь  API фотографий марсохода НАСА  и получите снимки, сделанные 1 июля 2020 года. Для целей тестирования вы можете использовать DEMO_KEY API-ключ, который NASA предоставляет по умолчанию. В противном случае вы можете быстро создать свой собственный, перейдя на главную страницу API NASA  и нажав   Начать.
Вы можете добавить ключ API к своему запросу, добавив параметр запроса api_key=:

>>> endpoint = "https://api.nasa.gov/mars-photos/api/v1/rovers/curiosity/photos"
>>> # Replace DEMO_KEY below with your own key if you generated one.
>>> api_key = "DEMO_KEY"
>>> query_params = {"api_key": api_key, "earth_date": "2020-07-01"}
>>> response = requests.get(endpoint, params=query_params)
>>> response
<Response [200]>


Пока все хорошо. Вам удалось отправить аутентифицированный запрос в API NASA и получить ответ 200 OK.
Теперь взгляните на объект Response и попробуйте извлечь из него несколько картинок:

>>> response.json()
{'photos': [{'id': 754118,
   'sol': 2809,
   'camera': {'id': 20,
    'name': 'FHAZ',
    'rover_id': 5,
    'full_name': 'Front Hazard Avoidance Camera'},
   'img_src': 'https://mars.nasa.gov/msl-raw-images/...JPG',
   'earth_date': '2020-07-01',
   'rover': {'id': 5,
    'name': 'Curiosity',
    'landing_date': '2012-08-06',
    'launch_date': '2011-11-26',
    'status': 'active'}},
  ...
}
>>> photos = response.json()["photos"]
>>> print(f"Found {len(photos)} photos")
Found 12 photos
>>> photos[4]["img_src"]
'https://mars.nasa.gov/msl-raw-images/proj/msl/redops/ods/surface/sol/02809/opgs/edr/rcam/RRB_646869036EDR_F0810628RHAZ00337M_.JPG'


Используя .json() для преобразования ответа в словарь Python, а затем извлекая поле photos из ответа, вы можете выполнить итерацию по всем объектам Photo и даже получить определенный URL-адрес изображения фотографии. Если вы откроете этот URL-адрес в своем браузере, то увидите следующую фотографию Марса, сделанную одним из  марсоходов:

Изображение API марсохода Mars Rover
Для этого примера вы выбрали конкретную фотографию из словаря ответов. earth_date (2020-07-01) а затем конкретную фотографию из словаря ответов. (4). Прежде чем двигаться дальше, попробуйте изменить дату или загрузить снимки с другой камеры, чтобы увидеть, как это изменит конечный результат.
OAuth: Начало работы
Другим очень распространенным стандартом аутентификации API является OAuth. В этом руководстве вы узнаете только основы OAuth, поскольку это очень обширная тема.
Даже если вы не знали, что это часть OAuth, вы, возможно, видели и использовали OAuth flow несколько раз. Каждый раз, когда приложение или платформа предлагает  Войти с помощью  или Продолжить с помощью , это отправная точка потока OAuth:

Пример кнопок входа в систему OAuth: Spotify
Вот пошаговое описание того, что произойдет, если вы нажмете Продолжить с Facebook:


Приложение Spotify запросит API Facebook запустить процесс аутентификации. Для этого приложение Spotify отправит свой идентификатор приложения (client_id) и URL-адрес (redirect_uri), чтобы перенаправить пользователя после успешного выполнения или ошибки.


Вы будете перенаправлены на веб-сайт Facebook и вам будет предложено войти в систему, используя свои учетные данные. Приложение Spotify не увидит эти учетные данные и не будет иметь к ним доступа. Это самое важное преимущество OAuth.


Facebook покажет вам все данные, которые приложение Spotify запрашивает из вашего профиля, и попросит вас принять или отклонить предоставление этих данных.


Если вы согласитесь предоставить Spotify доступ к своим данным, вы будете перенаправлены обратно в приложение Spotify, где вы уже вошли в систему.


При выполнении шага 4 Facebook предоставит Spotify специальные учетные данные (access_token), которые он сможет использовать повторно для получения вашей информации. Этот конкретный токен для входа в Facebook действителен в течение шестидесяти дней, но у других приложений могут быть другие сроки действия. Если вам интересно, то на Facebook есть страница настроек , на которой   вы можете проверить, какие приложения получили ваш токен доступа к Facebook.
Теперь, с более технической точки зрения, вот что вам нужно знать при использовании API с использованием OAuth:

Вам нужно создать приложение, у которого будет идентификатор (app_id или client_id) и секрет (app_secret или client_secret).
У вас должен быть URL-адрес для перенаправления (redirect_uri), который API будет использовать для отправки вам информации.
В результате аутентификации вы получите код, который вам необходимо обменять на токен доступа.

Существует несколько вариантов описанного выше, но, вообще говоря, большинство потоков OAuth будут содержать шаги, аналогичные этим.
 Совет: Когда вы только тестируете и вам нужен какой-то URL-адрес для перенаправления, чтобы получить code, вы можете воспользоваться сервисом под названием httpbin. 
Более конкретно, вы можете использовать https://httpbin.org/anything в качестве перенаправляющего URL-адреса, поскольку он просто выводит все, что получает в качестве входных данных. Вы можете проверить это самостоятельно, перейдя по этому URL-адресу.
Далее вы познакомитесь с примером использования GitHub API!
OAuth: Практический пример
Как вы видели выше, первым шагом является создание приложения. В  документации на GitHub содержится отличное пошаговое объяснение, которому вы можете следовать, чтобы сделать это. Единственное, что следует иметь в виду, - это то, что вам необходимо использовать URL-адрес https://httpbin.org/anything, указанный выше, для поля  URL обратного вызова авторизации.
 API GitHub: Вы можете использовать API GitHub для множества различных вариантов использования, таких как получение списка репозиториев, которые вы становитесь частью сообщества, получаете список своих подписчиков и многое другое.
После создания приложения скопируйте и вставьте Client_ID и Client_Secret вместе с выбранным URL-адресом перенаправления в файл Python с именем github.py:

github.py
import requests

# REPLACE the following variables with your Client ID and Client Secret
CLIENT_ID = "<REPLACE_WITH_CLIENT_ID>"
CLIENT_SECRET = "<REPLACE_WITH_CLIENT_SECRET>"

# REPLACE the following variable with what you added in the
# "Authorization callback URL" field
REDIRECT_URI = "<REPLACE_WITH_REDIRECT_URI>"


Теперь, когда у вас есть все важные переменные, вам нужно иметь возможность создать ссылку для перенаправления пользователя на его учетную запись на GitHub, как объясняется в документации на GitHub:

github.py
# ...

def create_oauth_link():
    params = {
        "client_id": CLIENT_ID,
        "redirect_uri": REDIRECT_URI,
        "scope": "user",
        "response_type": "code",
    }

    endpoint = "https://github.com/login/oauth/authorize"
    response = requests.get(endpoint, params=params)
    return response.url


В этом фрагменте кода вы сначала определяете необходимые параметры, ожидаемые API, а затем вызываете API, используя пакет requests и .get().
Когда вы отправите запрос к конечной точке /login/oauth/authorize, API автоматически перенаправит вас на веб-сайт GitHub. В этом случае вы хотите получить параметр url из ответа. Этот параметр содержит точный URL-адрес, на который вас перенаправляет GitHub.
Следующим шагом в процессе авторизации является обмен полученного вами кода на токен доступа. Опять же, следуя шагам, описанным в документации на GitHub, вы можете создать для него функцию:

github.py
# ...

def exchange_code_for_access_token(code=None):
    params = {
        "client_id": CLIENT_ID,
        "client_secret": CLIENT_SECRET,
        "redirect_uri": REDIRECT_URI,
        "code": code,
    }

    headers = {"Accept": "application/json"}
    endpoint = "https://github.com/login/oauth/access_token"
    response = requests.post(endpoint, params=params, headers=headers).json()
    return response["access_token"]


Здесь вы отправляете POST запрос на обмен кода на токен доступа. В этом запросе вы должны отправить свои CLIENT_SECRET и code, чтобы GitHub мог подтвердить, что этот конкретный код был изначально сгенерирован вашим приложением. Только после этого API GitHub сгенерирует действительный токен доступа и вернет его вам.
Теперь вы можете добавить в свой файл следующее и попробовать запустить его:

github.py
# ...

link = create_oauth_link()
print(f"Follow the link to start the authentication with GitHub: {link}")
code = input("GitHub code: ")
access_token = exchange_code_for_access_token(code)
print(f"Exchanged code {code} with access token: {access_token}")


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

github.py
# ...

def print_user_info(access_token=None):
    headers = {"Authorization": f"token {access_token}"}
    endpoint = "https://api.github.com/user"
    response = requests.get(endpoint, headers=headers).json()
    name = response["name"]
    username = response["login"]
    private_repos_count = response["total_private_repos"]
    print(
        f"{name} ({username}) | private repositories: {private_repos_count}"
    )

# ...


Теперь, когда у вас есть действительный токен доступа, вам нужно отправлять его на все ваши запросы к API, используя заголовок Authorization. Ответом на ваш запрос будет словарь Python, содержащий всю информацию о пользователе. Из этого словаря вы хотите получить поля name, login, и total_private_repos. Вы также можете напечатать переменную response, чтобы увидеть, какие еще поля доступны.
Хорошо, так и должно быть! Осталось только собрать все это воедино и попробовать:

github.py
import requests

# REPLACE the following variables with your Client ID and Client Secret
CLIENT_ID = "<REPLACE_WITH_CLIENT_ID>"
CLIENT_SECRET = "<REPLACE_WITH_CLIENT_SECRET>"

# REPLACE the following variable with what you added in
# the "Authorization callback URL" field
REDIRECT_URI = "<REPLACE_WITH_REDIRECT_URI>"

def create_oauth_link():
    params = {
        "client_id": CLIENT_ID,
        "redirect_uri": REDIRECT_URI,
        "scope": "user",
        "response_type": "code",
    }
    endpoint = "https://github.com/login/oauth/authorize"
    response = requests.get(endpoint, params=params)
    return response.url

def exchange_code_for_access_token(code=None):
    params = {
        "client_id": CLIENT_ID,
        "client_secret": CLIENT_SECRET,
        "redirect_uri": REDIRECT_URI,
        "code": code,
    }
    headers = {"Accept": "application/json"}
    endpoint = "https://github.com/login/oauth/access_token"
    response = requests.post(endpoint, params=params, headers=headers).json()
    return response["access_token"]

def print_user_info(access_token=None):
    headers = {"Authorization": f"token {access_token}"}
    endpoint = "https://api.github.com/user"
    response = requests.get(endpoint, headers=headers).json()
    name = response["name"]
    username = response["login"]
    private_repos_count = response["total_private_repos"]
    print(
        f"{name} ({username}) | private repositories: {private_repos_count}"
    )

link = create_oauth_link()
print(f"Follow the link to start the authentication with GitHub: {link}")
code = input("GitHub code: ")
access_token = exchange_code_for_access_token(code)
print(f"Exchanged code {code} with access token: {access_token}")
print_user_info(access_token=access_token)


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

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

John Doe (johndoe) | number of private repositories: 42


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

 Что, черт возьми, такое OAuth?
 Упрощенный OAuth 2
 Платформа авторизации OAuth 2.0

С точки зрения использования API, знание OAuth, безусловно, очень пригодится при взаимодействии с общедоступными API. Большинство API используют OAuth в качестве стандарта аутентификации, и на то есть веские причины.
Разбивка на страницы
За отправку большого количества данных между клиентами и серверами и обратно приходится платить: за пропускную способность. Чтобы серверы могли справляться с большим количеством запросов, API-интерфейсы обычно используют разбиение на страницы .
Говоря очень простым языком, разбивка на страницы - это процесс разделения больших объемов данных на множество более мелких фрагментов. Например, всякий раз, когда вы переходите на страницу вопросов  в Stack Overflow, вы видите внизу что-то вроде этого:

Пример разбивки на страницы в Stack Overflow
Вы, вероятно, знаете это по многим другим веб-сайтам, и концепция в основном одинакова на разных сайтах. В частности, для API это обычно обрабатывается с помощью параметров запроса, в основном следующих двух:

Атрибут page, который определяет, какую страницу вы запрашиваете в данный момент
Атрибут size, который определяет размер каждой страницы

Названия конкретных параметров запроса могут сильно отличаться в зависимости от разработчиков API, но концепция одна и та же. Некоторые пользователи API могут также использовать HTTP-заголовки или ответ в формате JSON для возврата текущих фильтров разбивки на страницы.
Снова используя API GitHub, вы можете найти конечную точку события в документации, которая содержит параметры запроса разбивки на страницы. Параметр per_page= определяет количество возвращаемых элементов, а page= позволяет разбивать несколько результатов на страницы. Вот как использовать эти параметры:

>>> response = requests.get("https://api.github.com/events?per_page=1&page=0")
>>> response.json()[0]["id"]
'14345572615'

>>> response = requests.get("https://api.github.com/events?per_page=1&page=1")
>>> response.json()[0]["id"]
'14345572808'

>>> response = requests.get("https://api.github.com/events?per_page=1&page=2")
>>> response.json()[0]["id"]
'14345572100'


С помощью первого URL-адреса вы можете получить только одно событие. Но, используя параметр запроса page=, вы можете продолжать разбивать результаты на страницы, чтобы быть уверенным, что сможете извлекать все события, не перегружая API.
Ограничение скорости
Учитывая, что API общедоступны и ими может пользоваться любой желающий, люди с дурными намерениями часто пытаются злоупотреблять ими. Чтобы предотвратить такие атаки, API-интерфейсы используют метод, называемый ограничение скорости, который ограничивает количество запросов, которые пользователи могут выполнить за определенный промежуток времени.
Некоторые API могут заблокировать ваш IP-адрес или ключи API, если вы слишком часто превышаете установленный лимит скорости. Будьте осторожны и не превышайте лимиты, установленные разработчиками API. В противном случае вам, возможно, придется подождать некоторое время, прежде чем снова вызывать этот API.
В приведенном ниже примере вы снова будете использовать API GitHub и конечную точку /events. Согласно документации , GitHub допускает около шестидесяти неаутентифицированных запросов в час. Если вы сделаете это выше, то получите код состояния 403 и не сможете больше выполнять вызовы API в течение некоторого времени.
 Предупреждение: Запуск следующего фрагмента кода на некоторое время действительно заблокирует доступ к GitHub, поэтому перед запуском убедитесь, что вам некоторое время не нужен доступ к API GitHub.
В целях демонстрации вы намеренно попытаетесь превысить лимит скорости на GitHub, чтобы посмотреть, что произойдет. В приведенном ниже коде вы будете запрашивать данные до тех пор, пока не получите код состояния, отличный от 200 OK:

>>> endpoint = "https://api.github.com/events"
>>> for i in range(1, 100):
>>>     response = requests.get(endpoint)
>>>     print(f"{i} - {response.status_code}")
>>>     if response.status_code != 200:
>>>         break
1 - 200
2 - 200
3 - 200
4 - 200
5 - 200
...
56 - 200
57 - 200
58 - 403
>>> response
<Response [403]>
>>> response.json()
{'message': "API rate limit exceeded for <ip-address>.",
 'documentation_url': 'https://developer.github.com/v3/#rate-limiting'}


Вот и все: примерно после шестидесяти запросов API перестал возвращать 200 OK ответов и вместо этого вернул 403 Forbidden ответа, информируя вас о том, что вы превысили лимит скорости API.
Некоторые API, такие как GitHub, могут даже включать в заголовки дополнительную информацию о вашем текущем лимите скорости и количестве оставшихся запросов. Это очень полезно для того, чтобы избежать превышения установленного лимита. Взгляните на последнюю версию response.headers, чтобы узнать, сможете ли вы найти эти конкретные заголовки, ограничивающие скорость.
Использование API с помощью Python: Практические примеры
Теперь, когда вы ознакомились со всей теорией и поэкспериментировали с несколькими API, вы можете закрепить полученные знания с помощью нескольких практических примеров. Вы можете изменить приведенные ниже примеры, чтобы приспособить их к вашим собственным целям.
Вы можете ознакомиться с примерами, загрузив исходный код, доступный по ссылке ниже:
 Получите исходный код:  Нажмите здесь, чтобы получить исходный код, который вы будете использовать чтобы узнать о работе с API в Python в этом руководстве.
Поиск и выборка популярных GIF-файлов
Как насчет того, чтобы создать небольшой скрипт, который будет извлекать три самых популярных GIF-файла с веб-сайта GIPHY? Для этого вам нужно создать приложение и получить API-ключ от GIPHY. Вы можете ознакомиться с инструкциями, развернув поле ниже, а также ознакомиться с документацией по быстрому запуску GIPHY .


Шаг 1: Создайте учетную запись GIPHY
Вам следует начать с создания учетной записи GIPHY:

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

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

Настройка GIPHY: Создание нового приложения
Обязательно выберите версию API, а не SDK. После этого вам нужно будет ввести еще несколько сведений о вашем приложении:

Настройка GIPHY: Выберите имя
Вы можете увидеть пример названия и описания приложения выше, но не стесняйтесь заполнять их по своему усмотрению.
Шаг 3: Получение ключа API
Как только вы выполните описанные выше действия, вы должны открыть новое приложение на своей панели мониторинга, под разделом "Ваши приложения". Там у вас будет ключ API, который выглядит следующим образом:

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

giphy_trending.py
 1import requests
 2
 3# Replace the following with the API key generated.
 4API_KEY = "API_KEY"
 5endpoint = "https://api.giphy.com/v1/gifs/trending"
 6
 7params = {"api_key": API_KEY, "limit": 3, "rating": "g"}
 8response = requests.get(endpoint, params=params).json()
 9for gif in response["data"]:
10    title = gif["title"]
11    trending_date = gif["trending_datetime"]
12    url = gif["url"]
13    print(f"{title} | {trending_date}\n{url}\n")


В верхней части файла, в строках 4 и 5, вы определяете свой API_KEY и GIPHY API endpoint, поскольку они не будут меняться так часто, как остальные.
В строке 7, используя то, что вы узнали из раздела параметры запроса, вы определяете params и добавляете свой собственный ключ API. Вы также включаете несколько других фильтров: limit для получения 3 результатов и rating для получения только  соответствующего контента.
Наконец, после получения ответа вы  повторяете результаты в строке 9. Для каждого GIF-файла вы печатаете его название, дату и URL-адрес в строке 13.
Запуск этого фрагмента кода в консоли приведет к появлению несколько структурированного списка GIF-файлов:

$ python giphy_trending.py
Excited Schitts Creek GIF by CBC | 2024-11-28 20:45:14
https://giphy.com/gifs/cbc-schittscreek-schitts-creek-SiGg4zSmwmbafTYwpj

Saved By The Bell Shrug GIF by PeacockTV | 2024-11-28 20:30:15
https://giphy.com/gifs/peacocktv-saved-by-the-bell-bayside-high-school-dZRjehRpivtJsNUxW9

Schitts Creek Thank You GIF by CBC | 2024-11-28 20:15:07
https://giphy.com/gifs/cbc-funny-comedy-26n79l9afmfm1POjC


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

giphy_search.py
import requests

# Replace the following with the API key generated.
API_KEY = "API_KEY"
endpoint = "https://api.giphy.com/v1/gifs/search"

search_term = "shrug"
params = {"api_key": API_KEY, "limit": 1, "q": search_term, "rating": "g"}
response = requests.get(endpoint, params=params).json()
for gif in response["data"]:
    title = gif["title"]
    url = gif["url"]
    print(f"{title} | {url}")


Вот и все! Теперь вы можете модифицировать этот скрипт по своему вкусу и создавать GIF-файлы по запросу. Попробуйте выбрать GIF—файлы из вашего любимого шоу или фильма, добавить ярлык на свой  терминал , чтобы получать самые популярные GIF-файлы по запросу, или интегрироваться с другим API из вашей любимой системы обмена сообщениями - WhatsApp, Slack, как хотите. Тогда начинайте отправлять GIF-файлы своим друзьям и коллегам!
Поиск в Google Книгах
Если вы увлекаетесь книгами, то, возможно, вам понадобится быстрый способ поиска нужной книги. Возможно, вы даже захотите подключить его к поисковой системе вашей местной библиотеки, чтобы узнать, доступна ли данная книга по ISBN .
В этом примере вы будете использовать API Google Books и общедоступную конечную точку volumes для поиска книг.
Вот простой фрагмент кода для поиска слов "moby dick" во всем каталоге:

google_books.py
 1import requests
 2
 3endpoint = "https://www.googleapis.com/books/v1/volumes"
 4query = "moby dick"
 5
 6params = {"q": query, "maxResults": 3}
 7response = requests.get(endpoint, params=params).json()
 8for book in response["items"]:
 9    volume = book["volumeInfo"]
10    title = volume.get("title", "")
11    published = volume.get("publishedDate", "")
12    description = volume.get("description", "")
13    print(f"{title} ({published})\n{description}\n")


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

$ python google_books.py
Moby-Dick (2016-04-12)
"Call me Ishmael." So begins the famous opening...

Moby Dick (1892)
A literary classic that wasn't recognized for its...

Moby Dick; Or, The Whale (1983-08-16)
The story of Captain Ahab's...


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

industryIdentifiers
averageRating и ratingsCount
imageLinks

 Интересная задача, которую можно решить с помощью этого API, - использовать свои знания OAuth и создать свое собственное приложение bookshelf, которое будет вести учет всех книг, которые вы прочитали или хотите прочитать. Вы даже можете подключить его к своему любимому книжному магазину или библиотеке, чтобы быстро найти книги из списка ваших пожеланий, которые доступны рядом с вами. Это только одна идея. Можете ли вы предложить что-нибудь еще?
Заключение
Вы можете так много узнать об API: разные заголовки, разные типы контента, разные методы аутентификации и так далее. Однако концепции и методы, которые вы изучили в этом руководстве, позволят вам практиковаться с любым API, который вам нравится, и использовать Python для любых ваших потребностей в использовании API.
 В этом уроке вы узнали:

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

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

 Публичный репозиторий API на GitHub
 Общедоступные API
Любые API

Вы можете ознакомиться с ними и найти API, который соответствует вам и вашим увлечениям и, возможно, вдохновит вас на создание небольшого проекта с его использованием. Если вы наткнетесь на хороший общедоступный API, о котором, по вашему мнению, должны знать другие люди, читающие это руководство, пожалуйста, оставьте комментарий ниже!
Часто задаваемые вопросы
Теперь, когда у вас есть некоторый опыт использования API в Python, вы можете воспользоваться приведенными ниже вопросами и ответами, чтобы проверить свое понимание и резюмировать то, что вы узнали.
Эти часто задаваемые вопросы относятся к наиболее важным понятиям, которые вы рассмотрели в этом руководстве. Нажмите на переключатель Показывать/скрывать рядом с каждым вопросом, чтобы открыть ответ.


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


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


API-интерфейсы REST (Representational State Transfer) используют стандартные методы HTTP и фокусируются на ресурсах и действиях, в то время как GraphQL позволяет клиентам точно указывать, какие данные им нужны, обеспечивая большую гибкость в запросах.


Вы управляете аутентификацией API в Python, используя такие методы, как ключи API, OAuth или базовая аутентификация, часто отправляя учетные данные в заголовках или в качестве параметров запроса.
<статус завершения article-slug="python-api" class="btn-group mb-0" data-api-article-bookmark-url="/api/v1/статьи/python-api/bookmark/" статус завершения data-api-article-url="/api/v1/articles/python-api/завершение_статуса/">



<кнопка поделиться bluesky-text="Интересная статья на #Python от @realpython.com :" email-body="Ознакомьтесь с этой статьей на Python:%0A%0APython и API: Выигрышная комбинация для чтения общедоступных данных" email-subject="Статья на Python для вас" twitter-текст="Интересная статья на #Python от @realpython:" url="https://realpython.com/python-api/" url-title="Python и API: выигрышная комбинация для чтения общедоступных данных">


                







                 Back to Top