Python Language
Python begär inlägg

Introduktion

Enkel post

from requests import post

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

Kommer att utföra en enkel HTTP POST-operation. Inlagda data kan vara inmost format, men nyckelvärdespar är mest utbredda.

rubriker

Rubriker kan visas:

print(foo.headers)

Ett exempel svar:

{'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'}

Rubriker kan också förberedas före inlägg:

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'})

kodning

Kodning kan ställas in och visas på ungefär samma sätt:

 print(foo.encoding)

'utf-8'

foo.encoding = 'ISO-8859-1'

SSL-verifiering

Begäranden validerar som standard SSL-certifikat för domäner. Detta kan åsidosättas:

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

Omdirigering

Alla omdirigeringar följs (t.ex. http till https), detta kan också ändras:

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

Om postoperationen har omdirigerats kan det här värdet nås:

print(foo.url) 

En fullständig historik med omdirigeringar kan ses:

print(foo.history) 

Formulär kodad data

from requests import post

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

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

För att skicka formkodad data med postoperationen måste data struktureras som ordbok och levereras som dataparameter.

Om data inte vill formkodas, överför bara en sträng eller heltal till dataparametern.

Leverera ordboken till json-parametern för Begäran om att formatera data automatiskt:

from requests import post

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

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

Filuppladdning

Med förfrågningsmodulen är det bara nödvändigt att tillhandahålla ett filhandtag i motsats till innehållet som hämtats med .read() :

from requests import post

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

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

Filnamn, content_type och rubriker kan också ställas in:

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

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

Strängar kan också skickas som en fil, så länge de levereras som files parameter.

Flera filer

Flera filer kan levereras på ungefär samma sätt som en fil:

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)

Svar

Svarskoder kan ses från en postoperation:

from requests import post

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

Returnerade data

Åtkomst till data som returneras:

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

Rå svar

I de fall där du behöver åtkomst till det underliggande urllib3-svaret. HTTP-svar-objekt kan detta göras på följande sätt:

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

print(res.read())

autentisering

Enkel HTTP-autentisering

Enkel HTTP-autentisering kan uppnås med följande:

from requests import post

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

Detta är tekniskt kort hand för följande:

from requests import post
from requests.auth import HTTPBasicAuth

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

HTTP Digest Authentication

HTTP Digest Authentication görs på ett mycket liknande sätt, Requests ger ett annat objekt för detta:

from requests import post
from requests.auth import HTTPDigestAuth

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

Anpassad autentisering

I vissa fall kanske de inbyggda autentiseringsmekanismerna inte räcker, föreställ dig detta exempel:

En server är konfigurerad för att acceptera autentisering om avsändaren har rätt användaragentsträng, ett visst rubrikvärde och tillhandahåller korrekt referens via HTTP Basic Authentication. För att uppnå detta bör en anpassad autentiseringsklass utarbetas, underklassificering av AuthBase, som är basen för begärda autentiseringsimplementeringar:

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

Detta kan sedan användas med följande kod:

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

Ombud

Varje förfrågan POST-operation kan konfigureras för att använda nätverksproxy

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)

HTTP-grundläggande autentisering kan tillhandahållas på detta sätt:

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

SOCKS Proxies

Användning av strumpeproxies kräver requests[socks] tredje part beroende requests[socks] , när installerade strumpeproxies används på ett mycket liknande sätt som HTTPBasicAuth:

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

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