Python 2.7单条非阻塞HTTPS POST请求实现方案问询

Got it—Python 2.7 can be tricky for async requests since most modern tools target 3.x, but there are reliable ways to do a single non-blocking HTTPS POST without blocking your main thread. Below are two solid options, depending on whether you can install third-party libraries or prefer using the standard library.

Option 1: Using gevent (Async IO with Greenlets) #

gevent is a lightweight async framework that works great with Python 2.7. It uses greenlets (lightweight execution units) to handle async tasks without the overhead of threads.

First, install compatible versions of gevent and requests (since newer versions drop Python 2.7 support):

pip install requests==2.26.0 gevent==1.5.0

Here's the example code:

from gevent import monkey
# Patch standard library modules to use gevent's async IO
monkey.patch_all()

import requests
import gevent

def async_https_post(url, payload):
    try:
        # Send HTTPS POST with certificate verification (secure default)
        response = requests.post(url, data=payload, verify=True)
        print("POST completed! Status code: {}".format(response.status_code))
        print("Response content: {}".format(response.text))
    except Exception as e:
        print("Error during POST request: {}".format(str(e)))

if __name__ == "__main__":
    # Replace with your target URL and payload
    target_url = "https://your-api-endpoint.com/post"
    request_payload = {"user": "test", "data": "sample"}

    # Spawn the async POST task (runs in background)
    gevent.spawn(async_https_post, target_url, request_payload)

    # Main thread continues executing non-blocking work
    print("Main thread is running other tasks...")
    for step in range(5):
        print("Main task step {}".format(step + 1))
        gevent.sleep(1)  # Simulate work with non-blocking sleep

Key Notes: #

• monkey.patch_all() replaces blocking socket calls in the standard library with gevent's async equivalents, so requests works asynchronously.
• verify=True ensures SSL certificates are validated (never disable this in production unless you have a specific, secure reason).
• The main thread runs independently while the POST request is processed in the background.

Option 2: Using threading (Standard Library Only) #

If you can't install third-party libraries, the built-in threading module lets you run the POST request in a separate thread, keeping your main thread unblocked.

Example code:

import threading
import requests
import time

def async_https_post(url, payload):
    try:
        response = requests.post(url, data=payload, verify=True)
        print("POST completed! Status code: {}".format(response.status_code))
        print("Response content: {}".format(response.text))
    except Exception as e:
        print("Error during POST request: {}".format(str(e)))

if __name__ == "__main__":
    target_url = "https://your-api-endpoint.com/post"
    request_payload = {"user": "test", "data": "sample"}

    # Create and start a daemon thread (exits when main thread finishes)
    post_thread = threading.Thread(target=async_https_post, args=(target_url, request_payload))
    post_thread.daemon = True
    post_thread.start()

    # Main thread continues its work
    print("Main thread is running other tasks...")
    for step in range(5):
        print("Main task step {}".format(step + 1))
        time.sleep(1)  # Simulate blocking work (thread still runs in background)

Key Notes: #

• Daemon threads don't prevent the program from exiting once the main thread completes.
• This uses OS-level threads, which have more overhead than gevent's greenlets but require no extra dependencies.

Both solutions handle HTTPS correctly and work exclusively with Python 2.7. Pick the one that fits your environment best!

内容的提问来源于stack exchange，提问作者svenyonson