Параметры requests get: документация на русском, get и post

Содержание

документация на русском, get и post

Прежде чем начать, убедитесь, что установлена последняя версия Requests.

Для начала, давайте рассмотрим простые примеры.

Создание GET и POST запроса

Импортируйте модуль Requests:

Копировать Скопировано Use a different Browser

import requests 

Попробуем получить веб-страницу с помощью get-запроса. В этом примере давайте рассмотрим общий тайм-лайн GitHub:

Копировать Скопировано Use a different Browser

r = requests.get('https://api.github.com/events')

Мы получили объект Response с именем r. С помощью этого объекта можно получить всю необходимую информацию.

Простой API Requests означает, что все типы HTTP запросов очевидны. Ниже приведен пример того, как вы можете сделать POST запрос:

Копировать Скопировано Use a different Browser

r = requests.post('https://httpbin. org/post', data = {'key':'value'})  

Другие типы HTTP запросов, такие как : PUT, DELETE, HEAD и OPTIONS так же очень легко выполнить:

Копировать Скопировано Use a different Browser

r = requests.put('https://httpbin.org/put', data = {'key':'value'})  
r = requests.delete('https://httpbin.org/delete')  
r = requests.head('https://httpbin.org/get')  
r = requests.options('https://httpbin.org/get')  

Передача параметров в URL

Часто вам может понадобится отправить какие-то данные в строке запроса URL. Если вы настраиваете URL вручную, эти данные будут представлены в нем в виде пар ключ/значение после знака вопроса. Например, httpbin.org/get?key=val. Requests позволяет передать эти аргументы в качестве словаря, используя аргумент params. Если вы хотите передать key1=value1 и key2=value2 ресурсу httpbin.org/get, вы должны использовать следующий код:

Копировать Скопировано Use a different Browser

payload = {'key1': 'value1', 'key2': 'value2'}  
r = requests. get('https://httpbin.org/get', params=payload)
print(r.url) 

Как видно, URL был сформирован правильно:

https://httpbin.org/get?key2=value2&key1=value1

Ключ словаря, значение которого None, не будет добавлен в строке запроса URL.

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

Копировать Скопировано Use a different Browser

>>> payload = {'key1': 'value1', 'key2': ['value2', 'value3']}  
>>> r = requests.get('https://httpbin.org/get', params=payload)  
>>> print(r.url)  
https://httpbin.org/get?key1=value1&key2=value2&key2=value3 

Содержимое ответа (response)

Мы можем прочитать содержимое ответа сервера. Рассмотрим снова тайм-лайн GitHub:

Копировать Скопировано Use a different Browser

>>> import requests
>>> r = requests.get('https://api.github.com/events')
>>> r.text
'[{"repository":{"open_issues":0,"url":"https://github. com/...

Requests будет автоматически декодировать содержимое ответа сервера. Большинство кодировок unicode декодируются без проблем.
Когда вы делаете запрос, Requests делает предположение о кодировке, основанное на заголовках HTTP. Эта же кодировка текста, используется при обращение к r.text. Можно узнать, какую кодировку использует Requests, и изменить её с помощью r.encoding:

Копировать Скопировано Use a different Browser

>>> r.encoding
'utf-8'
>>> r.encoding = 'ISO-8859-1'

Если вы измените кодировку, Requests будет использовать новое значение r.encoding всякий раз, когда вы будете использовать r.text. Вы можете сделать это в любой ситуации, где нужна более специализированная логика работы с кодировкой содержимого ответа.

Например, в HTML и XML есть возможность задавать кодировку прямо в теле документа. В подобных ситуациях вы должны использовать r.content, чтобы найти кодировку, а затем установить r.encoding. Это позволит вам использовать r.text с правильной кодировкой.

Requests может также использовать пользовательские кодировки в случае, если в них есть потребность. Если вы создали свою собственную кодировку и зарегистрировали ее в модуле codecs, используйте имя кодека в качестве значения r.encoding.

Бинарное содержимое ответа

Вы можете также получить доступ к телу ответа в виде байтов для не текстовых ответов:

Копировать Скопировано Use a different Browser

>>> r.content
b'[{"repository":{"open_issues":0,"url":"https://github.com/...

Передача со сжатием gzip и deflate автоматически декодируются для вас.

Например, чтобы создать изображение на основе бинарных данных, возвращаемых при ответе на запрос, используйте следующий код:

Копировать Скопировано Use a different Browser

from PIL import Image  
from io import BytesIO  
i = Image. open(BytesIO(r.content))

Содержимое ответа в JSON

Если вы работаете с данными в формате JSON, воспользуйтесь встроенным JSON декодером:

Копировать Скопировано Use a different Browser

>>> import requests
>>> r = requests.get('https://api.github.com/events')
>>> r.json()
[{'repository': {'open_issues': 0, 'url': 'https://github.com/...

Если декодирование в JSON не удалось, r.json() вернет исключение. Например, если ответ с кодом 204 (No Content), или на случай если ответ содержит не валидный JSON, попытка обращения к r.json() будет возвращать ValueError: No JSON object could be decoded.

Следует отметить, что успешный вызов r.json() не указывает на успешный ответ сервера. Некоторые серверы могут возвращать объект JSON при неудачном ответе (например, сведения об ошибке HTTP 500). Такой JSON будет декодирован и возвращен. Для того, чтобы проверить успешен ли запрос, используйте r. raise_for_status() или проверьте какой r.status_code.

Необработанное содержимое ответа

В тех редких случаях, когда вы хотите получить доступ к “сырому” ответу сервера на уровне сокета, обратитесь к r.raw. Если вы хотите сделать это, убедитесь, что вы указали stream=True в вашем первом запросе. После этого вы уже можете проделать следующее:

Копировать Скопировано Use a different Browser

>>> r = requests.get('https://api.github.com/events', stream=True)
>>> r.raw

>>> r.raw.read(10)
'\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03'

Однако, можно использовать подобный код как шаблон, чтобы сохранить результат в файл:

Копировать Скопировано Use a different Browser

with open(filename, 'wb') as fd:
    for chunk in r.iter_content(chunk_size=128):
        fd.write(chunk)

Использование r.iter_content обработает многое из того, с чем бы вам пришлось иметь дело при использовании r. raw напрямую. Для извлечения содержимого при потоковой загрузке, используйте способ, описанный выше. Обратите внимание, что chunk_size можно свободно скорректировать до числа, которое лучше подходит в вашем случае.

Важное замечание об использовании Response.iter_content и Response.raw. Response.iter_content будет автоматически декодировать gzip и deflate. Response.raw — необработанный поток байтов, он не меняет содержимое ответа. Если вам действительно нужен доступ к байтам по мере их возврата, используйте Response.raw.

Пользовательские заголовки

Если вы хотите добавить HTTP заголовки в запрос, просто передайте соответствующий dict в параметре headers.
Например, мы не указали наш user-agent в предыдущем примере:

Копировать Скопировано Use a different Browser

url = 'https://api. github.com/some/endpoint'  
headers = {'user-agent': 'my-app/0.0.1'}  
r = requests.get(url, headers=headers)

Заголовкам дается меньший приоритет, чем более конкретным источникам информации. Например:

  • Заголовки авторизации, установленные с помощью headers= будут переопределены, если учетные данные указаны .netrc, которые, в свою очередь переопределены параметром auth=.
  • Они же будут удалены при редиректе.
  • Заголовки авторизации с прокси будут переопределены учетными данными прокси-сервера, которые указаны в вашем URL.
  • Content-Length будут переопределены, когда вы определите длину содержимого.

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

Значения заголовка должны быть string, bytestring или unicode. Хотя это разрешено, рекомендуется избегать передачи значений заголовков unicode.

Более сложные POST запросы

Часто вы хотите послать некоторые form-encoded данные таким же образом, как это делается в HTML форме. Для этого просто передайте соответствующий словарь в аргументе data. Ваш словарь данных в таком случае будет автоматически закодирован как HTML форма, когда будет сделан запрос:

Копировать Скопировано Use a different Browser

>>> payload = {'key1': 'value1', 'key2': 'value2'}
>>> r = requests.post("https://httpbin.org/post", data=payload)
>>> print(r.text)
{
  ...
  "form": {
    "key2": "value2",
    "key1": "value1"
  },
  ...
}

Аргумент data также может иметь несколько значений для каждого ключа. Это можно сделать, указав data в формате tuple, либо в виде словаря со списками в качестве значений. Особенно полезно, когда форма имеет несколько элементов, которые используют один и тот же ключ:

Копировать Скопировано Use a different Browser

>>> payload_tuples = [('key1', 'value1'), ('key1', 'value2')]
>>> r1 = requests. post('https://httpbin.org/post', data=payload_tuples)
>>> payload_dict = {'key1': ['value1', 'value2']}
>>> r2 = requests.post('https://httpbin.org/post', data=payload_dict)
>>> print(r1.text)
{
  ...
  "form": {
    "key1": [
      "value1",
      "value2"
    ]
  },
  ...
}
>>> r1.text == r2.text
True

Бывают случаи, когда нужно отправить данные не закодированные методом form-encoded. Если вы передадите в запрос строку вместо словаря, эти данные отправятся в не измененном виде.

К примеру, GitHub API v3 принимает закодированные JSON POST/PATCH данные:

Копировать Скопировано Use a different Browser

import json
url = 'https://api.github.com/some/endpoint'  
payload = {'some': 'data'}  
r = requests.post(url, data=json.dumps(payload))  

Вместо того, чтобы кодировать dict, вы можете передать его напрямую, используя параметр json (добавленный в версии 2. 4.2), и он будет автоматически закодирован:

Копировать Скопировано Use a different Browser

url = 'https://api.github.com/some/endpoint'  
payload = {'some': 'data'}  
r = requests.post(url, json=payload) 

Обратите внимание, параметр json игнорируется, если передаются data или files.
Использование параметра json в запросе изменит заголовок Content-Type на application/json.

POST отправка Multipart-Encoded файла

Запросы упрощают загрузку файлов с многостраничным кодированием (Multipart-Encoded) :

Копировать Скопировано Use a different Browser

>>> url = 'https://httpbin.org/post'
>>> files = {'file': open('report.xls', 'rb')}
>>> r = requests.post(url, files=files)
>>> r.text
{
  ...
  "files": {
    "file": ""
  },
  ...
}

Вы можете установить имя файла, content_type и заголовки в явном виде:

Копировать Скопировано Use a different Browser

>>> url = 'https://httpbin. org/post'
>>> files = {'file': ('report.xls', open('report.xls', 'rb'), 'application/vnd.ms-excel', {'Expires': '0'})}
>>> r = requests.post(url, files=files)
>>> r.text
{
  ...
  "files": {
    "file": ""
  },
  ...
}

Можете отправить строки, которые будут приняты в виде файлов:

Копировать Скопировано Use a different Browser

>>> url = 'https://httpbin.org/post'
>>> files = {'file': ('report.csv', 'some,data,to,send\nanother,row,to,send\n')}
>>> r = requests.post(url, files=files)
>>> r.text
{
  ...
  "files": {
    "file": "some,data,to,send\\nanother,row,to,send\\n"
  },
  ...
}

В случае, если вы отправляете очень большой файл как запрос multipart/form-data, возможно понадобиться отправить запрос потоком. По умолчанию, requests не поддерживает этого, но есть отдельный пакет, который это делает — requests-toolbelt. Ознакомьтесь с документацией toolbelt для получения более детальной информации о том, как им пользоваться.

Для отправки нескольких файлов в одном запросе, обратитесь к расширенной документации.

Предупреждение!
Настоятельно рекомендуется открывать файлы в бинарном режиме. Это связано с тем, что запросы могут пытаться предоставить для вас заголовок Content-Length, и если это значение будет установлено на количество байтов в файле будут возникать ошибки, при открытии файла в текстовом режиме.

Коды состояния ответа

Мы можем проверить код состояния ответа:

Копировать Скопировано Use a different Browser

>>> r = requests.get('https://httpbin.org/get')
>>> r.status_code
200

У requests есть встроенный объект вывода кодов состояния:

Копировать Скопировано Use a different Browser

>>> r.status_code == requests.codes.ok
True

Если мы сделали неудачный запрос (ошибка 4XX или 5XX), то можем вызвать исключение с помощью r. raise_for_status():

Копировать Скопировано Use a different Browser

>>> bad_r = requests.get('https://httpbin.org/status/404')
>>> bad_r.status_code
404
>>> bad_r.raise_for_status()
Traceback (most recent call last):
  File "requests/models.py", line 832, in raise_for_status
    raise http_error
requests.exceptions.HTTPError: 404 Client Error

Но если status_code для r оказался 200, то когда мы вызываем raise_for_status() мы получаем:

Копировать Скопировано Use a different Browser

>>> r.raise_for_status()
None

Заголовки ответов

Мы можем просматривать заголовки ответа сервера, используя словарь Python:

Копировать Скопировано Use a different Browser

>>> r.headers
{
    'content-encoding': 'gzip',
    'transfer-encoding': 'chunked',
    'connection': 'close',
    'server': 'nginx/1. 0.4',
    'x-runtime': '148ms',
    'etag': '"e1ca502697e5c9317743dc078f67693f"',
    'content-type': 'application/json'
}

Это словарь особого рода, он создан специально для HTTP заголовков. Согласно с RFC 7230, имена заголовков HTTP нечувствительны к регистру.

Теперь мы можем получить доступ к заголовкам с большим буквами или без, если захотим:

Копировать Скопировано Use a different Browser

>>> r.headers['Content-Type']
'application/json'
>>> r.headers.get('content-type')
'application/json'

Cookies

Если в запросе есть cookies, вы сможете быстро получить к ним доступ:

Копировать Скопировано Use a different Browser

>>> url = 'https://example.com/some/cookie/setting/url'
>>> r = requests.get(url)
>>> r.cookies['example_cookie_name']
'example_cookie_value'

Чтобы отправить собственные cookies на сервер, используйте параметр cookies:

Копировать Скопировано Use a different Browser

>>> url = 'https://httpbin. org/cookies'
>>> cookies = dict(cookies_are='working')
>>> r = requests.get(url, cookies=cookies)
>>> r.text
'{"cookies": {"cookies_are": "working"}}'

Cookies возвращаются в RequestsCookieJar, который работает как dict, но также предлагает более полный интерфейс, подходящий для использования в нескольких доменах или путях. Словарь с cookie может также передаваться в запросы:

Копировать Скопировано Use a different Browser

>>> jar = requests.cookies.RequestsCookieJar()
>>> jar.set('tasty_cookie', 'yum', domain='httpbin.org', path='/cookies')
>>> jar.set('gross_cookie', 'blech', domain='httpbin.org', path='/elsewhere')
>>> url = 'https://httpbin.org/cookies'
>>> r = requests.get(url, cookies=jar)
>>> r.text
'{"cookies": {"tasty_cookie": "yum"}}'

Редиректы и история

По умолчанию Requests будет выполнять редиректы для всех HTTP глаголов, кроме HEAD.

Мы можем использовать свойство history объекта Response, чтобы отслеживать редиректы .

Список Response.history содержит объекты Response, которые были созданы для того, чтобы выполнить запрос. Список сортируется от более ранних, до более поздних ответов.

Например, GitHub перенаправляет все запросы HTTP на HTTPS:

Копировать Скопировано Use a different Browser

>>> r = requests.get('https://github.com/')
>>> r.url
'https://github.com/'
>>> r.status_code
200
>>> r.history
[]

Если вы используете запросы GET, OPTIONS, POST, PUT, PATCH или DELETE, вы можете отключить обработку редиректа с помощью параметра allow_redirects:

Копировать Скопировано Use a different Browser

>>> r = requests.get('https://github.com/', allow_redirects=False)
>>> r.status_code
301
>>> r.history
[]

Если вы используете HEAD, вы также можете включить редирект:

Копировать Скопировано Use a different Browser

>>> r = requests. head('https://github.com/', allow_redirects=True)
>>> r.url
'https://github.com/'
>>> r.history
[]

Тайм-ауты

Вы можете сделать так, чтобы Requests прекратил ожидание ответа после определенного количества секунд с помощью параметра timeout.

Почти весь код должен использовать этот параметр в запросах. Несоблюдение этого требования может привести к зависанию вашей программы:

Копировать Скопировано Use a different Browser

>>> requests.get('https://github.com/', timeout=0.001)
Traceback (most recent call last):
  File "", line 1, in 
requests.exceptions.Timeout: HTTPConnectionPool(host='github.com', port=80): Request timed out. (timeout=0.001)

Timeout это не ограничение по времени полной загрузки ответа. Исключение возникает, если сервер не дал ответ за timeout секунд (точнее, если ни одного байта не было получено от основного сокета за timeout секунд).

Ошибки и исключения

В случае неполадок в сети (например, отказа DNS, отказа соединения и т. д.), Requests вызовет исключение ConnectionError.

Response.raise_for_status() вызовет HTTPError если в запросе HTTP возникнет статус код ошибки.

Если выйдет время запроса, вызывается исключение Timeout. Если запрос превышает заданное значение максимального количества редиректов, то вызывают исключение TooManyRedirects.

Все исключения, которые вызывает непосредственно Requests унаследованы от requests.exceptions.RequestException.

Тест на знание основ Requests

Какой из HTTP-запросов является правильным?

requests.post(url, data={‘key’:’value’})

Все запросы верны

requests.get(url, params={‘key’:’value’})

requests.post(url, params={‘key’:’value’})

Какое из утверждений верно?

response.json() возвращает содержимое ответа в виде объекта dict

response.text возвращает содержимое ответа в виде байтового объекта

response.content возвращает содержимое ответа в виде строкового объекта

response. json возвращает содержимое ответа в виде объекта dict

Все не верно

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

response.cookie

response(«cookies»)

response.get_cookies

response.cookies

Что вернет метод status_code объекта Response?

Ошибку, если запрос неудачный

OK или ERROR

Код ответа

True или None

Какой код сформирует url «https://test.com/page?key1=value1&key2=value21,value22»

r.get(‘https://test.com/page’, params={‘key1’: ‘value1’, ‘key2’: [‘value21’, ‘value22’]})

r.get(‘https://test.com/page’, params={‘key1’: ‘value1’, ‘key2’: ‘value21,value22’})

r.get(‘https://test.com/page’, params={‘key1’: ‘value1’, ‘key2’: ‘value21’, ‘key2’: ‘value22’})

Это невозможно

{{title}}

{{image}}

{{content}}

{{/global}}

Поделиться результатами через

Facebook Twitter VK

GET и POST запросы c модулем requests в Python.

Передача параметров в URL для HTTP GET-запросов.

Часто в строке запроса URL-адреса, необходимо отправить какие-то данные. При составлении URL-адреса вручную, эти данные задаются в виде пар ключ/значение в конце URL-адреса после вопросительного знака, например httpbin.org/get?key=val. Модуль requests позволяет передавать эти параметры в метод requests.get() виде словаря строк, используя ключевой аргумент params. Например, если надо передать key1=value1 и key2=value2 для GET запроса к URL-адресу httpbin.org/get, то используйте следующий код:

>>> import requests
# подготовка дополнительных параметров для GET запроса
>>> params = {'key1': 'value1', 'key2': 'value2'}
>>> resp = requests.get('https://httpbin.org/get', params=params)
# смотрим, что URL-адрес был правильно закодирован
>>> print(resp.url)
# https://httpbin. org/get?key2=value2&key1=value1

Обратите внимание

, что любой ключ словаря, значение которого равно None, не будет добавлен в строку запроса URL-адреса.

В качестве значения словаря можно передать список дополнительных элементов URL-адреса:

>>> import requests
# ключ словаря 'key2' имеет список значений
>>> params = {'key1': 'value1', 'key2': ['value2', 'value3']}
# создаем GET запрос 
>>> resp = requests.get('https://httpbin.org/get', params=params)
# смотрим полученный URL
>>> print(resp.url)
# https://httpbin.org/get?key1=value1&key2=value2&key2=value3

Передача параметров в URL для HTTP POST-запросов.

Как правило, в POST-запросах встает необходимость отправить некоторые закодированные в форме данные. Для этого необходимо передать словарь в аргумент data метода requests.post(). Словарь с данными формы будет автоматически закодирован.

Обратите внимание

, что имя аргумента для передачи параметров метода requests.post(), отличается от имени аргумента дополнительных параметров метода requests.get().

>>> import requests
# подготовка параметров для POST-запроса
>>> param = {'key1': 'value1', 'key2': 'value2'}
# обратите внимание, что для метода POST, аргумент для 
# передачи параметров в запрос отличается от метода GET  
>>> resp = requests.post("https://httpbin.org/post", data=param)
>>> print(resp.text)
# {
#   ...
#   "form": {
#     "key2": "value2",
#     "key1": "value1"
#   },
#   ...
# }

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

>>> import requests
>>> param_tuples = [('key1', 'value1'), ('key1', 'value2')]
>>> resp1 = requests. post('https://httpbin.org/post', data=payload_tuples)
>>> param_dict = {'key1': ['value1', 'value2']}
>>> resp2 = requests.post('https://httpbin.org/post', data=payload_dict)
>>> print(resp1.text)
# {
#   ...
#   "form": {
#     "key1": [
#       "value1",
#       "value2"
#     ]
#   },
#   ...
# }
>>> resp1.text == resp2.text
# True

запросов Python получают метод

❮ Модуль запросов


Пример

Сделать запрос на веб-страницу и вернуть код состояния:

import request

x = request.get(‘https://w3schools.com’)
print(x.status_code)

Пример запуска »


Определение и использование

Метод get() отправляет GET-запрос на указанный URL.


Синтаксис

request.get( url , params={ key : value }, args )

args означает ноль или более из названных аргументов в таблице параметров ниже. Пример:

request.get(url, timeout=2.50)


Значения параметров

Параметр Описание
URL-адрес Попробуйте Обязательно. URL запроса
параметры Попробуйте Дополнительно. Словарь, список кортежей или байтов для отправки в виде строки запроса.
По умолчанию Нет
разрешить_перенаправления Попробуйте Дополнительно. Логическое значение для включения/отключения перенаправления.
По умолчанию
True (разрешение перенаправления)
авторизация Попробуйте Дополнительно. Кортеж для включения определенной HTTP-аутентификации.
По умолчанию
Нет
сертификат Попробуйте Дополнительно. Строка или кортеж, указывающий файл сертификата или ключ.
По умолчанию
Нет
печенье Попробуйте Дополнительно. Словарь файлов cookie для отправки на указанный URL.
По умолчанию
Нет
коллекторы Попробуйте Дополнительно. Словарь заголовков HTTP для отправки на указанный URL-адрес.
По умолчанию Нет
прокси Попробуйте Дополнительно. Словарь протокола к URL-адресу прокси.
По умолчанию
Нет
поток Попробуйте Дополнительно. Логическое указание, должен ли ответ быть немедленно загружен (False) или передан в потоковом режиме (True).
По умолчанию
Ложь
время ожидания Попробуйте Дополнительно. Число или кортеж, указывающий, сколько секунд ждать, пока клиент установит соединение и/или отправит ответ.
По умолчанию Нет означает, что запрос будет продолжен
пока соединение не будет закрыто
проверить Попытайся

Попробуй
Дополнительно. Логическое или строковое указание для проверки сертификата TLS серверов или нет.
По умолчанию Правда

Возвращаемое значение

Метод get() возвращает объект request.Response.


❮ Модуль запросов

ВЫБОР ЦВЕТА



Лучшие учебники

Учебник по HTML
Учебник по CSS
Учебник по JavaScript
Учебник How To
Учебник по SQL
Учебник по Python
Учебник по W3.CSS
Учебник по Bootstrap
Учебник по PHP
Учебник по Java
Учебник по C++
Учебник по jQuery

Основные ссылки

HTML Reference
CSS Reference
JavaScript Reference
SQL Reference
Python Reference
W3. CSS Reference
Bootstrap Reference
PHP Reference
HTML Colors
Java Reference
Angular Reference
jQuery Reference

9 Top0 Examples
Примеры HTML
Примеры CSS
Примеры JavaScript
Примеры How To
Примеры SQL
Примеры Python
Примеры W3.CSS
Примеры Bootstrap
Примеры PHP
Примеры Java
Примеры XML
Примеры jQuery


FORUM |
О

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

Авторское право 1999-2022 по данным Refsnes. Все права защищены.
W3Schools работает на основе W3.CSS.

Быстрый старт — запросы 2.

28.1 документации

Хотите начать? Эта страница дает хорошее представление о том, как начать работу
с запросами.

Во-первых, убедитесь, что:

Давайте начнем с нескольких простых примеров.

Сделать запрос

Сделать запрос с помощью Requests очень просто.

Начните с импорта модуля «Запросы»:

 >>> запросы на импорт
 

Теперь давайте попробуем получить веб-страницу. Для этого примера давайте получим общедоступный GitHub
временная шкала:

 >>> r = request.get('https://api.github.com/events')
 

Теперь у нас есть объект Response с именем r . Мы можем
получить всю необходимую нам информацию от этого объекта.

Простой API

Requests означает, что все формы HTTP-запросов очевидны. За
например, вот как вы делаете запрос HTTP POST:

 >>> r = request.post('https://httpbin.org/post', data={'key': 'value'})
 

Красиво, правда? А как насчет других типов HTTP-запросов: PUT, DELETE, HEAD и
ОПЦИИ? Все так же просто:

 >>> r = request. put('https://httpbin.org/put', data={'key': 'value'})
>>> r = request.delete('https://httpbin.org/delete')
>>> r = request.head('https://httpbin.org/get')
>>> r = request.options('https://httpbin.org/get')
 

Это все хорошо, но это только начало того, что могут сделать Запросы.
делать.

Передача параметров в URL

Вы часто хотите отправить какие-то данные в строке запроса URL. Если
вы создавали URL-адрес вручную, эти данные будут представлены как ключ/значение
пары в URL-адресе после вопросительного знака, например. httpbin.org/get?key=val .
Запросы позволяют вам предоставлять эти аргументы в виде словаря строк,
используя аргумент ключевого слова params . Например, если вы хотите пройти
ключ1=значение1 и ключ2=значение2 от до httpbin.org/get , вы бы использовали
следующий код:

 >>> полезная нагрузка = {'key1': 'value1', 'key2': 'value2'}
>>> r = request.get('https://httpbin. org/get', params=payload)
 

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

 >>> print(r.url)
https://httpbin.org/get?key2=value2&key1=value1
 

Обратите внимание, что любой ключ словаря, значение которого равно None , не будет добавлен в
Строка запроса URL.

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

 >>> полезная нагрузка = {'key1': 'value1', 'key2': ['value2', 'value3']}
>>> r = request.get('https://httpbin.org/get', params=payload)
>>> напечатать(r.url)
https://httpbin.org/get?key1=value1&key2=value2&key2=value3
 

Содержание ответа

Мы можем прочитать содержимое ответа сервера. Рассмотрите временную шкалу GitHub
еще раз:

 >>> запросы на импорт
>>> r = request.get('https://api.github.com/events')
>>> р.текст
'[{"репозиторий":{"open_issues":0,"url":"https://github.com/...
 

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

Когда вы делаете запрос, Requests делает обоснованные предположения о кодировке
ответ на основе заголовков HTTP. Кодировка текста, угадываемая Requests
используется при доступе к r.text . Вы можете узнать, что такое кодировка Requests
using и измените его, используя свойство r.encoding :

 >>> р.кодировка
'утф-8'
>>> r.encoding = 'ISO-8859-1'
 

Если вы измените кодировку, запросы будут использовать новое значение r.encoding
всякий раз, когда вы звоните r.text . Вы можете сделать это в любой ситуации, когда
вы можете применить специальную логику, чтобы выяснить, какая кодировка контента будет
быть. Например, HTML и XML имеют возможность указать свою кодировку в
их тело. В таких ситуациях вы должны использовать r.content , чтобы найти
кодировку, а затем установите r.encoding . Это позволит вам использовать р.текст с
правильная кодировка.

Запросы

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

Содержимое двоичного ответа

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

 >>> р.содержимое
b'[{"репозиторий":{"open_issues":0,"url":"https://github.com/...
 

Кодирование передачи gzip и deflate автоматически декодируется для вас.

Кодирование передачи br автоматически декодируется для вас, если библиотека Brotli
например, brotli или brotlicffi.

Например, чтобы создать образ из бинарных данных, возвращаемых запросом, вы можете
используйте следующий код:

 >>> из изображения импорта PIL
>>> из io импортировать BytesIO
>>> i = Image. open(BytesIO(r.content))
 

Содержимое ответа JSON

Также имеется встроенный декодер JSON, если вы имеете дело с данными JSON:

 >>> запросы на импорт
>>> r = request.get('https://api.github.com/events')
>>> р.json()
[{'репозиторий': {'open_issues': 0, 'url': 'https://github.com/...
 

В случае сбоя декодирования JSON r.json() вызывает исключение. Например, если
ответ получает 204 (нет содержимого), или если ответ содержит недопустимый JSON,
попытка r.json() вызывает request.exceptions.JSONDecodeError . Это исключение оболочки
обеспечивает взаимодействие для нескольких исключений, которые могут быть вызваны разными
версии python и библиотеки сериализации json.

Следует отметить, что успех вызова r.json() делает , а не
указать успешность ответа. Некоторые серверы могут возвращать объект JSON в
неудачный ответ (например, сведения об ошибке с HTTP 500). Такой JSON будет декодирован
и вернулся. Чтобы проверить успешность запроса, используйте
r.raise_for_status() или проверка r.status_code — это то, что вы ожидаете.

Необработанное содержимое ответа

В редких случаях, когда вы хотите получить необработанный ответ сокета от
сервер, вы можете получить доступ к r.raw . Если вы хотите сделать это, убедитесь, что вы установили
stream = True в вашем первоначальном запросе. Как только вы это сделаете, вы можете сделать это:

 >>> r = request.get('https://api.github.com/events', stream=True)
>>> r.raw

>>> r.raw.read(10)
'\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03'
 

В целом, однако, вы должны использовать подобный шаблон, чтобы сохранить то, что
передано в файл:

 с открытым (имя файла, 'wb') как fd:
    для чанка в r.iter_content(chunk_size=128):
        fd.write(чанк)
 

Использование Response.iter_content будет обрабатывать многое из того, что вы сделали бы в противном случае.
приходится обрабатывать при использовании Response.raw напрямую. При потоковой передаче
загрузки, указанный выше способ является предпочтительным и рекомендуемым способом получения
содержание. Обратите внимание, что chunk_size можно свободно настроить на число, которое
может лучше соответствовать вашим вариантам использования.

Note

Важное примечание об использовании Response.iter_content по сравнению с Response.raw .
Response.iter_content автоматически декодирует gzip и deflate
трансфер-кодировки. Response.raw — необработанный поток байтов.
преобразовать содержимое ответа. Если вам действительно нужен доступ к байтам, поскольку они
были возвращены, используйте Ответ.raw .

Более сложные запросы POST

Как правило, вы хотите отправить некоторые данные, закодированные в форме — очень похоже на HTML-форму.
Для этого просто передайте словарь в аргумент data . Ваш
словарь данных будет автоматически закодирован в форме при запросе:

 >>> полезная нагрузка = {'key1': 'value1', 'key2': 'value2'}
>>> r = request.post("https://httpbin.org/post", data=payload)
>>> печать (р.текст)
{
  ...
  "форма": {
    "ключ2": "значение2",
    "ключ1": "значение1"
  },
  ...
}
 

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

 >>> payload_tuples = [('ключ1', 'значение1'), ('ключ1', 'значение2')]
>>> r1 = request.post('https://httpbin.org/post', data=payload_tuples)
>>> payload_dict = {'key1': ['value1', 'value2']}
>>> r2 = request.post('https://httpbin.org/post', data=payload_dict)
>>> печать(r1.текст)
{
  ...
  "форма": {
    "ключ1": [
      "значение1",
      "значение2"
    ]
  },
  . ..
}
>>> r1.текст == r2.текст
Истинный
 

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

Например, GitHub API v3 принимает данные POST/PATCH в формате JSON:

 >>> импорт json
>>> url = 'https://api.github.com/some/endpoint'
>>> полезная нагрузка = {'некоторые': 'данные'}
>>> r = request.post(url, data=json.dumps(полезная нагрузка))
 

Обратите внимание, что приведенный выше код НЕ добавит Заголовок Content-Type
(поэтому, в частности, он НЕ будет устанавливать его на application/json ).

Если вам нужен этот набор заголовков и вы не хотите самостоятельно кодировать dict ,
вы также можете передать его напрямую, используя параметр json (добавлен в версии 2.4.2)
и он будет закодирован автоматически:

 >>> url = 'https://api.github. com/some/endpoint'
>>> полезная нагрузка = {'некоторые': 'данные'}
 
 >>> r = request.post(url, json=payload)
 

Обратите внимание, что параметр json игнорируется, если передается либо данные , либо файлы .

POST файл, закодированный из нескольких частей

Запросы упрощают загрузку файлов с кодировкой Multipart:

 >>> URL = 'https://httpbin.org/post'
>>> files = {'файл': open('report.xls', 'rb')}
>>> r = request.post(url, files=файлы)
>>> р.текст
{
  ...
  "файлы": {
    "file": "<цензурированные...бинарные...данные>"
  },
  ...
}
 

Вы можете указать имя файла, тип содержимого и заголовки явно:

 >>> URL = 'https://httpbin.org/post'
>>> files = {'file': ('report.xls', open('report.xls', 'rb'), 'application/vnd.ms-excel', {'Expires': '0'}) }
>>> r = request.post(url, files=файлы)
>>> р.текст
{
  ...
  "файлы": {
    "file": "<цензурированные...бинарные...данные>"
  },
  ...
}
 

При желании вы можете отправить строки для получения в виде файлов:

 >>> URL = 'https://httpbin. org/post'
>>> files = {'file': ('report.csv', 'some,data,to,send\nanother,row,to,send\n')}
>>> r = request.post(url, files=файлы)
>>> р.текст
{
  ...
  "файлы": {
    "file": "некоторые,данные,кому,отправить\\nanother,строка,кому,отправить\\n"
  },
  ...
}
 

Если вы публикуете очень большой файл как multipart/form-data
запрос, вы можете захотеть передать запрос. По умолчанию запрашивает не
поддерживают это, но есть отдельный пакет, который делает —
запрашивает пояс с инструментами . Вы должны прочитать документацию по поясу инструментов для получения более подробной информации о том, как его использовать.

Для отправки нескольких файлов в одном запросе обратитесь к расширенным
раздел.

Предупреждение

Настоятельно рекомендуется открывать файлы в двоичном формате
режим. Это связано с тем, что запросы могут пытаться предоставить
Content-Length заголовок для вас, и если он делает это значение
будет установлено число байт в файле. Могут возникать ошибки
если открыть файл в текстовом режиме .

Коды состояния ответа

Мы можем проверить код состояния ответа:

 >>> r = request.get('https://httpbin.org/get')
>>> r.status_code
200
 

Requests также поставляется со встроенным объектом поиска кода состояния для легкого
ссылка:

 >>> r.status_code == request.codes.ok
Истинный
 

Если мы сделали неверный запрос (ошибка клиента 4XX или ответ об ошибке сервера 5XX), мы
может поднять его с
Ответ.raise_for_status() :

 >>> bad_r = request.get('https://httpbin.org/status/404')
>>> bad_r.status_code
404
>>> bad_r.raise_for_status()
Traceback (последний последний вызов):
  Файл "requests/models.py", строка 832, в raise_for_status
    поднять http_error
запросы.исключения.HTTPError: 404 Ошибка клиента
 

Но, так как наши status_code для r было 200 , когда мы звоним
raise_for_status() получаем:

 >>> r. raise_for_status()
Никто
 

Все хорошо.

Файлы cookie

Если ответ содержит несколько файлов cookie, вы можете быстро получить к ним доступ:

 >>> url = 'http://example.com/some/cookie/setting/url'
>>> r = запросы.get(url)
>>> r.cookies['example_cookie_name']
'example_cookie_value'
 

Чтобы отправить собственные файлы cookie на сервер, вы можете использовать печенье
параметр:

 >>> URL = 'https://httpbin.org/cookies'
>>> cookies = dict(cookies_are='working')
>>> r = request.get(url, cookies=cookies)
>>> р.текст
'{"cookies": {"cookies_are": "рабочие"}}'
 

куки возвращаются в RequestsCookieJar ,
который действует как dict , но также предлагает более полный интерфейс,
подходит для использования в нескольких доменах или путях. Баночки для печенья могут
также передаваться в запросы:

 >>> jar = запросы.cookies.RequestsCookieJar()
>>> jar.set('tasty_cookie', 'ням', domain='httpbin. org', path='/cookies')
>>> jar.set('gross_cookie', 'blech', domain='httpbin.org', path='/в другом месте')
>>> URL = 'https://httpbin.org/cookies'
>>> r = request.get(url, cookies=jar)
>>> р.текст
'{"cookies": {"tasty_cookie": "ням"}}'
 

Перенаправление и история

По умолчанию запросы будут выполнять перенаправление местоположения для всех команд, кроме
ГЛАВА.

Мы можем использовать свойство history объекта Response для отслеживания перенаправления.

Список Response.history содержит
Ответ объектов, созданных для
завершить запрос. Список отсортирован от самого старого к самому последнему
отклик.

Например, GitHub перенаправляет все HTTP-запросы на HTTPS:

 >>> r = request.get('http://github.com/')
>>> р.url
'https://github.com/'
>>> r.status_code
200
>>> р.история
[<Ответ [301]>]
 

Если вы используете GET, OPTIONS, POST, PUT, PATCH или DELETE, вы можете отключить
обработка перенаправления с параметром allow_redirects :

 >>> r = request. get('http://github.com/', allow_redirects=False)
>>> r.status_code
301
>>> р.история
[]
 

Если вы используете HEAD, вы также можете включить перенаправление:

 >>> r = request.head('http://github.com/', allow_redirects=True)
>>> р.url
'https://github.com/'
>>> р.история
[<Ответ [301]>]
 

Тайм-ауты

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

 >>> request.get('https://github.com/', timeout=0.001)
Traceback (последний последний вызов):
  Файл "", строка 1, в 
request.exceptions.Timeout: HTTPConnectionPool (host = 'github.com', port = 80): время ожидания запроса истекло. (время ожидания = 0,001)
 

Примечание

тайм-аут не является ограничением по времени на загрузку всего ответа;
скорее, исключение возникает, если сервер не выдал
ответ на тайм-аут секунды (точнее, если ни один байт не был
получено на базовом сокете в течение тайм-аута секунд).

This entry was posted in Популярное