документация на русском, 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 Популярное