Request Library Dengan Python
Permintaan Library Dengan Python.
Library Permintaan digunakan untuk membuat permintaan ke situs web HTTP/titik akhir API.
Dengan menggunakan Library permintaan, kita dapat membuat permintaan ke URL, mendapatkan informasi situs web seperti Konten HTML, mengunduh gambar, melakukan otentikasi untuk keperluan login dan pengisian formulir.
• Instal paket Packages
Masukkan perintah berikut di terminal untuk menginstal paket permintaan.
Perintahnya sama untuk sistem operasi Windows dan Mac.
pip install requests
Setelah paket permintaan diunduh dan diinstal, kita dapat mengimpor modul ke dalam program kita menggunakan import kata kunci.
Untuk memeriksa versi paket permintaan yang terinstal, kita dapat menggunakan .__version__ metode ini.
import requests
print(requests.__version__)
# Output
2.26.0
• Jenis Requests
Modul Permintaan menggunakan metode bawaan HTTP untuk melakukan tindakan tertentu di server.
Berbagai Tindakan seperti mengambil data, menambah data, menghapus data, dll., dapat dilakukan.
Klien dapat mengakses data di server menggunakan metode permintaan yang berbeda seperti:
- GET
- POST
- PUT
- DELETE
- PATCH
- HEAD
• GET Requests
GET Requests adalah salah satu metode HTTP yang digunakan untuk meminta data dari server.
Data akan diambil dari URL yang kita lewati ke metode GET.
Sintaks untuk membuat permintaan GET diberikan di bawah ini:
response = requests.get(URL)
Mari kita coba melakukan permintaan GET di
https://www.blog-gan.org , dan menganalisis respons yang diambil menggunakan permintaan GET.
import requests
response = requests.get('https://www.blog-gan.org/')
Setelah kami membuat permintaan di server, ia mengembalikan respons dan objek respons memiliki beberapa properti yang dapat membantu kami memahami data yang diambil.
Kita dapat melihat properti dari objek respon ini menggunakan dir() metode.
Setelah kita membuat permintaan di server, ia mengembalikan respons dan objek respons memiliki beberapa properti yang dapat membantu kita memahami data yang diambil.
Kita dapat melihat properti dari objek respon ini menggunakan dir() metode.
dir(response)
Di antara semua properti, properti yang paling sering digunakan tercantum di bawah ini:
- json
- content
- text
- elapsed
- headers
- history
- status_code
- cookies
- url
- encoding
- links
- raw
• Response JSON
Ketika respons berhasil dikembalikan oleh server, Jika respons dalam format JSON yang berarti data disimpan sebagai pasangan nilai kunci, maka kita dapat mengambil data menggunakan response.json() metode.
Karena data dalam format JSON, kami dapat menguraikan data menggunakan kunci dan indeks.
• Response Teks
Jika respons dalam format teks, kita dapat membaca respons menggunakan response.text metode.
• Binary response
Jika respons yang dikembalikan dalam format biner seperti file gambar atau media, maka kami dapat mengambil respons dalam format biner itu sendiri menggunakan response.content, kami dapat memeriksa tipe data yang dikembalikan respons menggunakan type() dan mengevaluasi bahwa data dalam format byte.
Properti dan metode untuk objek respons dari POST, PUT, PATCH hampir mirip dengan GET Request.
• POST Requests
Permintaan POST adalah salah satu permintaan HTTP dan digunakan untuk mengirim data ke server bersama dengan isi permintaan.
Permintaan posting sebagian besar digunakan untuk mengirim data formulir ke server.
Itu juga digunakan untuk mengunggah beberapa format file ke server dan menyimpannya. Keuntungan utama dari permintaan POST adalah memungkinkan kita untuk mengirim sejumlah besar data ke server dalam satu permintaan.
- Melakukan beberapa permintaan POST dengan data yang sama pada URL yang sama menghasilkan jumlah salinan yang sama dengan ID yang berbeda.
- POST Request membuat sub-ordinat baru atau anak untuk sumber daya jika sumber daya sudah ada.
- Permintaan POST tidak di-cache secara default. Tetapi mereka dapat di-cache dengan menggunakan Expires header atau Cache-Control header.
Sintaks untuk melakukan permintaan posting pada URL diberikan di bawah ini:
requests.post(URL, data = {key : value})
Data dikirim dalam kamus menggunakan dataatribut. Alasan di balik ini adalah bahwa permintaan posting mengharapkan data formulir atau file dikirim ke server, kita perlu menggunakan dataatribut.
Dalam contoh di bawah ini, kami mengirim data ke URL menggunakan permintaan posting. Karena kami melakukan permintaan posting, kami perlu menggunakan requests.post()
import requests
info = {
'name' : 'chercher_requests',
'description' : 'post example',
}
response = requests.post('https://httpbin.org/post', data = info)
print(response.text)
Kita juga dapat mengirim data JSON ke URL yang sama. Tetapi data harus diserialisasi sebelum dikirim ke server.
Untuk membuat serial data, kami menggunakan json.dumps() dan meneruskan data dalam format kamus. Dalam contoh di bawah ini, kami melakukan serialisasi data yang sama dan mengirimkannya ke server.
Pada contoh sebelumnya, kita telah mengirim data formulir menggunakan permintaan POST.
Tapi sekarang kita telah mengirim data json itu akan disimpan di bawah atribut json.
• PUT Requests
PUT Requests adalah Permintaan HTTP yang digunakan untuk memperbarui sumber daya dan dikirim bersama dengan badan permintaan.
Dalam permintaan PUT jika sumber daya sudah ada maka hanya memperbaruinya dengan data baru.
PUT sebagian besar berguna ketika kita ingin memodifikasi sumber daya tunggal yang merupakan bagian dari koleksi sumber daya atau sudah ada.
Memanggil permintaan PUT beberapa kali memperbarui sumber daya yang sama beberapa kali dan memberikan satu sumber daya sebagai hasil akhir
Karena permintaan PUT idempoten yang berarti membuat beberapa permintaan identik, hasil memiliki efek yang sama dengan permintaan tunggal
Permintaan PUT tidak boleh di-cache karena idempotensinya
Tidak seperti POST, Dalam permintaan PUT ketika kami melakukan permintaan yang sama beberapa kali, hasil akhir sumber daya tetap sama seperti yang ditunjukkan pada gambar di bawah ini:
Sintaks untuk membuat permintaan put tetap sama dengan permintaan posting, kita hanya perlu mengubah permintaan menjadi requests.put()
requests.put(URL, data = {key : value})
Data dikirim dalam kamus menggunakan dataatribut. Dalam contoh di bawah ini, kami mengirim data ke URL menggunakan permintaan put. Karena kami melakukan permintaan put, kami perlu menggunakan requests.put()
import requests
info = {
'name' : 'chercher_requests',
'description' : 'put example',
}
response = requests.put('https://httpbin.org/put', data = info)
print(response.text)
• PUT vs POST
- PUT digunakan untuk memperbarui/memodifikasi satu sumber daya.
- Beberapa permintaan PUT yang sama mengembalikan hasil yang sama sebagai permintaan tunggal. Tidak membuat sumber daya baru.
- Metode PUT adalah idempoten yang menghasilkan sumber daya yang sama.
- Metode PUT tidak boleh di-cache.
- PUT harus digunakan ketika permintaan yang sama sedang dilakukan untuk operasi pembaruan.
- Operasi PUT 'N' dapat menghasilkan satu sumber daya.
- POST digunakan untuk membuat child resource ke sumber daya asli
- Beberapa permintaan POST yang sama membuat beberapa sub-ordinat atau child resource.
- Metode POST tidak idempoten karena membuat sub-ordinat baru untuk setiap permintaan.
- Metode POST dapat di-cache menggunakan parameter header tertentu.
- POST harus digunakan ketika permintaan yang berbeda dilakukan untuk membuat sumber daya.
- Operasi 'N' POST dapat menghasilkan sumber daya 'N'
• DELETE Requests
Permintaan DELETE dilakukan untuk menghapus data. Ini menghapus sumber daya pada URL tertentu.
requests.delete(URL)
URL sumber daya akan diteruskan ke permintaan penghapusan. Server mengembalikan respons dengan menghapus sumber daya.
Kita juga dapat menghapus sumber daya tertentu menggunakan ID sumber daya.
- Metode PATCH melakukan pembaruan sebagian sumber daya sedangkan metode PUT mengganti sumber daya dengan versi baru.
- Saat membandingkan PUT dan PATCH, hasil akhirnya bisa sama tetapi mungkin berbeda dalam ukuran sumber daya
Untuk melakukan permintaan PATCH kita dapat menggunakan requests.patch() metode dan meneruskan URL dan data yang perlu diperbarui.
import requests
info = {
'name' : 'chercher',
'description' : 'patch example',
}
response = requests.patch('https://httpbin.org/patch', data = info)
print(response.json())
• HEAD Requests
Metode HEAD melakukan permintaan yang mirip dengan metode GET. Tetapi alih-alih meminta seluruh objek respons, itu hanya meminta header respons.
Header respons berisi informasi seperti metadata. Metadata ini adalah informasi tentang server.
requests.head(URL)
Saat Kita melakukan permintaan HEAD, kami dapat mencoba memeriksa isi respons tetapi itu akan menjadi nol. Jadi tidak seperti metode HTTP lainnya, kita tidak dapat mengambil badan respons karena hanya header yang akan dikembalikan dari server.
Dalam contoh di bawah ini, kita mencoba mengambil badan respons menggunakan response.content yang yang mengembalikan objek biner. Karena metode HEAD hanya mengembalikan header, response.content ia mengembalikan nilai nol.
import requests
response = requests.head('https://httpbin.org/')
print(response.content)
# Output
b''
Kita dapat mengakses respons menggunakan response.headers, yang mengembalikan informasi tentang server.
print(response.headers)
• Response Status Code
Selain membaca respon, kita bisa mengetahui apakah permintaan berhasil atau tidak dengan menggunakan response.status_code .
Kode status dikeluarkan oleh server sebagai tanggapan atas permintaan yang dibuat dari sisi klien.
Kita dapat memeriksa apakah permintaan berhasil atau tidak menggunakan status_code properti objek respons.
response.status_code
Kode status Respon diklasifikasikan ke dalam 5 kategori berbeda, Digit pertama dalam kode status mewakili kelas kode status yang diwakilinya.
- 1xx – Informational Response yang mewakili permintaan/informasi diterima atau dipahami oleh server.
- 2xx – Successful ketika permintaan yang dibuat berhasil, diterima, dipahami, dan diterima.
- 3xx – Redirection menunjukkan klien harus melakukan tindakan tambahan untuk menyelesaikan permintaan.
- 4xx – Client Error dimaksudkan untuk situasi di mana kesalahan tampaknya disebabkan oleh sisi klien.
- 5xx – Server Error menunjukkan server mengalami kesalahan atau tidak mampu melakukan permintaan.
• Header
Header meneruskan informasi tambahan seperti metadata saat melakukan permintaan/tanggapan di server. Metadata berisi data tentang data.
Dalam header permintaan HTTP , kita dapat menyampaikan informasi mengenai konteks permintaan dari sisi klien seperti informasi browser, menerima, Otorisasi, dll.
Header Permintaan HTTP yang paling umum digunakan tercantum di bawah ini:
- Accept – Menentukan jenis file media apa yang dapat diterima browser klien untuk respons.
- Accept Encoding – Menentukan daftar encoding yang dapat diterima/dipahami klien. Pada dasarnya Server merespons dalam format yang didekodekan dan jika formatnya tidak dalam format yang dapat diterima di sisi klien, maka 503 kode status respons dikeluarkan.
- Authorization – Data yang terkait dengan otentikasi seperti kredensial login dapat diteruskan menggunakan parameter ini.
- Cache Control - Kontrol Cache digunakan dalam skenario permintaan dan respons baik untuk memproses permintaan melalui cache atau tidak.
- Connection – Parameter ini berguna untuk membuat koneksi tetap persisten bahkan setelah menyelesaikan permintaan. Koneksi ini dapat dalam bentuk TCP dan dapat digunakan untuk permintaan lebih lanjut.
- Cookie – Cookie adalah file datar yang menyimpan informasi mengenai aktivitas pengguna. kita dapat meneruskan string tertentu untuk memastikan permintaan diproses menggunakan cookie atau tidak.
- Content-Type – Mengirim informasi mengenai jenis data apa yang harus dikembalikan sebagai respons oleh server.
Sintaks untuk melewati header saat membuat permintaan diberikan di bawah ini. Dalam contoh di bawah ini kita telah mengatur Content-Type untuk respons server menjadi tipe JSON.
Jika respons dalam tipe yang berbeda maka kode status kesalahan yang menyerupai tidak ada data yang ditemukan untuk masing-masing tipe akan dikembalikan.
import requests
response = requests.get('https://blog-gan.org/',
headers = {'Content-Type' : 'application/json'})
print(response.headers['Content-Type'])
# Output
application/json; charset=UTF-8
Untuk informasi lebih lanjut tentang parameter Header Permintaan lainnya, silakan klik tautan
HTTP Response Header dikembalikan oleh server yang berisi informasi mengenai server.
Kita bisa mendapatkan daftar parameter header yang dikembalikan sebagai respons dari server menggunakan metode response.header.
import requests
response = requests.get('https://blog-gan.org/')
response_headers = []
for i in response.headers.keys():
response_headers.append(i)
print(response_headers)
# Output
['Date', 'Content-Type', 'Transfer-Encoding', 'Connection', 'access-control-allow-origin',
'cache-control', 'content-encoding', 'display', 'response', - -
- - - ]
Umumnya, Header Respons dikembalikan dalam pasangan nilai kunci kamus dan dapat diakses menggunakan kunci.
import requests
response = requests.get('https://blog-gan.org/')
print(response.headers['Content-Type'])
print(response.headers['response'])
print(response.headers['Server'])
# Output
application/json; charset=UTF-8
200
cloudflare
• Cookie dalam Requests/Respons
Cookie adalah jenis file datar yang menyimpan aktivitas pengguna saat kami melakukan permintaan di server.
Ketika permintaan dilakukan, server mengembalikan salinan cookie yang dapat menyimpan aktivitas pengguna dan salinan serupa juga disimpan di server.
Cookie juga dapat digunakan untuk melanjutkan sesi dari titik di mana pengguna mungkin telah pergi. Pada dasarnya setelah permintaan selesai dengan beberapa respons, koneksi akan dihentikan.
Sebagai gantinya, kita dapat mengambil cookie dari respons dan menggunakannya dalam permintaan berikutnya.
Hal ini membuat user experience menjadi jauh lebih baik saat melakukan Request/Response di sebuah server. kita dapat melihat cookie menggunakan metode response.cookies.
import requests
response = requests.get('https://blog-gan.org/')
print(response.cookies)
# Output
<RequestsCookieJar[<Cookie active_template::243221=pub_site.1990831337 for .blog-gan.org>,
<Cookie ezoab_243221=mod1 for .blog-gan.org/>, <Cookie ezoadgid_243221=-1 for .blog-gan.org/>,
- - - -
Kita juga dapat mengambil cookie dalam format kamus dengan membuat objek sesi dan menerapkan metode get_dict() .
import requests
request = requests.Session()
response = request.get('https://blog-gan.org/')
print(request.cookies.get_dict())
# Output
{'active_template::243221': 'pub_site.1990831337', 'ezoab_243221': 'mod1',
'ezoadgid_243221': '-1', 'ezopvc_243221': '1', 'ezoref_243221': '',
'ezosuibasgeneris-1': '43a05457-4ade-4bc8-41a2-1eeb9df21457',
- - - -
• HTTP Sessions
Sesi HTTP membantu kami menyimpan informasi di antara beberapa permintaan. Menggunakan Sesi kami dapat mengirim data pengguna individu ke server yang dapat dilacak oleh Session_ID.
Data pengguna disimpan di server dan data ini dapat diambil dengan mengirimkan session_id dalam cookie.
Untuk melakukan beberapa permintaan dalam satu sesi, kita perlu membuat objek sesi. Untuk membuat objek sesi kita dapat menggunakan requests.Session()
import requests
s = requests.Session()
Objek sesi memiliki semua metode bawaan yang mirip dengan library permintaan.
Menggunakan objek sesi yang dibuat pada langkah sebelumnya, kita dapat melakukan permintaan di server dan meneruskan data.
import requests
import json
s = requests.Session()
data = {
'name' : 'chercher',
'description' : 'Session example',
}
s.get('https://httpbin.org/cookies/set', params = data)
response = s.get('https://httpbin.org/cookies')
print(response.text)
Dari output di bawah ini, kita dapat melihat data yang dikirim ke server. Data ini dapat diakses selama sesi berlangsung. Dengan demikian, sesi dapat membantu memuat dan memproses permintaan dengan cepat.
# Output
{
"cookies": {
"description": "Session example",
"name": "chercher"
}
}
• Requests Timeouts
Timeout dapat membatalkan permintaan jika server membutuhkan waktu lebih lama dari batas tertentu untuk mengembalikan respons.
Ketika server membutuhkan lebih banyak waktu atau tidak merespons, dalam skenario seperti itu, waktu akan terbuang sia-sia.
Untuk menghindari hal ini, kita dapat mengatur timeoutparameter sedemikian rupa sehingga jika permintaan memakan waktu lebih dari waktu yang ditentukan dalam parameter batas waktu, permintaan akan dibatalkan dan memberikan kontrol kembali kepada pengguna.
Dalam contoh di bawah ini, kami mencoba melakukan permintaan pada URL bersama dengan batas waktu. Kita bisa melewati jumlah waktu yang dibutuhkan untuk menunda.
URL: https://httpbin.org/delay/n [ n adalah batas waktu ]
import requests
try:
response = s.get('https://httpbin.org/delay/5', timeout = 2)
except requests.exceptions.RequestException as exception:
print(exception)
Karena permintaan memakan waktu lebih lama dari batas waktu yang telah kita tentukan, permintaan akan dibatalkan. Ini bisa sangat membantu ketika Anda menguji waktu respons server.
• Errors and Exceptions
Saat melakukan permintaan pada URL, kita mungkin mengalami beberapa kesalahan. Namun error yang paling sering terjadi adalah ConnectionError dan HTTPError.
ConnectionErrors disebabkan karena URL yang tidak valid dari sisi klien, sedangkan HTTPErrors terjadi karena tidak ada respons atau URL mungkin rusak.
Saat terjadi kesalahan, eksekusi bagian berikutnya dari program yang bergantung pada permintaan mungkin terpengaruh.
Untuk menghindari skenario seperti itu, kita perlu menangani kesalahan ini. Salah satu caranya adalah dengan menggunakan raise_for_status(). Ini akan memunculkan objek HTTP Error jika terjadi kesalahan HTTP.
Kesalahan HTTP ini terjadi karena server tidak dapat memproses URL yang diminta, yang mungkin disebabkan karena URL rusak, atau situs tidak berfungsi.
import requests
r = requests.get("https://httpbin.org/status/404")
r.raise_for_status()
print('Bad Request', r.status_code)
Seperti yang dapat kita perhatikan dari output, r.raise_for_status() ini melakukan tugasnya dengan melemparkan kesalahan HTTP yang ditemui tetapi blok kode lainnya tidak dieksekusi.
Pada contoh di bawah ini, ketika kita membuat permintaan pada URL, server mengembalikan Kesalahan HTTP.
Untuk menangani Kesalahan HTTP ini kami melewati raise_for_status() sehingga akan melempar pengecualian dan kontrol diteruskan ke blok pengecualian. Dengan demikian kesalahan ditangani secara efisien.
import requests
try:
r = requests.get("https://httpbin.org/status/404")
r.raise_for_status()
except requests.exceptions.HTTPError as error:
print('Bad Request', r.status_code)
print('continue')
• Proxy Requests
Proxy bertindak sebagai gateway antara klien dan internet. Proxy memungkinkan kita untuk mengakses internet menggunakan alamat IP yang berbeda.
Dengan cara ini alamat IP Klien akan disembunyikan dari jaringan. Proxy juga bertindak sebagai firewall.
- Keuntungan utama dari Proxies adalah kami dapat menyimpan data untuk permintaan umum dan ini dapat meningkatkan waktu respons untuk permintaan tersebut.
- Juga saat melakukan pengikisan web, beberapa situs dapat memblokir alamat IP jika kami melakukan beberapa permintaan. Menggunakan Proxy, kami dapat melakukan banyak permintaan tanpa diblokir
Untuk melakukan permintaan menggunakan proxy, kita perlu melewati kamus proxy dengan metode HTTP atau.
HTTPS sebagai kunci dan alamat IP sebagai nilainya. Proxy ini dapat diambil dari berbagai situs web gratis yang menawarkan proxy.
proxy = {'https' : 'http://IP_address:Host', 'http' : 'http://IP_address:Host'}
dictionary proxy dapat diteruskan ke permintaan di bawah parameter "proxy" .
Pertama, mari kita periksa alamat IP perangkat kita sendiri. Saat kami membuat permintaan di “https://httpbin.org/ip” , ia mengembalikan alamat IP klien sebagai respons.
import requests
r = requests.get("https://httpbin.org/ip")
print(r.text)
Untuk melakukan permintaan yang sama di bawah alamat IP yang berbeda, kita perlu melewati kamus proxy sebagai parameter saat membuat permintaan.
import requests
proxies = {'https' : 'http://178.128.211.134:6868', 'http' : 'http://20.210.113.32:8123'}
r = requests.get("https://httpbin.org/ip", proxies = proxies)
print(r.text)
• Authentication Requests
Ketika klien meminta sumber daya yang dilindungi/tersembunyi, maka server perlu memvalidasi apakah pengguna memenuhi syarat untuk mengakses sumber daya atau tidak.
Dengan demikian server melakukan validasi menggunakan Otentikasi
Klien harus memberikan kredensial seperti nama pengguna/kata sandi saat membuat permintaan.
Kemudian otentikasi dilakukan di sisi server, jika kredensial valid maka server mengembalikan 200 kode respons dengan sumber daya yang diminta.
Ada otentikasi berbeda yang dapat diterapkan:
- Basic Authentication
- Digest Authentication
• Basic Authentication
Otentikasi Dasar adalah bentuk otentikasi paling sederhana yang dapat diimplementasikan. Dalam Otentikasi Dasar, klien harus memberikan nama_pengguna dan kata sandi dengan menyematkannya dalam permintaan.
Di Auth Dasar, nama_pengguna dan kata sandi dikirim dalam teks enkode base64 yang tidak terenkripsi , dan lebih baik menggunakan HTTPS melalui HTTP untuk menghindari pengambilan kata sandi dan digunakan kembali oleh pengguna atau situs web lain.
Untuk mengimplementasikan autentikasi dasar, kita perlu mengimpor HTTPBasicAuth dari requests.authmodul
from requests.auth import HTTPBasicAuth
Sekarang kita dapat memberikan nama_pengguna dan kata sandi ke URL yang diminta.
import requests
from requests.auth import HTTPBasicAuth
basic = HTTPBasicAuth('user_1', '1234')
r = requests.get('https://httpbin.org/basic-auth/user_1/1234', auth=basic)
print(r.status_code)
print(r.json())
• Digest Authentication
Keamanan In Digest Authentication tinggi jika dibandingkan dengan Basic Authentication .
Dalam jenis Otentikasi ini, fungsi hash digunakan pada kata sandi sebelum dikirim ke server.
Saat membuat permintaan menggunakan Otentikasi Intisari dan Otentikasi Dasar, prosesnya hampir sama tetapi secara internal fitur hashing dan keamanannya berbeda.
Poin-poin di bawah ini menjelaskan bagaimana hal itu dilakukan secara internal:
- Dalam Otentikasi Intisari, pengguna meminta sumber daya yang dilindungi tanpa kredensial apa pun sehingga server mengembalikan kode respons 401 "tidak sah".
- Pop-window akan terbuka dan pengguna akan diminta untuk memasukkan nama pengguna dan kata sandi
Kredensial ini dienkripsi menggunakan algoritma hash dan kemudian diteruskan ke server. Jika kredensial valid, sumber daya dikembalikan sebagai respons
- Digest Authentication menambahkan Nonce Klien yang dapat mengurangi Serangan Teks Biasa dan juga menambahkan QOP (Kualitas Perlindungan)
Untuk mengimplementasikan auth Digest kita perlu mengimpor HTTPDigestAuth dari modul requests.auth.
import requests
from requests.auth import HTTPDigestAuth
digest = HTTPDigestAuth('user_2', '1234')
r = requests.get('https://httpbin.org/digest-auth/auth/user_2/1234', auth=digest)
print('digest_auth status code:- ',r.status_code)
print(r.json())
• Event Hooks
Event Hooks membantu kita untuk menjalankan fungsi tertentu berdasarkan event yang terjadi. Dalam hal ini, acara adalah respons yang dikembalikan karena permintaan.
Aplikasi event hooks sama dalam setiap skenario seperti scraping atau membuat permintaan, tetapi implementasinya mungkin sedikit berbeda satu sama lain.
Dalam Permintaan, kait Acara dipicu saat respons dikembalikan untuk permintaan. Kait Acara ini pada dasarnya terkait dengan fungsi Call_back .
Kita dapat mengaitkan sebanyak mungkin fungsi Call_back yang diperlukan dengan satu kait peristiwa. Di bawah ini adalah sintaks untuk mengaitkan event hook dengan fungsi Call_back .
def func(response):
print('response attributes or anything')
hook = {'response' : func}
Jika kita ingin mengasosiasikan beberapa fungsi maka alih-alih mengirimkannya sebagai nilai kamus tunggal, kita dapat mengirimnya sebagai
tuplehook = {'response' : (func_1, func_2, .. .. .. )}
Dalam contoh di bawah ini kita mengasosiasikan fungsi Call_back yang menerima respons dan mengembalikan response.status_code, Juga saat membuat permintaan, kita perlu menetapkan variabel event_hooks ke parameter hook bersama dengan URL.
import requests
def status_code(response, *args, **kwargs):
print('Status_Code:- ', response.status_code)
def headers(response, *args, **kwargs):
print('headers:- ', response.headers)
event_hook = {'response' : (status_code, headers)}
response = requests.get('https://httpbin.org/get', hooks = event_hook)
• SSL Protocol
Secure Socket Layer adalah protokol dalam bentuk sertifikat yang memungkinkan koneksi aman dengan browser. Sertifikat ini adalah kunci publik yang dikeluarkan oleh server dalam file data kecil.
Klien dan server berbagi kunci terenkripsi dalam bentuk sertifikat dan memverifikasinya sebelum berbagi data.
Setelah sertifikat diverifikasi di kedua sisi maka data dibagikan dalam format terenkripsi yang akan didekripsi di ujung lainnya menggunakan kunci. Dengan demikian klien menyelesaikan Handshake SSL/TLS sebelum meminta data dari server.
Umumnya, SSL Handshake dilakukan antara klien dan server, tetapi ketika kami melakukan permintaan menggunakan perpustakaan permintaan, SSL diimplementasikan secara internal oleh modul permintaan.
Saat membuat permintaan, kami dapat melewati Otoritas Sertifikat yang Ditandatangani Sendiri. Untuk membuat
Sertifikat yang Ditandatangani Sendiri, gunakan kode di bawah ini:
openssl req -new -x509 -days 365 -nodes -out cert.pem -keyout cert.pem
Sertifikat ini akan dikirim melalui email dan dapat digunakan saat melakukan permintaan menggunakan verify atribut bersama dengan URL.
import requests
response = requests.get('https://httpbin.org/get', verify = 'user/downloads/self_signed_certicate')
Jika kita lulus verify=False yang berarti tidak ada enkripsi atau protokol tidak diterapkan maka akan muncul peringatan. Kami dapat memberikan sertifikat yang ditandatangani sendiri atau membiarkannya sebagai default. Tetapi jika kita menetapkan False maka itu akan memberikan peringatan bahwa koneksi tidak aman.
import requests
response = requests.get('https://httpbin.org/get', verify = False)
• Redirect Requests
Pengalihan Permintaan dilakukan oleh server setelah pengguna dilayani dengan otorisasi atau token akses. Pengalihan diterapkan dalam skenario yang berbeda seperti portal masuk, klik iklan, dll.,
Modul permintaan secara default menyediakan pengalihan URL untuk semua metode HTTP seperti GET, POST, PUT, DELETE. Pengalihan untuk metode HEAD harus dilakukan secara Manual
Misalnya, ketika kami melakukan metode permintaan GET, POST, PUT, DELETE di htttp://github.com , secara default itu mengarahkan pengguna dari situs web HTTP ke situs web HTTPS.
import requests
response = requests.get('http://github.com')
print(response.url)
print(response.status_code)
Kita dapat memeriksa pengembalian status_code dan URL. Ini mengembalikan 200 status_code dan URL baru yang menyatakan bahwa pengguna dialihkan secara permanen.
Kita juga dapat menghindari pengalihan dengan menyetel allow_redirectsparameter ke False. Dalam hal ini response.status_code mengembalikan kode 301.
response = requests.get('http://github.com', allow_redirects= False)
print(response.url)
Posting Komentar untuk "Request Library Dengan Python"
Terima kasih telah mengunjungi blog kami. Silakan tinggalkan jejak Anda dengan mengisi kolom komentar di bawah ini.