Of course! Let's break down httplib in Python, covering its history, modern alternatives, and providing clear code examples.

The Short Answer: What is httplib?

httplib is the original Python library for making HTTP requests. It was introduced in Python 2.0.

Important: In Python 3, the module was renamed to http.client. The functionality is essentially the same, but the name was changed to be more consistent with Python's other http.* modules (like http.server).

Because of its low-level nature, it's rarely used directly today. Modern applications use higher-level libraries like requests.

The Old Way: httplib (Python 2)

In Python 2, you would import httplib. It was very verbose and required you to manually handle many details like headers, connection state, and data encoding.

# Python 2 Example
import httplib
import json
# The data to send
data = {'key': 'value'}
json_data = json.dumps(data)
# Create a connection to the server
# Note: Port 80 is the default for HTTP
conn = httplib.HTTPConnection("example.com")
# Prepare the headers
headers = {
    'Content-type': 'application/json',
    'Accept': 'application/json'
}
# Send the POST request
conn.request("POST", "/path/to/resource", json_data, headers)
# Get the response from the server
response = conn.getresponse()
# Read the response body
response_body = response.read()
# Print the status and data
print "Status:", response.status
print "Headers:", response.getheaders()
print "Body:", response_body
# Close the connection
conn.close()

As you can see, this is quite a bit of code for a simple request. You have to manage the connection object (conn) and remember to close it.

The Modern Way: http.client (Python 3)

In Python 3, the module is http.client. The logic is nearly identical, but it's the standard way to do low-level HTTP in modern Python.

# Python 3 Example
import http.client
import json
# The data to send
data = {'key': 'value'}
json_data = json.dumps(data)
# Create a connection to the server
# Note: Port 80 is the default for HTTP
conn = http.client.HTTPConnection("example.com")
# Prepare the headers
headers = {
    'Content-type': 'application/json',
    'Accept': 'application/json'
}
try:
    # Send the POST request
    conn.request("POST", "/path/to/resource", body=json_data, headers=headers)
    # Get the response from the server
    response = conn.getresponse()
    # Read the response body
    # It's good practice to decode the bytes to a string
    response_body = response.read().decode('utf-8')
    # Print the status and data
    print(f"Status: {response.status}")
    print(f"Headers: {response.getheaders()}")
    print(f"Body: {response_body}")
finally:
    # It's crucial to close the connection
    conn.close()

This is the direct equivalent of the Python 2 code. It's still verbose and manual.

The Recommended Way: The requests Library

For almost all use cases, the requests library is the de facto standard. It's built on top of http.client but provides a beautiful, simple, and Pythonic API. It handles connection pooling, sessions, JSON encoding/decoding, and much more.

First, you need to install it:

pip install requests

Now, compare the requests code to the http.client code. The difference is night and day.

# The recommended way using the 'requests' library
import requests
import json
# The data to send (requests can handle dicts directly for JSON)
data = {'key': 'value'}
url = "http://example.com/path/to/resource"
# Prepare the headers
headers = {
    'Content-type': 'application/json',
    'Accept': 'application/json'
}
try:
    # Send the POST request. That's it.
    response = requests.post(url, json=data, headers=headers)
    # The 'response' object is rich with information
    # response.status_code gives the HTTP status (e.g., 200, 404)
    print(f"Status: {response.status_code}")
    # response.headers gives a dictionary-like object of headers
    print(f"Headers: {response.headers}")
    # response.json() automatically decodes the JSON response body
    # into a Python dictionary. Raises an error if the response is not valid JSON.
    response_data = response.json()
    print(f"Body (as JSON): {response_data}")
    # You can also get the raw text content
    # print(f"Body (as text): {response.text}")
except requests.exceptions.RequestException as e:
    # This will catch connection errors, timeouts, etc.
    print(f"An error occurred: {e}")
# No need to manually close the connection. requests handles it.

Why requests is better:

• Simplicity: The API is much cleaner and easier to read.
• Automatic JSON Handling: requests.post(..., json=data) automatically serializes your Python dict to a JSON string and sets the correct Content-Type header. response.json() automatically deserializes the response.
• Better Error Handling: response.raise_for_status() will raise an HTTPError for bad status codes (4xx or 5xx), making error handling more straightforward.
• Sessions: requests.Session objects allow you to persist parameters across requests, handle cookies, and use connection pooling, which is much more efficient for multiple calls to the same host.
• Human Readable: The library is designed to be used by humans, not robots.

Summary: When to Use Which?

Conclusion:

Unless you have a specific reason to work at a very low level, you should use the requests library. It will make your life easier and your code cleaner. Use http.client only when you are in an environment where you cannot install external packages or need fine-grained control that requests doesn't provide.