Introduction to Higher-Order Functions in Python

Introduction Higher-order functions are functions that take other functions as arguments or return them as results. Python provides built‑in higher‑order functions such as map , filter , and reduce , which can greatly simplify code and improve maintainability.

map Function The map function applies a given function to each element of a sequence and returns a new iterable.

import requests
from functools import partial

def send_request(url, params):
    response = requests.get(url, params=params)
    return response.json()

urls = ["https://api.example.com/user/1", "https://api.example.com/user/2"]
params = [{"id": 1}, {"id": 2}]
responses = map(partial(send_request, params=params), urls)
for response in responses:
    print("响应内容:", response)

filter Function The filter function applies a predicate to each element of a sequence and yields only those elements for which the predicate returns True .

import requests

def is_valid_response(response):
    return response.status_code == 200

responses = [
    requests.get("https://api.example.com/valid"),
    requests.get("https://api.example.com/invalid"),
]
valid_responses = filter(is_valid_response, responses)
for response in valid_responses:
    print("有效响应:", response.json())

reduce Function The reduce function aggregates a sequence into a single value by repeatedly applying a binary function.

from functools import reduce

def sum_response_times(a, b):
    return a + b.elapsed.total_seconds()

responses = [
    requests.get("https://api.example.com/1"),
    requests.get("https://api.example.com/2"),
]
total_time = reduce(sum_response_times, responses, 0)
print("总响应时间:", total_time)

partial Function functools.partial fixes some arguments of a function, producing a new callable with fewer parameters.

import requests
from functools import partial

send_request = partial(requests.get, timeout=5)
response = send_request("https://api.example.com/data")
print("响应内容:", response.json())

lambda Expressions Lambda expressions provide a concise way to create small anonymous functions, often used with filter or map .

import requests
responses = [
    requests.get("https://api.example.com/valid"),
    requests.get("https://api.example.com/invalid"),
]
valid_responses = filter(lambda r: r.status_code == 200, responses)
for response in valid_responses:
    print("有效响应:", response.json())

itertools Module The itertools module offers efficient iterator tools; chain can concatenate multiple iterables.

import requests
from itertools import chain

responses = [
    requests.get("https://api.example.com/users?page=1"),
    requests.get("https://api.example.com/users?page=2"),
]
all_users = chain.from_iterable(response.json()["users"] for response in responses)
for user in all_users:
    print("用户:", user)

functools Module Besides partial , functools provides lru_cache for memoization.

import requests
from functools import lru_cache

@lru_cache(maxsize=32)
def get_user(id):
    response = requests.get(f"https://api.example.com/user/{id}")
    return response.json()

user = get_user(1)
print("用户:", user)

contextlib Module contextlib.closing creates a context manager that ensures a resource is closed after use.

import requests
from contextlib import closing

with closing(requests.get("https://api.example.com/data")) as response:
    print("响应内容:", response.json())

concurrent.futures Module ThreadPoolExecutor enables simple parallel execution of I/O‑bound functions.

import requests
from concurrent.futures import ThreadPoolExecutor

def send_request(url):
    response = requests.get(url)
    return response.json()

urls = ["https://api.example.com/user/1", "https://api.example.com/user/2"]
with ThreadPoolExecutor(max_workers=2) as executor:
    results = list(executor.map(send_request, urls))
for result in results:
    print("响应内容:", result)

decorator Module The third‑party decorator library simplifies writing well‑behaved decorators.

from decorator import decorator

@decorator
def log_request(func, *args, **kwargs):
    print("发送请求:", args[0])
    result = func(*args, **kwargs)
    print("响应结果:", result)
    return result

@log_request
def send_request(url):
    response = requests.get(url)
    return response.json()

result = send_request("https://api.example.com/data")

Conclusion By leveraging Python’s higher‑order functions and related utilities, API automation tests become more concise and efficient, helping developers write cleaner, more maintainable code.