This article demonstrates using Python's requests library to make HTTP requests. It covers GET, POST, PUT, DELETE, and other methods, explaining how to handle status codes and send data (including JSON and files). Error handling using response.rai

How to Use Requests to Make HTTP Requests in Python?

The requests library in Python simplifies making HTTP requests. It provides a clean, intuitive API that abstracts away much of the complexity involved in handling HTTP connections, headers, and responses. To use it, you first need to install it. You can do this using pip:

pip install requests

Once installed, you can start making requests. The most common function is requests.get(), used for retrieving data from a URL. Here's a basic example:

import requests

response = requests.get("https://www.example.com")

# Check the status code
print(response.status_code)

# Access the content
print(response.text)

This code fetches the HTML content of example.com. The response object contains various attributes, including status_code (HTTP status code like 200 OK) and text (the response body). Other useful attributes include headers (response headers), json() (for parsing JSON responses), and content (raw response bytes). Error handling is crucial; we'll cover that in a later section. For other HTTP methods (like POST, PUT, DELETE), you use corresponding functions like requests.post(), requests.put(), and requests.delete().

What are the common HTTP methods supported by the Requests library in Python?

The requests library supports all the common HTTP methods, including:

• GET: Retrieves data from a specified resource. This is the most frequently used method.
• POST: Submits data to be processed to the specified resource. Often used to create new resources.
• PUT: Replaces all current representations of the target resource with the uploaded content.
• PATCH: Applies partial modifications to a resource.
• DELETE: Deletes the specified resource.
• HEAD: Similar to GET, but only retrieves the headers, not the body.
• OPTIONS: Describes the communication options for the target resource.

Each method is represented by a corresponding function in the requests library (e.g., requests.get(), requests.post(), etc.). The specific usage might vary depending on the method and the API you're interacting with, but the basic structure remains similar. For instance, requests.post() requires specifying the data to be sent in the request body.

How can I handle different HTTP status codes using the Requests library?

HTTP status codes indicate the outcome of an HTTP request. The requests library makes it easy to check and handle these codes. The response.status_code attribute provides the status code (e.g., 200 for success, 404 for Not Found, 500 for Internal Server Error). You should always check the status code to ensure the request was successful. Here's an example:

import requests

try:
    response = requests.get("https://www.example.com")
    response.raise_for_status()  # Raises an exception for bad status codes (4xx or 5xx)
    print("Request successful!")
    print(response.text)
except requests.exceptions.RequestException as e:
    print(f"An error occurred: {e}")

response.raise_for_status() is a convenient method that automatically raises an exception if the status code indicates an error (4xx or 5xx client/server errors). This simplifies error handling. You can also manually check the status code and handle different cases using if statements:

if response.status_code == 200:
    print("Success!")
elif response.status_code == 404:
    print("Not Found")
elif response.status_code == 500:
    print("Server Error")
else:
    print(f"Unknown status code: {response.status_code}")

How do I send POST requests with data using the Requests library in Python?

Sending POST requests with data involves using the requests.post() function and specifying the data to be sent in the request body. The data can be in various formats, such as dictionaries, lists, or files.

Here's how to send a POST request with data as a dictionary:

import requests

data = {'key1': 'value1', 'key2': 'value2'}
response = requests.post("https://httpbin.org/post", data=data)  # httpbin.org is a useful testing site

print(response.status_code)
print(response.json()) # httpbin.org returns the POST data as JSON

This example sends a POST request to httpbin.org/post with the provided dictionary as the request body. httpbin.org is a useful service for testing HTTP requests. For sending JSON data, use the json parameter:

import requests
import json

data = {'key1': 'value1', 'key2': 'value2'}
response = requests.post("https://httpbin.org/post", json=data)

print(response.status_code)
print(response.json())

Remember to handle potential errors using try...except blocks and response.raise_for_status() as shown in the previous section. For sending files, use the files parameter with a dictionary mapping filenames to file objects. The requests library offers great flexibility in handling different data types for POST requests.

The above is the detailed content of How to Use Requests to Make HTTP Requests in Python?. For more information, please follow other related articles on the PHP Chinese website!