Making HTTP requests using Python requests library

When using Python's requests library to initiate HTTP requests, you need to pay attention to key points such as parameter passing, exception handling, and session maintenance. 1. When transferring parameters to GET requests, the params parameter should be used instead of manually splicing the URL, which can automatically handle encoding and avoid security issues; 2. POST requests select data (form), json (JSON data) or files (file upload) parameters according to the scenario; 3. It is recommended to combine response.raise_for_status() and try-except to catch HTTP errors, and set timeout, control redirection and maximum number of retry times; 4. When you need to maintain login, use the Session object to automatically manage cookies, and temporary headers such as Authorization can be added through the headers parameter; 5. Sensitive information should be avoided hard coding, and it is recommended to use environment variables or configuration tools to manage them. Mastering these techniques can improve the stability and security of requests.

Using Python's requests library to make HTTP requests is a basic skill that many developers will use in daily life. It is simple and easy to use, and has comprehensive functions. Here are a few key points in the process of use, which will help you do this more stably and efficiently.

How to pass parameters when requesting GET?

When sending GET requests, the most common requirement is to add parameters to the URL. Don't spell strings manually at this time, using params parameter is the most convenient:

 import requests

response = requests.get("https://api.example.com/data", params={"page": 2, "limit": 20})

This not only makes writing clear, but also automatically handles encoding problems. For example, spaces will be converted to , Chinese can also be processed normally. If you don’t do this, you will easily make mistakes if you fight yourself and may encounter security problems.

Sometimes you will see that there are already parameters on the URL, and params will be automatically followed and there will be no conflict. But it should be noted that if the parameters already in the original URL are added with the same key through params , they may be overwritten or repeated, so you have to pay attention to the logic yourself.

How to transfer data in POST request?

There are several common situations for POST requests: form submission, JSON data, and upload files. Different scenarios should be set with different parameters.

• Form data (application/x-www-form-urlencoded)
  Just use data parameter to pass the dictionary:

   requests.post("https://example.com/login", data={"username": "test", "password": "123456"})

• JSON data (application/json)
  It is recommended to use json parameter, which will automatically set Content-Type and serialize data:

   requests.post("https://api.example.com/create", json={"name": "John", "age": 30})

• Upload file (multipart/form-data)
  Use files parameters, suitable for transferring pictures, documents, etc.:

   files = {"file": open("example.txt", "rb")}
  requests.post("https://example.com/upload", files=files)

Remember to close the files after using them, or use with open(...) to manage resources.

How to deal with exceptions and status codes?

Network requests cannot be 100% successful, so error handling must be added.

Let's look at the response status code first:

 response = requests.get("https://example.com")
if response.status_code == 200:
    print(response.json())
else:
    print(f"Request failed, status code: {response.status_code}")

However, there is a simpler way, just call response.raise_for_status() , which will throw exceptions when the status code is not 2xx, and it is very easy to use with try-except:

 try:
    response = requests.get("https://example.com")
    response.raise_for_status()
except requests.exceptions.HTTPError as err:
    print(f"HTTP error: {err}")

In addition, there are also details such as connection timeout and redirection control:

• Timeout setting: requests.get(url, timeout=5) to prevent the program from being stuck
• Redirects are prohibited: requests.get(url, allow_redirects=False)
• Set the maximum number of retry times: it needs to be implemented with Session and HTTPAdapter

How to keep a session or bring cookie requests?

Some interfaces require login status, and you can use Session object to maintain the session:

 session = requests.Session()
session.post("https://example.com/login", data={"user": "test", "pass": "123"})
response = session.get("https://example.com/profile")

Session will automatically save the cookie and bring it to subsequent requests, which is equivalent to the behavior of the browser. It is more convenient and safer than manually adding headers every time.

If you just add a header temporarily, such as Authorization:

 headers = {"Authorization": "Bearer your_token"}
response = requests.get("https://api.example.com/data", headers=headers)

However, sensitive information should not be hard-coded in the code. It is recommended to use environment variables or configuration management tools.

Basically that's it. It is not difficult to send requests, but to use them stably and safely, you still have to pay more attention to these small details.

The above is the detailed content of Making HTTP requests using Python requests library. For more information, please follow other related articles on the PHP Chinese website!