Żądania to biblioteka HTTP, która zapewnia prostą funkcjonalność obsługi żądań / odpowiedzi HTTP w aplikacji internetowej. Biblioteka została opracowana w języku Python.

Oficjalna strona internetowa Python Requests dostępna pod adresem https://2.python-requests.org/en/master/ definiuje żądania w następujący sposób -

Requests to elegancka i prosta biblioteka HTTP dla Pythona, zbudowana dla ludzi.

Funkcje żądań

Funkcje żądań omówiono poniżej -

Żądanie

Biblioteka żądań Pythona zawiera łatwe w użyciu metody do obsługi żądań HTTP. Przekazywanie parametrów i obsługa typu żądania jak GET, POST, PUT, DELETE itp. Jest bardzo proste.

Odpowiedź

Możesz uzyskać odpowiedź w wymaganym formacie, a obsługiwane są format tekstowy, odpowiedź binarna, odpowiedź JSON i odpowiedź surowa.

Nagłówki

Biblioteka umożliwia czytanie, aktualizowanie lub wysyłanie nowych nagłówków zgodnie z wymaganiami.

Limity czasu

Limity czasu można łatwo dodać do żądanego adresu URL za pomocą biblioteki żądań Pythona. Zdarza się, że używasz zewnętrznego adresu URL i czekasz na odpowiedź.

Dobrą praktyką jest zawsze przekroczenie limitu czasu dla adresu URL, ponieważ możemy chcieć, aby w tym czasie adres URL odpowiadał z odpowiedzią lub błędem, który pojawia się z powodu przekroczenia limitu czasu. Jeśli tego nie zrobisz, będziesz musiał czekać na to żądanie w nieskończoność.

Obsługa błędów

Moduł żądań obsługuje obsługę błędów, a niektóre z nich to błąd połączenia, błędy przekroczenia czasu, błędy TooManyRedirects, błędy Response.raise_for_status itp.

Ciasteczka

Biblioteka umożliwia odczytywanie, zapisywanie i aktualizowanie żądanego adresu URL.

Sesje

Aby zachować dane, potrzebujesz sesji między żądaniami. Tak więc, jeśli ten sam host jest wywoływany wielokrotnie, możesz ponownie użyć połączenia TCP, co z kolei poprawi wydajność.

Certyfikaty SSL

Certyfikat SSL to funkcja bezpieczeństwa, która zawiera bezpieczne adresy URL. Gdy używasz żądań, weryfikuje również certyfikaty SSL dla podanego adresu URL https. Weryfikacja SSL jest domyślnie włączona w bibliotece żądań i zgłosi błąd, jeśli certyfikat nie jest obecny.

Poświadczenie

Uwierzytelnianie HTTP odbywa się po stronie serwera i żąda pewnych informacji uwierzytelniających, takich jak nazwa użytkownika i hasło, gdy klient żąda adresu URL. Jest to dodatkowe zabezpieczenie żądania i odpowiedzi wymienianej między klientem a serwerem.

Zalety korzystania z biblioteki żądań języka Python

Oto zalety korzystania z biblioteki żądań języka Python -

• Łatwy w użyciu i pobieraniu danych z podanego adresu URL.

• Biblioteka żądań może służyć do pobierania danych ze strony internetowej.

• Korzystając z żądań, możesz pobierać, publikować, usuwać, aktualizować dane dla podanego adresu URL.

• Obsługa plików cookie i sesji jest bardzo łatwa.

• O bezpieczeństwo dba również pomoc obsługi modułu uwierzytelniania.

W tym rozdziale będziemy pracować nad instalacją żądań. Aby rozpocząć pracę z modułem Requests, musimy najpierw zainstalować Pythona. Więc będziemy pracować nad następowaniem

• Zainstaluj Python
• Żądania instalacji

Instalowanie Pythona

Przejdź do oficjalnej strony Pythona: https://www.python.org/downloads/jak pokazano poniżej i kliknij najnowszą wersję dostępną dla systemów Windows, Linux / Unix i Mac OS. Pobierz Pythona zgodnie z 64- lub 32-bitowym systemem operacyjnym dostępnym u Ciebie.

Po pobraniu kliknij plik .exe i postępuj zgodnie z instrukcjami, aby zainstalować Pythona w systemie.

Menedżer pakietów Pythona, tj. Pip, zostanie również domyślnie zainstalowany podczas powyższej instalacji. Aby działał globalnie w systemie, dodaj bezpośrednio lokalizację języka python do zmiennej PATH. To samo jest pokazane na początku instalacji, aby pamiętać o zaznaczeniu pola wyboru DODAJ do ŚCIEŻKI. Jeśli zapomnisz to sprawdzić, wykonaj poniższe kroki, aby dodać do PATH.

Aby dodać do PATH, wykonaj następujące kroki:

Kliknij prawym przyciskiem myszy ikonę komputera i kliknij właściwości> Zaawansowane ustawienia systemu.

Wyświetli ekran, jak pokazano poniżej -

Kliknij Zmienne środowiskowe, jak pokazano powyżej. Wyświetli ekran, jak pokazano poniżej -

Wybierz ścieżkę i kliknij przycisk Edytuj, dodaj na końcu ścieżkę lokalizacji swojego Pythona. Teraz sprawdźmy wersję Pythona.

Sprawdzanie wersji Pythona

E:\prequests>python --version
Python 3.7.3

Żądania instalacji

Teraz, gdy mamy już zainstalowany Python, zamierzamy zainstalować Requests.

Po zainstalowaniu Pythona zostanie również zainstalowany menedżer pakietów Pythona, czyli pip. Poniżej znajduje się polecenie sprawdzania wersji pip.

E:\prequests>pip --version
pip 19.1.1 from c:\users\xxxxx\appdata\local\programs\python\python37\lib\site-p
ackages\pip (python 3.7)

Mamy zainstalowany pip, a wersja to 19.1.1. Teraz użyje pip do zainstalowania modułu Requests.

Polecenie podano poniżej -

pip install requests

E:\prequests>pip install requests
Requirement already satisfied: requests in c:\users\xxxx\appdata\local\programs
\python\python37\lib\site-packages (2.22.0)
Requirement already satisfied: certifi>=2017.4.17 in c:\users\kamat\appdata\loca
l\programs\python\python37\lib\site-packages (from requests) (2019.3.9)
Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in c:\use
rs\xxxxx\appdata\local\programs\python\python37\lib\site-packages (from requests
) (1.25.3)
Requirement already satisfied: idna<2.9,>=2.5 in c:\users\xxxxxxx\appdata\local\pr
ograms\python\python37\lib\site-packages (from requests) (2.8)
Requirement already satisfied: chardet<3.1.0,>=3.0.2 in c:\users\xxxxx\appdata\l
ocal\programs\python\python37\lib\site-packages (from requests) (3.0.4)

Mamy już zainstalowany moduł, więc w wierszu poleceń jest napisane Wymaganie już spełnione; gdyby nie został zainstalowany, ściągnąłby wymagane pakiety do instalacji.

Aby sprawdzić szczegóły zainstalowanego modułu żądań, możesz użyć następującego polecenia -

pip show requests
E:\prequests>pip show requests
Name: requests
Version: 2.22.0
Summary: Python HTTP for Humans.
Home-page: http://python-requests.org
Author: Kenneth Reitz
Author-email: [email protected]
License: Apache 2.0
Location: c:\users\xxxxx\appdata\local\programs\python\python37\lib\site-package
S
Requires: certifi, idna, urllib3, chardet
Required-by:

Wersja modułu Requests to 2.22.0.

Żądania Pythona to biblioteka HTTP, która pomoże nam wymieniać dane między klientem a serwerem. Weź pod uwagę, że masz interfejs użytkownika z formularzem, w którym musisz wprowadzić dane użytkownika, więc po jego wprowadzeniu musisz przesłać dane, które są niczym innym jak żądaniem Http POST lub PUT od klienta do serwera, aby zapisać dane.

Jeśli chcesz uzyskać dane, musisz je pobrać z serwera, co jest ponownie żądaniem HTTP GET. Wymiana danych między klientem, gdy żąda danych, a serwerem odpowiadającym wymaganymi danymi, ta relacja między klientem a serwerem jest bardzo ważna.

Żądanie jest kierowane na podany adres URL i może to być bezpieczny lub niezabezpieczony adres URL.

Żądanie do adresu URL można wykonać za pomocą GET, POST, PUT, DELETE. Najczęściej stosowana jest metoda GET, używana głównie wtedy, gdy chcesz pobrać dane z serwera.

Możesz również wysłać dane na adres URL jako ciąg zapytania, na przykład -

https://jsonplaceholder.typicode.com/users?id=9&username=Delphine

Więc tutaj przekazujemy id = 9 i username = Delphine do adresu URL. Wszystkie wartości są wysyłane w parze klucz / wartość po znaku zapytania (?), A wiele parametrów jest przekazywanych do adresu URL oddzielonych znakiem &.

Korzystając z biblioteki żądań, adres URL jest wywoływany w następujący sposób przy użyciu słownika ciągów.

W którym dane do adresu URL są wysyłane jako słownik ciągów. Jeśli chcesz przekazać id = 9 i username = Delphine, możesz wykonać następujące czynności:

payload = {'id': '9', 'username': 'Delphine'}

Biblioteka żądań jest wywoływana w następujący sposób -

res = requests.get('https://jsonplaceholder.typicode.com/users', params=payload')

Używając POST, możemy zrobić co następuje -

res = requests.post('https://jsonplaceholder.typicode.com/users', data = {'id':'9', 'username':'Delphine'})

Korzystanie z PUT

res = requests.put('https://jsonplaceholder.typicode.com/users', data = {'id':'9', 'username':'Delphine'})

Używanie DELETE

res = requests.delete('https://jsonplaceholder.typicode.com/users')

Odpowiedź z żądania HTTP może być zakodowana w formie tekstu, zakodowana binarnie, w formacie JSON lub w postaci nieprzetworzonej odpowiedzi. Szczegóły wniosku i odpowiedzi są szczegółowo wyjaśnione w następnych rozdziałach.

W tym rozdziale zrozumiemy, jak pracować z modułem wniosków. Przyjrzymy się następującemu:

• Wykonywanie żądań HTTP.
• Przekazywanie parametrów do żądań HTTP.

Wykonywanie żądań HTTP

Aby wykonać żądanie HTTP, musimy najpierw zaimportować moduł żądania, jak pokazano poniżej

import requests

Zobaczmy teraz, jak wywołać URL za pomocą modułu request.

Użyjmy adresu URL− https://jsonplaceholder.typicode.com/users w kodzie, aby przetestować moduł żądań.

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.status_code)

Adres url− https://jsonplaceholder.typicode.com/usersjest wywoływana za pomocą metody request.get (). Obiekt odpowiedzi adresu URL jest przechowywany w zmiennej getdata. Kiedy drukujemy zmienną, podaje kod odpowiedzi 200, co oznacza, że ​​otrzymaliśmy odpowiedź pomyślnie.

Wynik

E:\prequests>python makeRequest.py
<Response [200]>

Aby uzyskać treść odpowiedzi, możemy to zrobić za pomocą getdata.content jak pokazano poniżej -

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.content)

getdata.content, wypisze wszystkie dane dostępne w odpowiedzi.

Wynik

E:\prequests>python makeRequest.py
b'[\n {\n  "id": 1,\n  "name": "Leanne Graham",\n  "username": "Bret",\n
"email": "[email protected]",\n  "address": {\n  "street": "Kulas Light
",\n  "suite": "Apt. 556",\n  "city": "Gwenborough",\n  "zipcode": "
92998-3874",\n  "geo": {\n "lat": "-37.3159",\n  "lng": "81.149
6"\n }\n },\n  "phone": "1-770-736-8031 x56442",\n  "website": "hild
egard.org",\n  "company": {\n "name": "Romaguera-Crona",\n  "catchPhr
ase": "Multi-layered client-server neural-net",\n  "bs": "harness real-time
e-markets"\n }\n }

Przekazywanie parametrów do żądań HTTP

Samo żądanie adresu URL nie wystarczy, musimy również przekazać parametry do adresu URL.

Parametry są przeważnie przekazywane jako para klucz / wartość, na przykład -

 https://jsonplaceholder.typicode.com/users?id=9&username=Delphine

Mamy więc id = 9 i username = Delphine. Teraz zobaczymy, jak przekazać takie dane do modułu HTTP żądań.

Przykład

import requests
payload = {'id': 9, 'username': 'Delphine'}
getdata = requests.get('https://jsonplaceholder.typicode.com/users', params=payload)
print(getdata.content)

Szczegóły są przechowywane w ładunku obiektu w parze klucz / wartość i przekazywane do parametrów wewnątrz metody get ().

Wynik

E:\prequests>python makeRequest.py
b'[\n {\n "id": 9,\n "name": "Glenna Reichert",\n "username": "Delphin
e",\n "email": "[email protected]",\n "address": {\n "street":
"Dayna Park",\n "suite": "Suite 449",\n "city": "Bartholomebury",\n
"zipcode": "76495-3109",\n "geo": {\n "lat": "24.6463",\n
"lng": "-168.8889"\n }\n },\n "phone": "(775)976-6794 x41206",\n "
website": "conrad.com",\n "company": {\n "name": "Yost and Sons",\n
"catchPhrase": "Switchable contextually-based project",\n "bs": "aggregate
real-time technologies"\n }\n }\n]'

W odpowiedzi otrzymujemy teraz szczegóły id = 9 i username = Delphine.

Jeśli chcesz zobaczyć, jak wygląda adres URL po przekazaniu parametrów, wykorzystując obiekt odpowiedzi do adresu URL.

Przykład

import requests
payload = {'id': 9, 'username': 'Delphine'}
getdata = requests.get('https://jsonplaceholder.typicode.com/users', params=payload)
print(getdata.url)

Wynik

E:\prequests>python makeRequest.py
https://jsonplaceholder.typicode.com/users?id=9&username=Delphine

W tym rozdziale zajmiemy się bardziej szczegółami odpowiedzi otrzymanej z modułu zapytań. Omówimy następujące szczegóły -

• Uzyskiwanie odpowiedzi
• Odpowiedź JSON
• Odpowiedź RAW
• Odpowiedź binarna

Uzyskiwanie odpowiedzi

Zażądamy adresu URL za pomocą metody request.get ().

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users');

Getdata ma obiekt odpowiedzi. Zawiera wszystkie szczegóły odpowiedzi. Odpowiedź możemy uzyskać na dwa sposoby, używając (. Text ) i (. Content ). Użycie response.text zwróci dane w formacie tekstowym, jak pokazano poniżej

Przykład

E:\prequests>python makeRequest.py
[
 {
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
   }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered client-server neural-net",
   "bs": "harness real-time e-markets"
  }
},

Zobaczysz, że odpowiedź jest taka sama, jak wyglądałaby w przeglądarce po wyświetleniu źródła adresu URL, jak pokazano poniżej:

Możesz również wypróbować adres URL .html i zobaczyć zawartość za pomocą response.text, będzie taka sama, jak zawartość źródła przeglądania adresu URL .html w przeglądarce.

Teraz spróbujmy response.content dla tego samego adresu URL i zobaczmy wynik.

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.content)

Wynik

E:\prequests>python makeRequest.py
b'[\n {\n "id": 1,\n "name": "Leanne Graham",\n "username": "Bret",\n
"email": "[email protected]",\n "address": {\n "street": "Kulas Light
",\n "suite": "Apt. 556",\n "city": "Gwenborough",\n "zipcode": "
92998-3874",\n "geo": {\n "lat": "-37.3159",\n "lng": "81.149
6"\n }\n },\n "phone": "1-770-736-8031 x56442",\n "website": "hild
egard.org",\n "company": {\n "name": "Romaguera-Crona",\n "catchPhr
ase": "Multi-layered client-server neural-net",\n "bs": "harness real-time
e-markets"\n }\n },\n {\n "id": 2,\n "name": "Ervin Howell",\n "us
ername": "Antonette",\n "email": "[email protected]",\n "address": {\n
"street": "Victor Plains",\n "suite": "Suite 879",\n "city": "Wisoky
burgh",\n "zipcode": "90566-7771",\n "geo": {\n "lat": "-43.950
9",\n "lng": "-34.4618"\n }\n },\n "phone": "010-692-6593 x091
25",\n "website": "anastasia.net",\n "company": {\n "name": "Deckow-C
rist",\n "catchPhrase": "Proactive didactic contingency",\n "bs": "syn
ergize scalable supply-chains"\n }\n },\n {\n "id": 3,\n "name": "Cle
mentine Bauch",\n "username": "Samantha",\n "email":
"[email protected]",
\n "address": {\n "street": "Douglas Extension",\n "suite": "Suite
847",\n "city": "McKenziehaven",\n "zipcode": "59590-4157",\n "ge
o": {\n "lat": "-68.6102",\n "lng": "-47.0653"\n }\n },\n

Odpowiedź jest podawana w bajtach. Otrzymasz listbna początku odpowiedzi. Dzięki modułowi żądań możesz uzyskać używane kodowanie, a także zmienić kodowanie, jeśli jest to wymagane. Na przykład, aby uzyskać kodowanie, możesz użyć response.encoding.

print(getdata.encoding)

Wynik

utf-8

Możesz zmienić kodowanie w następujący sposób - Możesz użyć dowolnego kodowania.

getdata.encoding = 'ISO-8859-1'

Odpowiedź JSON

Możesz również uzyskać odpowiedź na żądanie HTTP w formacie json, używając metody response.json () w następujący sposób:

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.json())

Wynik

E:\prequests>python makeRequest.py
[{'id': 1, 'name': 'Leanne Graham', 'username': 'Bret', 'email': 'Sincere@april.
biz', 'address': {'street': 'Kulas Light', 'suite': 'Apt. 556', 'city': 'Gwenbor
ough', 'zipcode': '92998-3874', 'geo': {'lat': '-37.3159', 'lng': '81.1496'}},
'
phone': '1-770-736-8031 x56442', 'website': 'hildegard.org', 'company': {'name':
'Romaguera-Crona', 'catchPhrase': 'Multi-layered client-server neural-net', 'bs
': 'harness real-time e-markets'}}]

Odpowiedź RAW

Jeśli potrzebujesz nieprzetworzonej odpowiedzi na adres URL Http, możesz skorzystać z response.raw, również dodaj stream=True wewnątrz metody get, jak pokazano poniżej -

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users', stream=True)
print(getdata.raw)

Wynik

E:\prequests>python makeRequest.py
<urllib3.response.HTTPResponse object at 0x000000A8833D7B70>

Aby przeczytać więcej treści z surowych danych, możesz to zrobić w następujący sposób:

print(getdata.raw.read(50))

Wynik

E:\prequests>python makeRequest.py
b'\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03\x95\x98[o\xe38\x12\x85\xdf\xe7W\x10y\
xda\x01F\x82.\xd4m\x9f\xdc\x9dd\xba\xb7\x93\xf4\x06q\xef4\x06\x83A@K\x15\x89m'

Odpowiedź binarna

Aby uzyskać odpowiedź binarną, możemy skorzystać z response.content.

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.content)

Wynik

E:\prequests>python makeRequest.py
b'[\n {\n "id": 1,\n "name": "Leanne Graham",\n "username": "Bret",\n
"email": "[email protected]",\n "address": {\n "street": "Kulas Light
",\n "suite": "Apt. 556",\n "city": "Gwenborough",\n "zipcode": "
92998-3874",\n "geo": {\n "lat": "-37.3159",\n "lng": "81.149
6"\n }\n },\n "phone": "1-770-736-8031 x56442",\n "website": "hild
egard.org",\n "company": {\n "name": "Romaguera-Crona",\n "catchPhr
ase": "Multi-layered client-server neural-net",\n "bs": "harness real-time
e-markets"\n }\n },\n {\n "id": 2,\n "name": "Ervin Howell",\n "us
ername": "Antonette",\n "email": "[email protected]",\n "address": {\n
"street": "Victor Plains",\n "suite": "Suite 879",\n "city": "Wisoky
burgh",\n "zipcode": "90566-7771",\n "geo": {\n "lat": "-43.950
9",\n "lng": "-34.4618"\n }\n },\n "phone": "010-692-6593 x091
25",\n "website": "anastasia.net",\n "company": {\n "name": "Deckow-C
rist",\n "catchPhrase": "Proactive didactic contingency",\n "bs": "syn
ergize scalable supply-chains"\n }\n },\n {\n "id": 3,\n "name": "Cle
mentine Bauch",\n "username": "Samantha",\n "email": "[email protected]",
\n "address": {\n "street": "Douglas Extension",\n "suite": "Suite
847",\n "city": "McKenziehaven",\n "zipcode": "59590-4157",\n "ge
o": {\n "lat": "-68.6102",\n "lng": "-47.0653"\n }\n },\n

Odpowiedź jest podawana w bajtach. Otrzymasz listbna początku odpowiedzi. Odpowiedź binarna jest używana głównie w przypadku żądań nietekstowych.

Żądania - nagłówki żądań HTTP

W poprzednim rozdziale widzieliśmy, jak złożyć żądanie i uzyskać odpowiedź. W tym rozdziale omówimy nieco więcej sekcji nagłówka adresu URL. Więc przyjrzymy się następującemu:

• Zrozumienie nagłówków żądań
• Niestandardowe nagłówki
• Nagłówki odpowiedzi

Zrozumienie nagłówków żądań

Wybierz dowolny adres URL w przeglądarce, sprawdź go i sprawdź na karcie sieciowej narzędzia programisty.

Otrzymasz nagłówki odpowiedzi, nagłówki żądań, ładunek itp.

Na przykład rozważmy następujący adres URL−

https://jsonplaceholder.typicode.com/users

Możesz uzyskać szczegóły nagłówka w następujący sposób -

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users', stream=True)
print(getdata.headers)

Wynik

E:\prequests>python makeRequest.py
{'Date': 'Sat, 30 Nov 2019 05:15:00 GMT', 'Content-Type': 'application/json; cha
rset=utf-8', 'Transfer-Encoding': 'chunked', 'Connection': 'keep-alive', 'Set-Co
okie': '__cfduid=d2b84ccf43c40e18b95122b0b49f5cf091575090900; expires=Mon, 30-De
c-19 05:15:00 GMT; path=/; domain=.typicode.com; HttpOnly', 'X-Powered-By': 'Exp
ress', 'Vary': 'Origin, Accept-Encoding', 'Access-Control-Allow-Credentials': 't
rue', 'Cache-Control': 'max-age=14400', 'Pragma': 'no-cache', 'Expires': '-1', '
X-Content-Type-Options': 'nosniff', 'Etag': 'W/"160d-1eMSsxeJRfnVLRBmYJSbCiJZ1qQ
"', 'Content-Encoding': 'gzip', 'Via': '1.1 vegur', 'CF-Cache-Status': 'HIT', 'A
ge': '2271', 'Expect-CT': 'max-age=604800, report-uri="https://report-uri.cloudf
lare.com/cdn-cgi/beacon/expect-ct"', 'Server': 'cloudflare', 'CF-RAY': '53da574f
f99fc331-SIN'}

Aby przeczytać dowolny nagłówek http, możesz to zrobić w następujący sposób:

getdata.headers["Content-Encoding"] // gzip

Niestandardowe nagłówki

Możesz także wysłać nagłówki na wywoływany adres URL, jak pokazano poniżej.

Przykład

import requests
headers = {'x-user': 'test123'}
getdata = requests.get('https://jsonplaceholder.typicode.com/users', headers=headers)

Przekazywane nagłówki muszą być w formacie ciągów, bajtów lub Unicode. Zachowanie żądania nie zmieni się zgodnie z przekazanymi niestandardowymi nagłówkami.

Nagłówki odpowiedzi

Nagłówki odpowiedzi wyglądają jak poniżej, gdy sprawdzisz adres URL w narzędziu programisty przeglądarki, tab− sieci

Aby uzyskać szczegółowe informacje o nagłówkach z modułu żądań, użyj. Response.headers są takie, jak pokazano poniżej -

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.headers)

Wynik

E:\prequests>python makeRequest.py
{'Date': 'Sat, 30 Nov 2019 06:08:10 GMT', 'Content-Type': 'application/json; cha
rset=utf-8', 'Transfer-Encoding': 'chunked', 'Connection': 'keep-alive', 'Set-Co
okie': '__cfduid=de1158f1a5116f3754c2c353055694e0d1575094090; expires=Mon, 30-De
c-19 06:08:10 GMT; path=/; domain=.typicode.com; HttpOnly', 'X-Powered-By': 'Exp
ress', 'Vary': 'Origin, Accept-Encoding', 'Access-Control-Allow-Credentials': 't
rue', 'Cache-Control': 'max-age=14400', 'Pragma': 'no-cache', 'Expires': '-1', '
X-Content-Type-Options': 'nosniff', 'Etag': 'W/"160d-1eMSsxeJRfnVLRBmYJSbCiJZ1qQ
"', 'Content-Encoding': 'gzip', 'Via': '1.1 vegur', 'CF-Cache-Status': 'HIT', 'A
ge': '5461', 'Expect-CT': 'max-age=604800, report-uri="https://report-uri.cloudf
lare.com/cdn-cgi/beacon/expect-ct"', 'Server': 'cloudflare', 'CF-RAY': '53daa52f
3b7ec395-SIN'}

Możesz uzyskać dowolny nagłówek w następujący sposób -

print(getdata.headers["Expect-CT"])

Wynik

max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/exp
ect-ct

You can also get the header details by using the get() method.

print(getdata.headers.get("Expect-CT"))

Wynik

max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/exp
ect-ct

Żądania - obsługa żądań GET

W tym rozdziale skupimy się bardziej na żądaniach GET, które są najbardziej powszechne i często używane. Praca GET w module zgłoszeń jest bardzo prosta. Oto prosty przykład pracy z adresem URL przy użyciu metody GET.

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.content)
getdata.content, will print all the data available in the response.

Wynik

E:\prequests>python makeRequest.py
b'[\n {\n "id": 1,\n "name": "Leanne Graham",\n "username": "Bret",\n
"email": "[email protected]",\n "address": {\n "street": "Kulas Light
",\n "suite": "Apt. 556",\n "city": "Gwenborough",\n "zipcode": "
92998-3874",\n "geo": {\n "lat": "-37.3159",\n "lng": "81.149
6"\n }\n },\n "phone": "1-770-736-8031 x56442",\n "website": "hild
egard.org",\n "company": {\n "name": "Romaguera-Crona",\n "catchPhr
ase": "Multi-layered client-server neural-net",\n "bs": "harness real-time
e-markets"\n }\n }

Możesz także przekazać parametry do metody get, używając atrybutu param, jak pokazano poniżej

import requests
payload = {'id': 9, 'username': 'Delphine'}
getdata = requests.get('https://jsonplaceholder.typicode.com/users',
params=payload)
print(getdata.content)

Szczegóły są przechowywane w ładunku obiektu w parze klucz / wartość i przekazywane do parametrów wewnątrz metody get ().

Wynik

E:\prequests>python makeRequest.py
b'[\n {\n "id": 9,\n "name": "Glenna Reichert",\n "username": "Delphin
e",\n "email": "[email protected]",\n "address": {\n "street":
"Dayna Park",\n "suite": "Suite 449",\n "city": "Bartholomebury",\n
"zipcode": "76495-3109",\n "geo": {\n "lat": "24.6463",\n
"lng": "-168.8889"\n }\n },\n "phone": "(775)976-6794 x41206",\n "
website": "conrad.com",\n "company": {\n "name": "Yost and Sons",\n
"catchPhrase": "Switchable contextually-based project",\n "bs": "aggregate
real-time technologies"\n }\n }\n]'

Obsługa żądań POST, PUT, PATCH i DELETE

W tym rozdziale zrozumiemy, jak używać metody POST przy użyciu biblioteki request, a także przekazywać parametry do adresu URL.

Korzystanie z POST

W przypadku żądania PUT biblioteka Requests ma metodę request.post (), jej przykład pokazano poniżej:

żądania importu

myurl = 'https://postman-echo.com/post'
myparams = {'name': 'ABC', 'email':'[email protected]'}
res = requests.post(myurl, data=myparams)
print(res.text)

Wynik

E:\prequests>python makeRequest.py
{"args":{},"data":"","files":{},"form":{"name":"ABC","email":"[email protected]"},"headers":{"x-forwarded-proto":"https","host":"postman-echo.com","content-length":"30","accept":"*/*","accept-encoding":"gzip,deflate","content-type":"application/x-www-form-urlencoded","user-agent":"python-requests/2.22.0","x-forwarded-port":"443"},"json":{"name":"ABC","email":"[email protected]"},"url":"https://postman-echo.com/post"}

W powyższym przykładzie możesz przekazać dane formularza jako parę klucz-wartość do parametru danych wewnątrz request.post (). Zobaczymy również, jak pracować z modułem PUT, PATCH i DELETE w żądaniach.

Korzystanie z PUT

W przypadku żądania PUT biblioteka Requests ma metodę request.put (), której przykład pokazano poniżej.

import requests
myurl = 'https://postman-echo.com/put'
myparams = {'name': 'ABC', 'email':'[email protected]'}
res = requests.put(myurl, data=myparams)
print(res.text)

Wynik

E:\prequests>python makeRequest.py
{"args":{},"data":"","files":{},"form":{"name":"ABC","email":"[email protected]"},"h
eaders":{"x-forwarded-proto":"https","host":"postman-echo.com","content-length":
"30","accept":"*/*","accept-encoding":"gzip, deflate","content-type":"applicatio
n/x-www-form-urlencoded","user-agent":"python-requests/2.22.0","x-forwarded-port
":"443"},"json":{"name":"ABC","email":"[email protected]"},"url":"https://postman-ec ho.com/put"}

Korzystanie z PATCH

W przypadku żądania PATCH biblioteka Requests ma metodę request.patch (), której przykład pokazano poniżej.

import requests
myurl = https://postman-echo.com/patch'
res = requests.patch(myurl, data="testing patch")
print(res.text)

Wynik

E:\prequests>python makeRequest.py
{"args":{},"data":{},"files":{},"form":{},"headers":{"x-forwarded-proto":"https"
,"host":"postman-echo.com","content-length":"13","accept":"*/*","accept-encoding
":"gzip, deflate","user-agent":"python-requests/2.22.0","x-forwarded-port":"443"
},"json":null,"url":"https://postman-echo.com/patch"}

Używanie DELETE

W przypadku żądania DELETE biblioteka Requests ma metodę request.delete (), której przykład pokazano poniżej.

import requests
myurl = 'https://postman-echo.com/delete'
res = requests.delete(myurl, data="testing delete")
print(res.text)

Wynik

E:\prequests>python makeRequest.py
{"args":{},"data":{},"files":{},"form":{},"headers":{"x-forwarded-proto":"https"
,"host":"postman-echo.com","content-length":"14","accept":"*/*","accept-encoding
":"gzip, deflate","user-agent":"python-requests/2.22.0","x-forwarded-port":"443"
},"json":null,"url":"https://postman-echo.com/delete"}

Żądania - przesyłanie plików

W tym rozdziale załadujemy plik za pomocą request i przeczytamy zawartość przesłanego pliku. Możemy to zrobić za pomocąfiles param, jak pokazano w poniższym przykładzie.

Będziemy używać http://httpbin.org/opublikuj, aby przesłać plik.

Przykład

import requests
myurl = 'https://httpbin.org/post'
files = {'file': open('test.txt', 'rb')}
getdata = requests.post(myurl, files=files)
print(getdata.text)

Test.txt

File upload test using Requests

Przykład

var total = [0, 1, 2, 3].reduceRight(function(a, b){ return a + b; }); 
console.log("total is : " + total );

Wynik

E:\prequests>python makeRequest.py
{
  "args": {},
  "data": "",
  "files": {
   "file": "File upload test using Requests"
  },
  "form": {},
  "headers": {
   "Accept": "*/*",
   "Accept-Encoding": "gzip, deflate",
   "Content-Length": "175",
   "Content-Type": "multipart/form-data; 
boundary=28aee3a9d15a3571fb80d4d2a94bf
d33",
   "Host": "httpbin.org",
   "User-Agent": "python-requests/2.22.0"
  },
  "json": null,
  "origin": "117.223.63.135, 117.223.63.135",
  "url": "https://httpbin.org/post"
}

Możliwe jest również przesłanie zawartości pliku, jak pokazano poniżej -

Przykład

import requests
myurl = 'https://httpbin.org/post'
files = {'file': ('test1.txt', 'Welcome to TutorialsPoint')}
getdata = requests.post(myurl, files=files)
print(getdata.text)

Wynik

E:\prequests>python makeRequest.py
{
  "args": {},
  "data": "",
  "files": {
   "file": "Welcome to TutorialsPoint"
},
"form": {},
"headers": {
   "Accept": "*/*",
   "Accept-Encoding": "gzip, deflate",
   "Content-Length": "170",
   "Content-Type": "multipart/form-data; boundary=f2837238286fe40e32080aa7e172b
e4f",
  "Host": "httpbin.org",
  "User-Agent": "python-requests/2.22.0"
},
  "json": null,
  "origin": "117.223.63.135, 117.223.63.135",
  "url": "https://httpbin.org/post"
}

Żądania - praca z plikami cookie

W tym rozdziale omówimy, jak postępować z plikami cookie. Możesz pobrać pliki cookie, a także wysłać je podczas wywoływania adresu URL za pomocą biblioteki żądań.

Adres URL, https://jsonplaceholder.typicode.com/users po wejściu w przeglądarkę możemy uzyskać szczegółowe informacje o plikach cookie, jak pokazano poniżej

Możesz przeczytać pliki cookie, jak pokazano poniżej

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users')
print(getdata.cookies["__cfduid"])

Wynik

E:\prequests>python makeRequest.py
d1733467caa1e3431fb7f768fa79ed3741575094848

Możesz również wysyłać pliki cookie, gdy wysyłamy żądanie.

Przykład

import requests
cookies = dict(test='test123')
getdata = requests.get('https://httpbin.org/cookies',cookies=cookies)
print(getdata.text)

Wynik

E:\prequests>python makeRequest.py
{
   "cookies": {
   "test": "test123"
}
}

Żądania - praca z błędami

W tym rozdziale omówimy, jak radzić sobie z błędami pojawiającymi się podczas pracy z biblioteką żądań HTTP. Zawsze dobrze jest zarządzać błędami we wszystkich możliwych przypadkach.

Wyjątek błędu

Moduł żądań podaje następujące typy wyjątków błędów:

ConnectionError- To zostanie podniesione, jeśli wystąpi jakikolwiek błąd połączenia. Na przykład niepowodzenie sieci, błąd DNS, więc biblioteka Request zgłosi wyjątek ConnectionError.

Response.raise_for_status()- Na podstawie kodu statusu, tj. 401, 404, zgłosi błąd HTTPError dla żądanego adresu URL.

HTTPError- Ten błąd zostanie zgłoszony w przypadku nieprawidłowej odpowiedzi przychodzącej na wysłane żądanie.

Timeout- Błędy zgłoszone z powodu przekroczenia limitu czasu dla żądanego adresu URL.

TooManyRedirects- Jeśli limit zostanie przekroczony dla maksymalnej liczby przekierowań, spowoduje to błąd TooManyRedirects.

Przykład

Oto przykład błędów pokazanych dla timeout−

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users',timeout=0.001)
print(getdata.text)

Wynik

raise ConnectTimeout(e, request=request)
requests.exceptions.ConnectTimeout: HTTPSConnectionPool(host='jsonplaceholder.ty
picode.com', port=443): Max retries exceeded with url: /users (Caused by Connect
TimeoutError(<urllib3.connection.VerifiedHTTPSConnection object at
0x000000B02AD
E76A0>, 'Connection to jsonplaceholder.typicode.com timed out. (connect timeout= 0.001)'))

Żądania - obsługa limitów czasu

Limity czasu można łatwo dodać do żądanego adresu URL. Tak się składa, że ​​używasz zewnętrznego adresu URL i czekasz na odpowiedź. Dobrą praktyką jest zawsze przekroczenie limitu czasu w adresie URL, ponieważ możemy chcieć, aby adres URL odpowiadał w określonym czasie z odpowiedzią lub błędem. Nie zrobienie tego może spowodować oczekiwanie na to żądanie w nieskończoność.

Możemy nadać adresowi URL limit czasu, używając parametru limitu czasu, a wartość jest przekazywana w sekundach, jak pokazano w poniższym przykładzie.

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users',timeout=0.001)
print(getdata.text)

Wynik

raise ConnectTimeout(e, request=request)
requests.exceptions.ConnectTimeout: HTTPSConnectionPool(host='jsonplaceholder.ty
picode.com', port=443): Max retries exceeded with url: /users (Caused by Connect
TimeoutError(<urllib3.connection.VerifiedHTTPSConnection object at 0x000000B02AD
E76A0>, 'Connection to jsonplaceholder.typicode.com timed out. (connect timeout=
0.001)'))

Podany limit czasu jest następujący: -

getdata = requests.get('https://jsonplaceholder.typicode.com/users',timeout=0.001)

Wykonanie zgłasza błąd przekroczenia limitu czasu połączenia, jak pokazano w danych wyjściowych. Podany limit czasu wynosi 0,001, co nie jest możliwe dla żądania odzyskania odpowiedzi i generuje błąd. Teraz zwiększymy limit czasu i sprawdzimy.

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users',timeout=1.000)
print(getdata.text)

Wynik

E:\prequests>python makeRequest.py
[
 {
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
   }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered client-server neural-net",
   "bs": "harness real-time e-markets"
 }

Po przekroczeniu limitu czasu 1 sekundy możemy uzyskać odpowiedź na żądany adres URL.

Żądania - obsługa przekierowań

W tym rozdziale przyjrzymy się, jak biblioteka żądań obsługuje przypadek przekierowania adresu URL.

Przykład

import requests
getdata = requests.get('http://google.com/')
print(getdata.status_code)
print(getdata.history)

Adres url− http://google.com zostanie przekierowany przy użyciu kodu stanu 301 (przeniesiony na stałe) do https://www.google.com/. Przekierowanie zostanie zapisane w historii.

Wynik

Kiedy powyższy kod jest wykonywany, otrzymujemy następujący wynik -

E:\prequests>python makeRequest.py
200
[<Response [301]>]

Możesz zatrzymać przekierowanie adresu URL za pomocą allow_redirects=False. Można to zrobić na zastosowanych metodach GET, POST, OPTIONS, PUT, DELETE, PATCH.

Przykład

Oto przykład tego samego.

import requests
getdata = requests.get('http://google.com/', allow_redirects=False)
print(getdata.status_code)
print(getdata.history)
print(getdata.text)

Jeśli teraz sprawdzisz dane wyjściowe, przekierowanie nie będzie dozwolone i otrzyma kod stanu 301.

Wynik

E:\prequests>python makeRequest.py
301
[]
<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">
<TITLE>301 Moved</TITLE></HEAD><BODY>
<H1>301 Moved</H1>
The document has moved
<A HREF="http://www.google.com/">here</A>.
</BODY></HTML>

Żądania - historia obsługi

Możesz uzyskać historię podanego adresu URL za pomocą response.history. Jeśli podany adres URL ma przekierowania, to samo zostanie zapisane w historii.

Do historii

import requests
getdata = requests.get('http://google.com/')
print(getdata.status_code)
print(getdata.history)

Wynik

E:\prequests>python makeRequest.py
200
[<Response [301]>]

Plik response.historywłaściwość będzie zawierała szczegóły obiektów odpowiedzi, które zostały wykonane na podstawie żądania. Obecne wartości zostaną posortowane od najstarszych do najnowszych. Plikresponse.history właściwość śledzi wszystkie przekierowania wykonane na żądanym adresie URL.

Żądania - obsługa sesji

Aby zachować dane między żądaniami, potrzebujesz sesji. Tak więc, jeśli ten sam host jest wywoływany wielokrotnie, możesz ponownie użyć połączenia TCP, co z kolei poprawi wydajność. Zobaczmy teraz, jak zachować pliki cookie w przypadku żądań wysyłanych za pomocą sesji.

Dodawanie plików cookies za pomocą sesji

import requests
req = requests.Session()
cookies = dict(test='test123')
getdata = req.get('https://httpbin.org/cookies',cookies=cookies)
print(getdata.text)

Wynik

E:\prequests>python makeRequest.py
{
   "cookies": {
   "test": "test123"
}
}

Korzystając z sesji, możesz zachować dane plików cookie na wszystkie żądania. Możliwe jest również przekazanie danych nagłówka za pomocą sesji, jak pokazano poniżej

Przykład

import requests
req = requests.Session()
req.headers.update({'x-user1': 'ABC'})
headers = {'x-user2': 'XYZ'}
getdata = req.get('https://httpbin.org/headers', headers=headers)    
print(getdata.headers)

Żądania - certyfikat SSL

Certyfikat SSL to funkcja bezpieczeństwa, która zawiera bezpieczne adresy URL. Kiedy używasz biblioteki Requests, weryfikuje ona również certyfikaty SSL dla podanego adresu URL https. Weryfikacja SSL jest domyślnie włączona w module żądań i zgłosi błąd, jeśli certyfikat nie jest obecny.

Praca z bezpiecznym adresem URL

Poniżej znajduje się przykład pracy z bezpiecznym adresem URL−

import requests
getdata = requests.get(https://jsonplaceholder.typicode.com/users)
print(getdata.text)

Wynik

E:\prequests>python makeRequest.py
[
   {
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
   }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered client-server neural-net",
   "bs": "harness real-time e-markets"
   }
  }
]

Łatwo otrzymujemy odpowiedź z powyższego adresu URL https, a to dlatego, że moduł żądania może zweryfikować certyfikat SSL.

Możesz wyłączyć weryfikację SSL, po prostu dodając weryfikację = False, jak pokazano w poniższym przykładzie.

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users', verify=False)
print(getdata.text)

Otrzymasz dane wyjściowe, ale otrzymasz również ostrzeżenie, że certyfikat SSL nie został zweryfikowany i zaleca się dodanie weryfikacji certyfikatu.

Wynik

E:\prequests>python makeRequest.py
connectionpool.py:851: InsecureRequestWarning: Unverified HTTPS request is being
made. Adding certificate verification is strongly advised. See: https://urllib3
   .readthedocs.io/en/latest/advanced-usage.htm  l#ssl-warnings
 InsecureRequestWarning)
[
 {
  "id": 1,
   "name": "Leanne Graham",
   "username": "Bret", 
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
   }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered   client-server neural-net",
   "bs": "harness real-time e-markets"
  }
 }
]

Możesz również zweryfikować certyfikat SSL, umieszczając go na swoim końcu i podając ścieżkę za pomocą verify param, jak pokazano poniżej.

Przykład

import requests
getdata = requests.get('https://jsonplaceholder.typicode.com/users', verify='C:\Users\AppData\Local\certificate.txt')
print(getdata.text)

Wynik

E:\prequests>python makeRequest.py
[
  {
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
   }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered   client-server neural-net",
   "bs": "harness real-time e-markets"
   }
  }
]

Żądania - uwierzytelnianie

W tym rozdziale omówimy typy uwierzytelniania dostępne w module Żądania.

Omówimy następujące:

• Praca z uwierzytelnianiem w żądaniach HTTP

• Uwierzytelnianie podstawowe

• Uwierzytelnianie Digest

• Uwierzytelnianie OAuth2

Praca z uwierzytelnianiem w żądaniach HTTP

Uwierzytelnianie HTTP odbywa się po stronie serwera i żąda pewnych informacji uwierzytelniających, takich jak nazwa użytkownika i hasło, gdy klient żąda adresu URL. Jest to dodatkowe zabezpieczenie żądania i odpowiedzi wymienianej między klientem a serwerem.

Po stronie klienta te dodatkowe informacje uwierzytelniające, tj. Nazwa użytkownika i hasło, mogą być przesłane w nagłówkach, które później po stronie serwera zostaną sprawdzone. Odpowiedź zostanie dostarczona po stronie serwera tylko wtedy, gdy uwierzytelnienie jest prawidłowe.

Biblioteka żądań ma najczęściej używane uwierzytelnianie w request.auth , czyli uwierzytelnianiu podstawowym ( HTTPBasicAuth ) i uwierzytelnianiu szyfrowanym ( HTTPDigestAuth ).

Uwierzytelnianie podstawowe

To najprostsza forma uwierzytelnienia serwera. Do pracy z uwierzytelnianiem podstawowym będziemy korzystać z klasy HTTPBasicAuth dostępnej z biblioteką requestów.

Przykład

Oto działający przykład, jak go używać.

import requests
from requests.auth import HTTPBasicAuth
response_data = requests.get('httpbin.org/basic-auth/admin/admin123', auth=HTTPDigestAuth('admin', 'admin123'))
print(response_data.text)

Wzywamy adres URL, https://httpbin.org/basic-auth/admin/admin123z użytkownikiem jako admin i hasłem jako admin123 .

Tak więc ten adres URL nie będzie działał bez uwierzytelnienia, tj. Użytkownika i hasła. Gdy podasz uwierzytelnienie przy użyciu parametru autoryzacji, tylko serwer zwróci odpowiedź.

Wynik

E:\prequests>python makeRequest.py
{
   "authenticated": true,
   "user": "admin"
}

Uwierzytelnianie Digest

To kolejna forma uwierzytelniania dostępna przy żądaniach. Zamierzamy wykorzystać klasę HTTPDigestAuth z żądań.

Przykład

import requests
from requests.auth import HTTPDigestAuth
response_data = requests.get('https://httpbin.org/digest-auth/auth/admin/admin123>, auth=HTTPDigestAuth('admin', 'admin123'))
print(response_data.text)

Wynik

E:\prequests>python makeRequest.py
{
   "authenticated": true,
   "user": "admin"
}

Uwierzytelnianie OAuth2

Aby korzystać z uwierzytelniania OAuth2, potrzebujemy biblioteki „request_oauth2”. Aby zainstalować „request_oauth2” wykonaj następujące czynności -

pip install requests_oauth2

Wyświetlacz w terminalu podczas instalacji będzie wyglądał tak, jak pokazano poniżej

E:\prequests>pip install requests_oauth2
Collecting requests_oauth2
Downloading https://files.pythonhosted.org/packages/52/dc/01c3c75e6e7341a2c7a9
71d111d7105df230ddb74b5d4e10a3dabb61750c/requests-oauth2-0.3.0.tar.gz
Requirement already satisfied: requests in c:\users\xyz\appdata\local\programs
\python\python37\lib\site-packages (from requests_oauth2) (2.22.0)
Requirement already satisfied: six in c:\users\xyz\appdata\local\programs\pyth
on\python37\lib\site-packages (from requests_oauth2) (1.12.0)
Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in c:\use
rs\xyz\appdata\local\programs\python\python37\lib\site-packages (from requests
->requests_oauth2) (1.25.3)
Requirement already satisfied: certifi>=2017.4.17 in c:\users\xyz\appdata\loca
l\programs\python\python37\lib\site-packages (from requests->requests_oauth2) (2
019.3.9)
Requirement already satisfied: chardet<3.1.0,>=3.0.2 in c:\users\xyz\appdata\l
ocal\programs\python\python37\lib\site-packages (from requests->requests_oauth2)
(3.0.4)
Requirement already satisfied: idna<2.9,>=2.5 in c:\users\xyz\appdata\local\pr
ograms\python\python37\lib\site-packages (from requests->requests_oauth2) (2.8)
Building wheels for collected packages: requests-oauth2
Building wheel for requests-oauth2 (setup.py) ... done
Stored in directory: C:\Users\xyz\AppData\Local\pip\Cache\wheels\90\ef\b4\43
3743cbbc488463491da7df510d41c4e5aa28213caeedd586
Successfully built requests-oauth2

Skończyliśmy instalować „request-oauth2”. Aby korzystać z API Google, Twittera potrzebujemy jego zgody i to samo dzieje się z wykorzystaniem uwierzytelniania OAuth2.

Do uwierzytelnienia OAuth2 będziemy potrzebować identyfikatora klienta i tajnego klucza. Szczegóły, jak to zdobyć, są wymienione nahttps://developers.google.com/identity/protocols/OAuth2.

Później zaloguj się do konsoli Google API, która jest dostępna pod adresem https://console.developers.google.com/i uzyskaj identyfikator klienta i tajny klucz.

Przykład

Oto przykład użycia „request-oauth2”.

import requests
from requests_oauth2.services import GoogleClient
google_auth = GoogleClient(
   client_id="xxxxxxxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com",
redirect_uri="http://localhost/auth/success.html",
)
a = google_auth.authorize_url(
   scope=["profile", "email"],
   response_type="code",
)
res = requests.get(a)
print(res.url)

Nie będziemy mogli przekierować na podany adres URL, ponieważ wymaga zalogowania się na konto Gmail, ale tutaj zobaczysz z przykładu, że google_auth działa i podany jest autoryzowany adres URL.

Wynik

E:\prequests>python oauthRequest.py
https://accounts.google.com/o/oauth2/auth?redirect_uri=
http%3A%2F%2Flocalhost%2Fauth%2Fsuccess.html&
client_id=xxxxxxxxxxxxxxxxxxxxx.apps.googleusercontent.com&
scope=profile+email&response_type=code

Żądania - haki zdarzeń

Możemy dodawać zdarzenia do żądanego adresu URL za pomocą haków zdarzeń. W poniższym przykładzie dodamy funkcję zwrotną, która zostanie wywołana, gdy odpowiedź będzie dostępna.

Przykład

Aby dodać wywołanie zwrotne, musimy skorzystać z parametru hooks, jak pokazano na poniższym przykładzie

mport requests
def printData(r, *args, **kwargs):
   print(r.url)
   print(r.text)
getdata = requests.get('https://jsonplaceholder.typicode.com/users', 
hooks={'response': printData})

Wynik

E:\prequests>python makeRequest.py
https://jsonplaceholder.typicode.com/users
[
{
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
    "lat": "-37.3159",
    "lng": "81.1496"
   }
  }, 
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered client-server neural-net",
   "bs": "harness real-time e-markets"
   }
  }
]

Możesz także wywołać wiele funkcji zwrotnych, jak pokazano poniżej

Przykład

import requests
def printRequestedUrl(r, *args, **kwargs):
   print(r.url)
def printData(r, *args, **kwargs):
   print(r.text)
getdata = requests.get('https://jsonplaceholder.typicode.com/users', hooks={'response': [printRequestedUrl, printData]})

Wynik

E:\prequests>python makeRequest.py
https://jsonplaceholder.typicode.com/users
[
  {
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
 }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered client-server neural-net",
    "bs": "harness real-time e-markets"
   }
  }
]

Możesz także dodać podpięcie do utworzonej sesji, jak pokazano poniżej

Przykład

import requests
def printData(r, *args, **kwargs):
print(r.text)
s = requests.Session()
s.hooks['response'].append(printData)
s.get('https://jsonplaceholder.typicode.com/users')

Wynik

E:\prequests>python makeRequest.py
[
 {
   "id": 1,
   "name": "Leanne Graham",
   "username": "Bret",
   "email": "[email protected]",
   "address": {
   "street": "Kulas Light",
   "suite": "Apt. 556",
   "city": "Gwenborough",
   "zipcode": "92998-3874",
   "geo": {
   "lat": "-37.3159",
   "lng": "81.1496"
   }
  },
   "phone": "1-770-736-8031 x56442",
   "website": "hildegard.org",
   "company": {
   "name": "Romaguera-Crona",
   "catchPhrase": "Multi-layered client-server neural-net",
   "bs": "harness real-time e-markets"
   }
  }
]

Żądania - pełnomocnik

Do tej pory widzieliśmy, jak klienci bezpośrednio łączą się i rozmawiają z serwerem. Za pomocą proxy interakcja przebiega następująco:

• Klient wysyła żądanie do proxy.

• Proxy wysyła żądanie do serwera.

• Serwer odsyła odpowiedź do serwera proxy.

• Serwer proxy odeśle odpowiedź z powrotem do klienta.

Korzystanie z Http-proxy jest dodatkowym zabezpieczeniem przypisanym do zarządzania wymianą danych między klientem a serwerem. Biblioteki żądań mają również możliwość obsługi proxy, używając parametrów proxy, jak pokazano poniżej

Przykład

import requests
proxies = {
'http': 'http://localhost:8080'
}
res = requests.get('http://httpbin.org/', proxies=proxies)
print(res.status_code)

Żądanie będzie kierowane do ('http://localhost:8080 URL.

Wynik

200

Żądania - przeglądanie sieci przy użyciu żądań

Widzieliśmy już, jak możemy uzyskać dane z podanego adresu URL za pomocą biblioteki żądań Pythona. Postaramy się wyrzucić dane z witrynyTutorialspoint który jest dostępny pod adresem https://www.tutorialspoint.com/tutorialslibrary.htm używając następującego -

• Biblioteka żądań

• Piękna biblioteka zup od Pythona

Zainstalowaliśmy już bibliotekę Requests, zainstalujmy teraz pakiet Beautiful soup. Oto oficjalna strona internetowabeautiful soup dostępne o https://www.crummy.com/software/BeautifulSoup/bs4/doc/ jeśli chcesz poznać więcej funkcji pięknej zupy.

Instalowanie Beautifulsoup

Poniżej zobaczymy, jak zainstalować Beautiful Soup

E:\prequests>pip install beautifulsoup4
Collecting beautifulsoup4
Downloading https://files.pythonhosted.org/packages/3b/c8/a55eb6ea11cd7e5ac4ba
cdf92bac4693b90d3ba79268be16527555e186f0/beautifulsoup4-4.8.1-py3-none-any.whl (
101kB)
|████████████████████████████████| 102kB 22kB/s
Collecting soupsieve>=1.2 (from beautifulsoup4)
Downloading https://files.pythonhosted.org/packages/81/94/03c0f04471fc245d08d0
a99f7946ac228ca98da4fa75796c507f61e688c2/soupsieve-1.9.5-py2.py3-none-any.whl
Installing collected packages: soupsieve, beautifulsoup4
Successfully installed beautifulsoup4-4.8.1 soupsieve-1.9.5

Mamy teraz zainstalowaną bibliotekę żądań Pythona i piękną zupę.

Napiszmy teraz kod, który usunie dane z podanego adresu URL.

Skrobanie sieci

import requests
from bs4 import BeautifulSoup
res = requests.get('https://www.tutorialspoint.com/tutorialslibrary.htm')
print("The status code is ", res.status_code)
print("\n")
soup_data = BeautifulSoup(res.text, 'html.parser')
print(soup_data.title)
print("\n")
print(soup_data.find_all('h4'))

Korzystając z biblioteki żądań, możemy pobrać zawartość z podanego adresu URL, a piękna biblioteka zup pomaga ją przeanalizować i pobrać szczegóły tak, jak chcemy.

Możesz użyć pięknej biblioteki zup do pobierania danych za pomocą tagu HTML, klasy, identyfikatora, selektora css i wielu innych sposobów. Poniżej znajduje się wynik, w którym wydrukowaliśmy tytuł strony, a także wszystkie tagi h4 na stronie.

Wynik

E:\prequests>python makeRequest.py
The status code is 200
<title>Free Online Tutorials and Courses</title>
[<h4>Academic</h4>, <h4>Computer Science</h4>, <h4>Digital Marketing</h4>, <h4>M
onuments</h4>,<h4>Machine Learning</h4>, <h4>Mathematics</h4>, <h4>Mobile Devel
opment</h4>,<h4>SAP</h4>, <h4>Software Quality</h4>, <h4>Big Data & Analyti
cs</h4>, <h4>Databases</h4>, <h4>Engineering Tutorials</h4>, <h4>Mainframe Devel
opment</h4>, <h4>Microsoft Technologies</h4>, <h4>Java Technologies</h4>,<h4>XM
L Technologies</h4>, <h4>Python Technologies</h4>, <h4>Sports</h4>, <h4>Computer
Programming</h4>,<h4>DevOps</h4>, <h4>Latest Technologies</h4>, <h4>Telecom</h4>, <h4>Exams Syllabus</h4>, <h4>UPSC IAS Exams</h4>, <h4>Web Development</h4>,
<h4>Scripts</h4>, <h4>Management</h4>,<h4>Soft Skills</h4>, <h4>Selected Readin
g</h4>, <h4>Misc</h4>]