Requests · pypi

HTML Sessions¶

These sessions are for making HTTP requests:

class (mock_browser=True)

A consumable session, for cookie persistence and connection pooling,
amongst other things.

(): If a browser was created close it first.

(url, **kwargs)

Sends a DELETE request. Returns object.

Parameters:	url – URL for the new object. **kwargs – Optional arguments that takes.
Return type:	requests.Response

(url, **kwargs)

Sends a GET request. Returns object.

Parameters:	url – URL for the new object. **kwargs – Optional arguments that takes.
Return type:	requests.Response

(url)

Returns the appropriate connection adapter for the given URL.

Return type:	requests.adapters.BaseAdapter

(resp): Receives a Response. Returns a redirect URI or

(url, **kwargs)

Sends a HEAD request. Returns object.

Parameters:	url – URL for the new object. **kwargs – Optional arguments that takes.
Return type:	requests.Response

(url, proxies, stream, verify, cert)

Check the environment and merge it with some settings.

Return type:

(prefix, adapter)

Registers a connection adapter to a prefix.

Adapters are sorted in descending order by prefix length.

(url, **kwargs)

Sends a OPTIONS request. Returns object.

Parameters:	url – URL for the new object. **kwargs – Optional arguments that takes.
Return type:	requests.Response

(url, data=None, **kwargs)

Sends a PATCH request. Returns object.

Parameters:	url – URL for the new object. data – (optional) Dictionary, bytes, or file-like object to send in the body of the . **kwargs – Optional arguments that takes.
Return type:	requests.Response

(url, data=None, json=None, **kwargs)

Sends a POST request. Returns object.

Parameters:	url – URL for the new object. data – (optional) Dictionary, bytes, or file-like object to send in the body of the . json – (optional) json to send in the body of the . **kwargs – Optional arguments that takes.
Return type:	requests.Response

(request)

Constructs a for
transmission and returns it. The has settings
merged from the instance and those of the
.

Parameters:	request – instance to prepare with this session’s settings.
Return type:	requests.PreparedRequest

(url, data=None, **kwargs)

Sends a PUT request. Returns object.

Parameters:	url – URL for the new object. data – (optional) Dictionary, bytes, or file-like object to send in the body of the . **kwargs – Optional arguments that takes.
Return type:	requests.Response

(prepared_request, response): When being redirected we may want to strip authentication from the
request to avoid leaking credentials. This method intelligently removes
and reapplies authentication where possible to avoid credential loss.

(prepared_request, response): When being redirected we may want to change the method of the request
based on certain specs or browser behavior.

(prepared_request, proxies)

This method re-evaluates the proxy configuration by considering the
environment variables. If we are redirected to a URL covered by
NO_PROXY, we strip the proxy configuration. Otherwise, we set missing
proxy keys for this URL (in case they were stripped by a previous
redirect).

This method also replaces the Proxy-Authorization header where
necessary.

Return type:

(*args, **kwargs) → requests_html.HTMLResponse: Makes an HTTP Request, with mocked User–Agent headers.
Returns a class:HTTPResponse <HTTPResponse>.

(resp, req, stream=False, timeout=None, verify=True, cert=None, proxies=None, yield_requests=False, **adapter_kwargs): Receives a Response. Returns a generator of Responses or Requests.

(request, **kwargs)

Send a given PreparedRequest.

Return type:	requests.Response

Cookies¶

If a response contains some Cookies, you can quickly access them:

>>> url = 'http://example.com/some/cookie/setting/url'
>>> r = requests.get(url)

>>> r.cookies'example_cookie_name'
'example_cookie_value'

To send your own cookies to the server, you can use the
parameter:

>>> url = 'https://httpbin.org/cookies'
>>> cookies = dict(cookies_are='working')

>>> r = requests.get(url, cookies=cookies)
>>> r.text
'{"cookies": {"cookies_are": "working"}}'

Cookies are returned in a ,
which acts like a but also offers a more complete interface,
suitable for use over multiple domains or paths. Cookie jars can
also be passed in to requests:

Session Objects¶

The Session object allows you to persist certain parameters across
requests. It also persists cookies across all requests made from the
Session instance, and will use ’s . So if
you’re making several requests to the same host, the underlying TCP
connection will be reused, which can result in a significant performance
increase (see HTTP persistent connection).

A Session object has all the methods of the main Requests API.

Let’s persist some cookies across requests:

s = requests.Session()

s.get('https://httpbin.org/cookies/set/sessioncookie/123456789')
r = s.get('https://httpbin.org/cookies')

print(r.text)
# '{"cookies": {"sessioncookie": "123456789"}}'

Sessions can also be used to provide default data to the request methods. This
is done by providing data to the properties on a Session object:

s = requests.Session()
s.auth = ('user', 'pass')
s.headers.update({'x-test' 'true'})

# both 'x-test' and 'x-test2' are sent
s.get('https://httpbin.org/headers', headers={'x-test2' 'true'})

Any dictionaries that you pass to a request method will be merged with the
session-level values that are set. The method-level parameters override session
parameters.

Note, however, that method-level parameters will not be persisted across
requests, even if using a session. This example will only send the cookies
with the first request, but not the second:

s = requests.Session()

r = s.get('https://httpbin.org/cookies', cookies={'from-my' 'browser'})
print(r.text)
# '{"cookies": {"from-my": "browser"}}'

r = s.get('https://httpbin.org/cookies')
print(r.text)
# '{"cookies": {}}'

If you want to manually add cookies to your session, use the
to manipulate
.

Sessions can also be used as context managers:

with requests.Session() as s
    s.get('https://httpbin.org/cookies/set/sessioncookie/123456789')

This will make sure the session is closed as soon as the block is
exited, even if unhandled exceptions occurred.

Remove a Value From a Dict Parameter

Sometimes you’ll want to omit session-level keys from a dict parameter. To
do this, you simply set that key’s value to in the method-level
parameter. It will automatically be omitted.

Basic Authentication¶

To illustrate creating and installing a handler we will use the
. For a more detailed discussion of this subject –
including an explanation of how Basic Authentication works — see the Basic
Authentication Tutorial.

When authentication is required, the server sends a header (as well as the 401
error code) requesting authentication. This specifies the authentication scheme
and a ‘realm’. The header looks like: .

e.g.

WWW-Authenticate: Basic realm="cPanel Users"

The client should then retry the request with the appropriate name and password
for the realm included as a header in the request. This is ‘basic
authentication’. In order to simplify this process we can create an instance of
and an opener to use this handler.

The uses an object called a password manager to handle
the mapping of URLs and realms to passwords and usernames. If you know what the
realm is (from the authentication header sent by the server), then you can use a
. Frequently one doesn’t care what the realm is. In that
case, it is convenient to use . This allows
you to specify a default username and password for a URL. This will be supplied
in the absence of you providing an alternative combination for a specific
realm. We indicate this by providing as the realm argument to the
method.

The top-level URL is the first URL that requires authentication. URLs “deeper”
than the URL you pass to .add_password() will also match.

# create a password manager
password_mgr = urllib.request.HTTPPasswordMgrWithDefaultRealm()

# Add the username and password.
# If we knew the realm, we could use it instead of None.
top_level_url = "http://example.com/foo/"
password_mgr.add_password(None, top_level_url, username, password)

handler = urllib.request.HTTPBasicAuthHandler(password_mgr)

# create "opener" (OpenerDirector instance)
opener = urllib.request.build_opener(handler)

# use the opener to fetch a URL
opener.open(a_url)

# Install the opener.
# Now all calls to urllib.request.urlopen use our opener.
urllib.request.install_opener(opener)

Note

In the above example we only supplied our to
. By default openers have the handlers for normal situations
– (if a proxy setting such as an
environment variable is set), , ,
, , ,
, , .

Python requests upload image

In the following example, we are going to upload an image. We create
a web application with Flask.

app.py

#!/usr/bin/env python

import os
from flask import Flask, request

app = Flask(__name__)

@app.route("/")
def home():
    return 'This is home page'

@app.route("/upload", methods=)
def handleFileUpload():

    msg = 'failed to upload image'

    if 'image' in request.files:

        photo = request.files

        if photo.filename != '':

            photo.save(os.path.join('.', photo.filename))
            msg = 'image uploaded successfully'

    return msg

if __name__ == '__main__':
    app.run()

This is a simple application with two endpoints. The
endpoint checks if there is some image and saves it to the current directory.

upload_file.py

#!/usr/bin/env python

import requests as req

url = 'http://localhost:5000/upload'

with open('sid.jpg', 'rb') as f:

    files = {'image': f}

    r = req.post(url, files=files)
    print(r.text)

We send the image to the Flask application. The file is specified
in the attribute of the method.

Чтение ответа

Ответ на HTTP-запрос может содержать множество заголовков, содержащих различную информацию.

httpbin – популярный веб-сайт для тестирования различных операций HTTP. В этой статье мы будем использовать httpbin или get для анализа ответа на запрос GET. Прежде всего, нам нужно узнать заголовок ответа и то, как он выглядит. Вы можете использовать любой современный веб-браузер, чтобы найти его, но для этого примера мы будем использовать браузер Google Chrome:

В Chrome откройте URL-адрес http://httpbin.org/get, щелкните правой кнопкой мыши в любом месте страницы и выберите параметр «Проверить».
Это откроет новое окно в вашем браузере. Обновите страницу и перейдите на вкладку «Сеть».
Эта вкладка «Сеть» покажет вам все различные типы сетевых запросов, сделанных браузером. Щелкните запрос «получить» в столбце «Имя» и выберите вкладку «Заголовки» справа.

Содержание «Заголовков ответа» является нашим обязательным элементом. Вы можете увидеть пары ключ-значение, содержащие различную информацию о ресурсе и запросе. Попробуем разобрать эти значения с помощью библиотеки запросов:

import requests

r = requests.get('http://httpbin.org/get')
print(r.headers)
print(r.headers)
print(r.headers)
print(r.headers)
print(r.headers)
print(r.headers)
print(r.headers)
print(r.headers)

Мы получили информацию заголовка с помощью r.headers, и мы можем получить доступ к каждому значению заголовка с помощью определенных ключей

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

Заголовок выше показывает, что ответ находится в формате JSON: (Content-type: application/json). Библиотека запросов поставляется с одним встроенным парсером JSON, и мы можем использовать request.get (‘url’). Json() для анализа его как объекта JSON. Затем значение для каждого ключа результатов ответа можно легко проанализировать, как показано ниже:

Точно так же попробуем получить доступ к значению ответа. Заголовок выше показывает, что ответ находится в формате JSON: (Content-type: application/json). Библиотека запросов поставляется с одним встроенным парсером JSON, и мы можем использовать request.get (‘url’). Json() для анализа его как объекта JSON. Затем значение для каждого ключа результатов ответа можно легко проанализировать, как показано ниже:

import requests

r = requests.get('http://httpbin.org/get')

response = r.json()
print(r.json())
print(response)
print(response)
print(response)
print(response)
print(response)
print(response)
print(response)
print(response)
print(response)

Приведенный выше код напечатает следующий вывод:

{'headers': {'Host': 'httpbin.org', 'Accept-Encoding': 'gzip, deflate', 'Connection': 'close', 'Accept': '*/*', 'User-Agent': 'python-requests/2.9.1'}, 'url': 'http://httpbin.org/get', 'args': {}, 'origin': '103.9.74.222'}
{}
{'Host': 'httpbin.org', 'Accept-Encoding': 'gzip, deflate', 'Connection': 'close', 'Accept': '*/*', 'User-Agent': 'python-requests/2.9.1'}
*/*
gzip, deflate
close
httpbin.org
python-requests/2.9.1
103.9.74.222
http://httpbin.org/get

Третья строка, ierjson(), напечатала значение ответа JSON. Мы сохранили значение JSON в ответе переменной, а затем распечатали значение для каждого ключа

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

Подобно JSON и текстовому контенту, мы можем использовать запросы для чтения контента ответа в байтах для нетекстовых запросов, используя свойство .content. Это автоматически декодирует gzip и дефлирует закодированные файлы.

Client Side Certificates¶

You can also specify a local cert to use as client side certificate, as a single
file (containing the private key and the certificate) or as a tuple of both
files’ paths:

>>> requests.get('https://kennethreitz.org', cert=('/path/client.cert', '/path/client.key'))
<Response >

or persistent:

s = requests.Session()
s.cert = '/path/client.cert'

If you specify a wrong path or an invalid cert, you’ll get a SSLError:

>>> requests.get('https://kennethreitz.org', cert='/wrong_path/client.pem')
SSLError:  _ssl.c:347: error:140B0009:SSL routines:SSL_CTX_use_PrivateKey_file:PEM lib

Properties and Methods

Property/Method		Description
apparent_encoding	Try it	Returns the apparent encoding
close()	Try it	Closes the connection to the server
content	Try it	Returns the content of the response, in bytes
cookies	Try it	Returns a CookieJar object with the cookies sent back from the server
elapsed	Try it	Returns a timedelta object with the time elapsed from sending the request to the arrival of the response
encoding	Try it	Returns the encoding used to decode r.text
headers	Try it	Returns a dictionary of response headers
history	Try it	Returns a list of response objects holding the history of request (url)
is_permanent_redirect	Try it	Returns True if the response is the permanent redirected url, otherwise False
is_redirect	Try it	Returns True if the response was redirected, otherwise False
iter_content()	Try it	Iterates over the response
iter_lines()	Try it	Iterates over the lines of the response
json()	Try it	Returns a JSON object of the result (if the result was written in JSON format, if not it raises an error)
links	Try it	Returns the header links
next	Try it	Returns a PreparedRequest object for the next request in a redirection
ok	Try it	Returns True if status_code is less than 400, otherwise False
raise_for_status()	Try it	If an error occur, this method returns a HTTPError object
reason	Try it	Returns a text corresponding to the status code
request	Try it	Returns the request object that requested this response
status_code	Try it	Returns a number that indicates the status (200 is OK, 404 is Not Found)
text	Try it	Returns the content of the response, in unicode
url	Try it	Returns the URL of the response

User agent

In this section, we specify the name of the user agent. We create our
own Python HTTP server.

http_server.py

#!/usr/bin/env python

from http.server import BaseHTTPRequestHandler, HTTPServer

class MyHandler(BaseHTTPRequestHandler):

    def do_GET(self):

        message = "Hello there"

        self.send_response(200)

        if self.path == '/agent':

            message = self.headers

        self.send_header('Content-type', 'text/html')
        self.end_headers()

        self.wfile.write(bytes(message, "utf8"))

        return


def main():

    print('starting server on port 8081...')

    server_address = ('127.0.0.1', 8081)
    httpd = HTTPServer(server_address, MyHandler)
    httpd.serve_forever()

main()

We have a simple Python HTTP server.

if self.path == '/agent':

    message = self.headers

If the path contains , we return
the specified user agent.

user_agent.py

#!/usr/bin/env python

import requests as req

headers = {'user-agent': 'Python script'}

resp = req.get("http://localhost:8081/agent", headers=headers)
print(resp.text)

This script creates a simple GET request to our Python HTTP server.
To add HTTP headers to a request, we pass in a dictionary to the
parameter.

headers = {'user-agent': 'Python script'}

The header values are placed in a Python dictionary.

resp = req.get("http://localhost:8081/agent", headers=headers)

The values are passed to the parameter.

$ simple_server.py
starting server on port 8081...

First, we start the server.

$ ./user_agent.py
Python script

Then we run the script. The server responded with the name of the agent that we
have sent with the request.

Other HTTP methods

POST and GET are the two most common methods used by the average user. For example, Scraper APIs users utilize only these two HTTP methods in order to send job requests (POST) and receive data (GET). Yet, there are many more ways to interact with servers over HTTP.

PUT – replaces all the current representations of the target resource with the uploaded content.
DELETE – removes all the current representations of the target resource given by URI.
HEAD – similar to GET, but it transfers the status and header section only.
OPTIONS – describes the communication options for the target resource.
TRACE – echoes the original request message back to its source.
PATCH – applies modifications to a specified resource.

All the HTTP methods listed above are rarely used outside of server administration, web development and debugging. An average internet user will not have the required permissions to perform actions such as DELETE or PUT on nearly any website. Other HTTP methods are mostly useful for testing websites, something that is quite often outside the field of interest of the average internet user.

SSL Cert Verification¶

Requests verifies SSL certificates for HTTPS requests, just like a web browser.
By default, SSL verification is enabled, and Requests will throw a SSLError if
it’s unable to verify the certificate:

>>> requests.get('https://requestb.in')
requests.exceptions.SSLError: hostname 'requestb.in' doesn't match either of '*.herokuapp.com', 'herokuapp.com'

I don’t have SSL setup on this domain, so it throws an exception. Excellent. GitHub does though:

>>> requests.get('https://github.com')
<Response >

You can pass the path to a CA_BUNDLE file or directory with certificates of trusted CAs:

>>> requests.get('https://github.com', verify='/path/to/certfile')

or persistent:

s = requests.Session()
s.verify = '/path/to/certfile'

Note

If is set to a path to a directory, the directory must have been processed using
the utility supplied with OpenSSL.

This list of trusted CAs can also be specified through the environment variable.
If is not set, will be used as fallback.

Requests can also ignore verifying the SSL certificate if you set to False:

>>> requests.get('https://kennethreitz.org', verify=False)
<Response >

Note that when is set to , requests will accept any TLS
certificate presented by the server, and will ignore hostname mismatches
and/or expired certificates, which will make your application vulnerable to
man-in-the-middle (MitM) attacks. Setting verify to may be useful
during local development or testing.

Потоковая отправка/загрузка контента модулем requests.

;
;
;
.

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

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

tarball_url = 'https://github.com/psf/requests/tarball/master'
resp = requests.get(tarball_url, stream=True)

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

if int(resp.headers'content-length']) < TOO_LONG
  content = resp.content
  ...

Можно дополнительно управлять рабочим процессом с помощью методов и . Кроме того, можно прочитать не декодированное тело ответа сервера, которое возвращает атрибут (из базового ).

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

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

with requests.get('https://httpbin.org/get', stream=True) as resp
    # здесь делаем что-нибудь с ответом.

Потоковая передача данных для исходящих/входящих запросов.

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

Для потоковой передачи или загрузки просто предоставьте файлоподобный объект для тела запроса:

Пример отправки большого файла:

with open('massive-body', 'rb') as fp
    requests.post('http://some.url/streamed', data=fp)

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

Передача данных частями для исходящих/входящих запросов.

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

def gen():
    yield 'hi'
    yield 'there'

requests.post('http://some.url/chunked', data=gen())

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

Поддержка соединения при больших объемах данных.

Благодаря поддержка соединения keep-alive работает на 100% автоматически в течение всего сеанса! Любые запросы, которые делаются в течение сеанса, автоматически повторно используют соответствующее соединение!

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

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

В некоторых случаях вам нужно будет передавать параметры вместе с вашими запросами GET, которые принимают форму строк запроса. Для этого нам нужно передать эти значения в параметре params, как показано ниже:

import requests

payload = {'user_name': 'admin', 'password': 'password'}
r = requests.get('http://httpbin.org/get', params=payload)

print(r.url)
print(r.text)

Здесь мы присваиваем значения наших параметров переменной полезной нагрузки, а затем – запросу GET через params. Приведенный выше код вернет следующий результат:

http://httpbin.org/get?password=passworduser_name=admin
{"args":{"password":"password","user_name":"admin"},"headers":{"Accept":"*/*","Accept-Encoding":"gzip, deflate","Connection":"close","Host":"httpbin.org","User-Agent":"python-requests/2.9.1"},"origin":"103.9.74.222","url":"http://httpbin.org/get?password=passworduser_name=admin"}

Как видите, библиотека Reqeusts автоматически превратила наш словарь параметров в строку запроса и прикрепила ее к URL-адресу.

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

Python Tutorial

Python HOMEPython IntroPython Get StartedPython SyntaxPython CommentsPython Variables
Python Variables
Variable Names
Assign Multiple Values
Output Variables
Global Variables
Variable Exercises

Python Data TypesPython NumbersPython CastingPython Strings
Python Strings
Slicing Strings
Modify Strings
Concatenate Strings
Format Strings
Escape Characters
String Methods
String Exercises

Python BooleansPython OperatorsPython Lists
Python Lists
Access List Items
Change List Items
Add List Items
Remove List Items
Loop Lists
List Comprehension
Sort Lists
Copy Lists
Join Lists
List Methods
List Exercises

Python Tuples
Python Tuples
Access Tuples
Update Tuples
Unpack Tuples
Loop Tuples
Join Tuples
Tuple Methods
Tuple Exercises

Python Sets
Python Sets
Access Set Items
Add Set Items
Remove Set Items
Loop Sets
Join Sets
Set Methods
Set Exercises

Python Dictionaries
Python Dictionaries
Access Items
Change Items
Add Items
Remove Items
Loop Dictionaries
Copy Dictionaries
Nested Dictionaries
Dictionary Methods
Dictionary Exercise

Python If…ElsePython While LoopsPython For LoopsPython FunctionsPython LambdaPython ArraysPython Classes/ObjectsPython InheritancePython IteratorsPython ScopePython ModulesPython DatesPython MathPython JSONPython RegExPython PIPPython Try…ExceptPython User InputPython String Formatting

Authentication

Authentication helps a service understand who you are. Typically, you provide your credentials to a server by passing data through the header or a custom header defined by the service. All the request functions you’ve seen to this point provide a parameter called , which allows you to pass your credentials.

One example of an API that requires authentication is GitHub’s API. This endpoint provides information about the authenticated user’s profile. To make a request to the Authenticated User API, you can pass your GitHub username and password in a tuple to :

>>>

The request succeeded if the credentials you passed in the tuple to are valid. If you try to make this request with no credentials, you’ll see that the status code is :

>>>

When you pass your username and password in a tuple to the parameter, is applying the credentials using HTTP’s Basic access authentication scheme under the hood.

Therefore, you could make the same request by passing explicit Basic authentication credentials using :

>>>

Though you don’t need to be explicit for Basic authentication, you may want to authenticate using another method. provides other methods of authentication out of the box such as and .

You can even supply your own authentication mechanism. To do so, you must first create a subclass of . Then, you implement :

Here, your custom mechanism receives a token, then includes that token in the header of your request.

Bad authentication mechanisms can lead to security vulnerabilities, so unless a service requires a custom authentication mechanism for some reason, you’ll always want to use a tried-and-true auth scheme like Basic or OAuth.

While you’re thinking about security, let’s consider dealing with SSL Certificates using .

Аутентификация

Рассмотрим базовую

аутентификацию

на сайте httpbin

Придумайте любое имя пользоватлея и пароль к нему.

Я придумал andrey с паролем heihei

Перейдите на

httpbin.org

. Убедитесь, что в адресной строке стоит basic-auth/andrey/heihei
либо те логин и пароль, что придумали вы.

Введите ваши логин и пароль

Убедитесь, что аутентификация прошла успешно

Теперь проделаем такую же аутентификацию с помощью Python

Создайте файл

auth_demo.py

со следующим кодом

python3 auth_demo.py

{
«authenticated»: true,
«user»: «andrey»
}

Ответ совпадает с тем что мы уже получали в браузере

Выполните такой же запрос, но с неправильным паролем. Убедитесь в том, что text ничего не содержит. Замените
print(r.text) на print(r) и убедитесь, что полученный объект это

Python requests head method

The method retrieves document headers.
The headers consist of fields, including date, server, content type,
or last modification time.

head_request.py

#!/usr/bin/env python

import requests as req

resp = req.head("http://www.webcode.me")

print("Server: " + resp.headers)
print("Last modified: " + resp.headers)
print("Content type: " + resp.headers)

The example prints the server, last modification time, and content type
of the web page.

$ ./head_request.py
Server: nginx/1.6.2
Last modified: Sat, 20 Jul 2019 11:49:25 GMT
Content type: text/html

This is the output of the program.

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

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

import http.client
import pprint

connection = http.client.HTTPSConnection("www.journaldev.com")
connection.request("GET", "/")
response = connection.getresponse()
headers = response.getheaders()
pp = pprint.PrettyPrinter(indent=4)
pp.pprint("Headers: {}".format(headers))

Посмотрим на результат этой программы:

Parameter Values

Parameter		Description
url	Try it	Required. The url of the request
allow_redirects	Try itTry it	Optional. A Boolean to enable/disable redirection.Default (not allowing redirects)
auth	Try it	Optional. A tuple to enable a certain HTTP authentication.Default
cert	Try it	Optional. A String or Tuple specifying a cert file or key.Default
cookies	Try it	Optional. A dictionary of cookies to send to the specified url.Default
headers	Try it	Optional. A dictionary of HTTP headers to send to the specified url.Default
proxies	Try it	Optional. A dictionary of the protocol to the proxy url.Default
stream	Try it	Optional. A Boolean indication if the response should be immediately downloaded (False) or streamed (True).Default
timeout	Try it	Optional. A number, or a tuple, indicating how many seconds to wait for the client to make a connection and/or send a response.Default which means the request will continue until the connection is closed
verify	Try it	Optional. A Boolean or a String indication to verify the servers TLS certificate or not.Default

Footnotes¶

This document was reviewed and revised by John Lee.

Google for example.

Browser sniffing is a very bad practice for website design — building
sites using web standards is much more sensible. Unfortunately a lot of
sites still send different versions to different browsers.

The user agent for MSIE 6 is
‘Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322)’

For details of more HTTP request headers, see
Quick Reference to HTTP Headers.

In my case I have to use a proxy to access the internet at work. If you
attempt to fetch localhost URLs through this proxy it blocks them. IE
is set to use the proxy, which urllib picks up on. In order to test
scripts with a localhost server, I have to prevent urllib from using
the proxy.

urllib opener for SSL proxy (CONNECT method): ASPN Cookbook Recipe.

HTTP status codes¶

Supported,
IANA-registered
status codes available in are:

Code	Enum Name	Details
		HTTP/1.1 RFC 7231, Section 6.2.1
		HTTP/1.1 RFC 7231, Section 6.2.2
		WebDAV RFC 2518, Section 10.1
		An HTTP Status Code for Indicating Hints RFC 8297
		HTTP/1.1 RFC 7231, Section 6.3.1
		HTTP/1.1 RFC 7231, Section 6.3.2
		HTTP/1.1 RFC 7231, Section 6.3.3
		HTTP/1.1 RFC 7231, Section 6.3.4
		HTTP/1.1 RFC 7231, Section 6.3.5
		HTTP/1.1 RFC 7231, Section 6.3.6
		HTTP/1.1 RFC 7233, Section 4.1
		WebDAV RFC 4918, Section 11.1
		WebDAV Binding Extensions RFC 5842, Section 7.1 (Experimental)
		Delta Encoding in HTTP RFC 3229, Section 10.4.1
		HTTP/1.1 RFC 7231, Section 6.4.1
		HTTP/1.1 RFC 7231, Section 6.4.2
		HTTP/1.1 RFC 7231, Section 6.4.3
		HTTP/1.1 RFC 7231, Section 6.4.4
		HTTP/1.1 RFC 7232, Section 4.1
		HTTP/1.1 RFC 7231, Section 6.4.5
		HTTP/1.1 RFC 7231, Section 6.4.7
		Permanent Redirect RFC 7238, Section 3 (Experimental)
		HTTP/1.1 RFC 7231, Section 6.5.1
		HTTP/1.1 Authentication RFC 7235, Section 3.1
		HTTP/1.1 RFC 7231, Section 6.5.2
		HTTP/1.1 RFC 7231, Section 6.5.3
		HTTP/1.1 RFC 7231, Section 6.5.4
		HTTP/1.1 RFC 7231, Section 6.5.5
		HTTP/1.1 RFC 7231, Section 6.5.6
		HTTP/1.1 Authentication RFC 7235, Section 3.2
		HTTP/1.1 RFC 7231, Section 6.5.7
		HTTP/1.1 RFC 7231, Section 6.5.8
		HTTP/1.1 RFC 7231, Section 6.5.9
		HTTP/1.1 RFC 7231, Section 6.5.10
		HTTP/1.1 RFC 7232, Section 4.2
		HTTP/1.1 RFC 7231, Section 6.5.11
		HTTP/1.1 RFC 7231, Section 6.5.12
		HTTP/1.1 RFC 7231, Section 6.5.13
		HTTP/1.1 Range Requests RFC 7233, Section 4.4
		HTTP/1.1 RFC 7231, Section 6.5.14
		HTCPCP/1.0 RFC 2324, Section 2.3.2
		HTTP/2 RFC 7540, Section 9.1.2
		WebDAV RFC 4918, Section 11.2
		WebDAV RFC 4918, Section 11.3
		WebDAV RFC 4918, Section 11.4
		Using Early Data in HTTP RFC 8470
		HTTP/1.1 RFC 7231, Section 6.5.15
		Additional HTTP Status Codes RFC 6585
		Additional HTTP Status Codes RFC 6585
		Additional HTTP Status Codes RFC 6585
		An HTTP Status Code to Report Legal Obstacles RFC 7725
		HTTP/1.1 RFC 7231, Section 6.6.1
		HTTP/1.1 RFC 7231, Section 6.6.2
		HTTP/1.1 RFC 7231, Section 6.6.3
		HTTP/1.1 RFC 7231, Section 6.6.4
		HTTP/1.1 RFC 7231, Section 6.6.5
		HTTP/1.1 RFC 7231, Section 6.6.6
		Transparent Content Negotiation in HTTP RFC 2295, Section 8.1 (Experimental)
		WebDAV RFC 4918, Section 11.5
		WebDAV Binding Extensions RFC 5842, Section 7.2 (Experimental)
		An HTTP Extension Framework RFC 2774, Section 7 (Experimental)
		Additional HTTP Status Codes RFC 6585, Section 6

In order to preserve backwards compatibility, enum values are also present
in the module in the form of constants. The enum name is
equal to the constant name (i.e. is also available as
).

Changed in version 3.7: Added status code.

New in version 3.8: Added status code.

New in version 3.9: Added , and status codes.