Python Language
Python Requests Post

Einführung

Einfacher Beitrag

from requests import post

foo = post('http://httpbin.org/post', data = {'key':'value'})

Führt eine einfache HTTP-POST-Operation aus. Gebuchte Daten können in fast allen Formaten vorliegen, jedoch sind Schlüsselwertpaare am häufigsten.

Kopfzeilen

Header können angezeigt werden:

print(foo.headers)

Eine Beispielantwort:

{'Content-Length': '439', 'X-Processed-Time': '0.000802993774414', 'X-Powered-By': 'Flask', 'Server': 'meinheld/0.6.1', 'Connection': 'keep-alive', 'Via': '1.1 vegur', 'Access-Control-Allow-Credentials': 'true', 'Date': 'Sun, 21 May 2017 20:56:05 GMT', 'Access-Control-Allow-Origin': '*', 'Content-Type': 'application/json'}

Header können auch vor dem Post vorbereitet werden:

headers = {'Cache-Control':'max-age=0',
        'Upgrade-Insecure-Requests':'1',
        'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/54.0.2840.99 Safari/537.36',
        'Content-Type':'application/x-www-form-urlencoded',
        'Accept':'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
        'Referer':'https://www.groupon.com/signup',
        'Accept-Encoding':'gzip, deflate, br',
        'Accept-Language':'es-ES,es;q=0.8'
        }

 foo = post('http://httpbin.org/post', headers=headers, data = {'key':'value'})

Codierung

Die Kodierung kann auf die gleiche Weise festgelegt und angezeigt werden:

 print(foo.encoding)

'utf-8'

foo.encoding = 'ISO-8859-1'

SSL-Überprüfung

Bei Anfragen werden standardmäßig SSL-Zertifikate von Domänen überprüft. Dies kann überschrieben werden:

foo = post('http://httpbin.org/post', data = {'key':'value'}, verify=False)

Umleitung

Bei jeder Umleitung (zB http zu https) kann dies ebenfalls geändert werden:

foo = post('http://httpbin.org/post', data = {'key':'value'}, allow_redirects=False)

Wenn die Nachoperation umgeleitet wurde, kann auf diesen Wert zugegriffen werden:

print(foo.url) 

Eine vollständige Geschichte von Weiterleitungen kann angezeigt werden:

print(foo.history) 

Formularcodierte Daten

from requests import post

payload = {'key1' : 'value1',
           'key2' : 'value2'
           }

foo = post('http://httpbin.org/post', data=payload)

Um formcodierte Daten mit der Nachoperation zu übergeben, müssen Daten als Wörterbuch strukturiert und als Datenparameter bereitgestellt werden.

Wenn die Daten nicht formcodiert werden sollen, übergeben Sie einfach eine Zeichenfolge oder eine Ganzzahl an den Datenparameter.

Geben Sie das Wörterbuch an den Parameter json für Requests, um die Daten automatisch zu formatieren:

from requests import post

payload = {'key1' : 'value1', 'key2' : 'value2'}

foo = post('http://httpbin.org/post', json=payload)

Datei-Upload

Mit dem Requests-Modul muss lediglich ein .read() im Gegensatz zu den mit .read() abgerufenen .read() :

from requests import post

files = {'file' : open('data.txt', 'rb')}

foo = post('http://http.org/post', files=files)

Dateiname, Inhaltstyp und Kopfzeilen können ebenfalls festgelegt werden:

files = {'file': ('report.xls', open('report.xls', 'rb'), 'application/vnd.ms-excel', {'Expires': '0'})}

foo = requests.post('http://httpbin.org/post', files=files)

Strings können auch als Datei gesendet werden, sofern sie als files Parameter angegeben werden.

Mehrere Dateien

Mehrere Dateien können ähnlich wie eine Datei bereitgestellt werden:

multiple_files = [
    ('images', ('foo.png', open('foo.png', 'rb'), 'image/png')),
    ('images', ('bar.png', open('bar.png', 'rb'), 'image/png'))]

foo = post('http://httpbin.org/post', files=multiple_files)

Antworten

Antwortcodes können in einer Nachoperation angezeigt werden:

from requests import post

foo = post('http://httpbin.org/post', data={'data' : 'value'})
print(foo.status_code)

Zurückgegebene Daten

Zugriff auf zurückgegebene Daten:

foo = post('http://httpbin.org/post', data={'data' : 'value'})
print(foo.text)

Rohe Antworten

In den Fällen, in denen Sie auf das zugrunde liegende urllib3 response.HTTPResponse-Objekt zugreifen müssen, kann dies folgendermaßen geschehen:

foo = post('http://httpbin.org/post', data={'data' : 'value'})
res = foo.raw

print(res.read())

Authentifizierung

Einfache HTTP-Authentifizierung

Die einfache HTTP-Authentifizierung kann mit folgendem erreicht werden:

from requests import post

foo = post('http://natas0.natas.labs.overthewire.org', auth=('natas0', 'natas0'))

Dies ist eine technisch kurze Hand für Folgendes:

from requests import post
from requests.auth import HTTPBasicAuth

foo = post('http://natas0.natas.labs.overthewire.org', auth=HTTPBasicAuth('natas0', 'natas0'))

HTTP-Digest-Authentifizierung

Die HTTP-Digest-Authentifizierung erfolgt auf sehr ähnliche Weise. Requests bietet hierfür ein anderes Objekt:

from requests import post
from requests.auth import HTTPDigestAuth

foo = post('http://natas0.natas.labs.overthewire.org', auth=HTTPDigestAuth('natas0', 'natas0'))

Benutzerdefinierte Authentifizierung

In einigen Fällen reichen die integrierten Authentifizierungsmechanismen möglicherweise nicht aus. Stellen Sie sich folgendes Beispiel vor:

Ein Server ist so konfiguriert, dass er die Authentifizierung akzeptiert, wenn der Absender über die richtige Benutzeragentenzeichenfolge und einen bestimmten Header-Wert verfügt und die richtigen Anmeldeinformationen über die HTTP-Basisauthentifizierung bereitstellt. Um dies zu erreichen, muss eine benutzerdefinierte Authentifizierungsklasse erstellt werden, die AuthBase, die Basis für die Implementierung der Anforderungsauthentifizierung, darstellt:

from requests.auth import AuthBase
from requests.auth import _basic_auth_str
from requests._internal_utils import to_native_string

class CustomAuth(AuthBase):

    def __init__(self, secret_header, user_agent , username, password):
        # setup any auth-related data here
        self.secret_header =  secret_header
        self.user_agent = user_agent
        self.username = username
        self.password = password

    def __call__(self, r):
        # modify and return the request
        r.headers['X-Secret'] = self.secret_header
        r.headers['User-Agent'] = self.user_agent
        r.headers['Authorization'] = _basic_auth_str(self.username, self.password)
        
        return r

Dies kann dann mit dem folgenden Code verwendet werden:

foo = get('http://test.com/admin', auth=CustomAuth('SecretHeader', 'CustomUserAgent', 'user', 'password' ))

Proxies

Jeder Anforderungs-POST-Vorgang kann für die Verwendung von Netzwerk-Proxys konfiguriert werden

HTTP / S-Proxies

from requests import post

proxies = {
  'http': 'http://192.168.0.128:3128',
  'https': 'http://192.168.0.127:1080',
   }

foo = requests.post('http://httpbin.org/post', proxies=proxies)

Die HTTP-Basisauthentifizierung kann auf folgende Weise bereitgestellt werden:

proxies = {'http': 'http://user:[email protected]:312'}
foo = requests.post('http://httpbin.org/post', proxies=proxies)

SOCKS Proxies

Die Verwendung von Socken-Proxys erfordert Abhängigkeiten von Drittanbietern requests[socks] . Sobald Socken-Proxies installiert sind, werden sie auf ähnliche Weise wie HTTPBasicAuth verwendet:

proxies = {
'http': 'socks5://user:pass@host:port',
'https': 'socks5://user:pass@host:port'
}

foo = requests.post('http://httpbin.org/post', proxies=proxies)