Python 同、异步HTTP客户端封装:性能与简洁性的较量

Python异步编程:httpx.AsyncClient的stream方法超时设置全解析 本文深入解析了Python httpx库中AsyncClient.stream()方法的超时设置机制。针对流式请求场景,详细阐述了timeout参数的多维度含义,特别是read超时对数据块间隔的控制作用,并提供了不同业务场景下的配置策略与代码示例,帮助开发者构建稳定高效的异步HTTP流式请求。 阅读详情

一、前言

  • 引入异步编程趋势:Python的异步编程正变得越来越流行。在过去,同步的HTTP请求已经不足以满足对性能的要求。

  • 异步HTTP客户端库的流行:目前,有许多第三方库已经实现了异步HTTP客户端,如aiohttp和httpx等。然而,异步语法使得代码变得更加冗长,导致缩进增多,降低了代码的可读性和简洁性。

  • 封装异步HTTP客户端:为了简化异步HTTP请求的代码,我们需要封装一个常用的HTTP客户端,以实现业务中常见的功能,并提供更简洁的接口。在这篇博客中,我将使用httpx库来进行封装异步客户端,requests则是封装同步客户端,以实现常见的HTTP方法,并支持设置超时时间、请求参数等功能。

二、同异步http客户端测试

同异步简易Demo

再封装之前先看看同异步发个http请求的代码差异,这里以 requests、aiohttp、httpx进行展示

依赖安装

pip install requests aiohttp httpx  

#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Author: Hui
# @Desc: { 模块描述 }
# @Date: 2023/09/28 10:09
import asyncio
import httpx
import aiohttp
import requests

def requests_demo(url):
    print("requests_demo")
    resp = requests.get(url)
    print(resp.text)

async def aiohttp_demo(url):
    print("aiohttp_demo")
    async with aiohttp.client.ClientSession() as session:
        async with session.get(url) as resp:
            html_text = await resp.text()
            print(html_text)

async def httpx_demo(url):
    print("httpx_demo")

    async with httpx.AsyncClient() as client:
        resp = await client.get(url)
        print(resp.text)

async def main():
    url = "https://juejin.cn/"

    requests_demo(url)

    await aiohttp_demo(url)
    await httpx_demo(url)

if __name__ == '__main__':
    asyncio.run(main())

可以看到同步的requests库实现的非常简洁一行代码就可以发送http请求。但异步语法的 httpx与aiohttp就感觉代码很臃肿,要嵌套好多层,尤其aiohttp,可读性变差了好多,但异步的请求可以大大的提升并发性能,利用网络IO的耗时处理更多的请求任务,这在爬虫中可以大大提升性能,再异步的web框架中也非常适用。

并发http请求测试

再看看同异步如何并发请求数据

async def concurrent_http_test():
    # requests test
    urls = ["https://juejin.cn/"] * 10

    start_time = time.time()
    for url in urls:
        requests_demo(url)
    use_time = time.time() - start_time
    print(f"requests {len(urls)} http req use {use_time} s")

    # httpx test
    start_time = time.time()
    await asyncio.gather(*[
        httpx_demo(url) for url in urls
    ])
    use_time = time.time() - start_time
    print(f"httpx {len(urls)} http req use {use_time} s")

    # aiohttp test
    start_time = time.time()
    await asyncio.gather(*[
        aiohttp_demo(url) for url in urls
    ])
    use_time = time.time() - start_time
    print(f"aiohttp {len(urls)} http req use {use_time} s")

结果:

requests 10 http req use 2.9108400344848633 s

httpx 10 http req use 0.8657052516937256 s

aiohttp 10 http req use 1.9703822135925293 s

requests 请求demo是同步一个一个请求,所以会慢好多,而 httpx、aiohttp 是通过 asyncio.gather 并发请求的,会一次性发送10个请求,这样网络IO的耗时就复用了,但发现 aiohttp 的效果不尽人意,与httpx的0.86s相差太大,都是异步库,不应该的,于是看看之前写的demo代码发现其实aiohttp并没有复用 ClientSession 每次都是创建一个新的实例来去发送请求,这样频繁的创建与销毁连接会大大影响性能,httpx的 async with httpx.AsyncClient() as client: 好像是一样的问题,但httpx效果更好些。

尝试把 aiohttp 的 ClientSession 与 httpx.AsyncClient() 放到全局中去,再试试。

def requests_demo(url, session):
    # print("requests_demo")
    resp = session.get(url)
    return resp

async def aiohttp_demo(url, aio_session):
    # print("aiohttp_demo")

    async with aio_session.get(url) as resp:
        # html_text = await resp.text()
        return resp

async def httpx_demo(url, client):
    # print("httpx_demo")

    resp = await client.get(url)
    return resp
    

async def concurrent_http_test():
    # requests test
    urls = ["https://juejin.cn/"] * 10

    start_time = time.time()
    with ThreadPoolExecutor() as pool:
        session = requests.session()
        for url in urls:
            pool.submit(requests_demo, url, session)

    use_time = time.time() - start_time
    print(f"requests {len(urls)} http req use {use_time} s")

    # aiohttp test
    start_time = time.time()
    async with aiohttp.client.ClientSession() as aio_session:
        await asyncio.gather(*[
            aiohttp_demo(url, aio_session) for url in urls
        ])
    use_time = time.time() - start_time
    print(f"aiohttp {len(urls)} http req use {use_time} s")

    # httpx test
    start_time = time.time()
    async with httpx.AsyncClient() as client:
        await asyncio.gather(*[
            httpx_demo(url, client) for url in urls
        ])
    use_time = time.time() - start_time
    print(f"httpx {len(urls)} http req use {use_time} s")

改进效果

requests 10 http req use 1.2176601886749268 s

aiohttp 10 http req use 0.4052879810333252 s

httpx 10 http req use 0.5238490104675293 s

异步的效果很明显快了很多,requests 请求我也用 session 与线程池来并发请求看看效果,但网络有波动每次测的数据都不一样,所以这里的测试值仅作为参考。

三、异步http客户端封装

简易封装

aiohttp 与 httpx 性能都差不多,由于之前用 requests 习惯了,再接触这些异步封装的语法都觉得好怪,而 httpx的api 与 requests 类似,所以我就选择用 htppx 简单封装下。

#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Author: Hui
# @Desc: { http客户端 }
# @Date: 2023/08/10 09:33
import httpx
from datetime import timedelta

class HttpMethod(BaseEnum):
    GET = "GET"
    POST = "POST"
    PATCH = "PATCH"
    PUT = "PUT"
    DELETE = "DELETE"
    HEAD = "HEAD"
    OPTIONS = "OPTIONS"

class RespFmt(BaseEnum):
    """http响应格式"""
    JSON = "json"
    BYTES = "bytes"
    TEXT = "text"

class AsyncHttpClient:
    """异步HTTP客户端

    通过httpx封装,实现了常见的HTTP方法,支持设置超时时间、请求参数等,简化了异步调用的层级缩进。

    Attributes:
        default_timeout: 默认请求超时时间,单位秒
        default_headers: 默认请求头字典
        default_resp_fmt: 默认响应格式json
        client: httpx 异步客户端
        response: 每次实例请求的响应
    """

    def __init__(self, timeout=timedelta(seconds=10), headers: dict = None, resp_fmt: RespFmt = RespFmt.JSON):
        """构造异步HTTP客户端"""
        self.default_timeout = timeout
        self.default_headers = headers or {}
        self.default_resp_fmt = resp_fmt
        self.client = httpx.AsyncClient()
        self.response: httpx.Response = None

    async def _request(
            self,
            method: HttpMethod, url: str,
            params: dict = None, data: dict = None,
            timeout: timedelta = None, **kwargs
    ):
        """内部请求实现方法

        创建客户端会话,构造并发送HTTP请求,返回响应对象

        Args:
            method: HttpMethod 请求方法, 'GET', 'POST' 等
            url: 请求URL
            params: 请求查询字符串参数字典
            data: 请求体数据字典
            timeout: 超时时间,单位秒
            kwargs: 其他关键字参数

        Returns:
            httpx.Response: HTTP响应对象
        """
        timeout = timeout or self.default_timeout
        headers = self.default_headers or {}
        self.response = await self.client.request(
            method=method.value,
            url=url,
            params=params,
            data=data,
            headers=headers,
            timeout=timeout.total_seconds(),
            **kwargs
        )
        return self.response

    def _parse_response(self, resp_fmt: RespFmt = None):
        """解析响应

        Args:
            resp_fmt: 响应格式

        Returns:
            resp Union[dict, bytes, str]
        """
        resp_fmt = resp_fmt or self.default_resp_fmt
        resp_content_mapping = {
            RespFmt.JSON: self.json,
            RespFmt.BYTES: self.bytes,
            RespFmt.TEXT: self.text,
        }
        resp_func = resp_content_mapping.get(resp_fmt)
        return resp_func()

    def json(self):
        return self.response.json()

    def bytes(self):
        return self.response.content

    def text(self):
        return self.response.text

    async def get(self, url: str, params: dict = None, timeout: timedelta = None, resp_fmt: RespFmt = None, **kwargs):
        """GET请求

        Args:
            url: 请求URL
            params: 请求查询字符串参数字典
            timeout: 请求超时时间,单位秒
            resp_fmt: 响应格式,默认None 使用实例对象的 default_resp_fmt

        Returns:
            resp => dict or bytes
        """

        await self._request(HttpMethod.GET, url, params=params, timeout=timeout, **kwargs)
        return self._parse_response(resp_fmt)

    async def post(self, url: str, data: dict = None, timeout: timedelta = None, resp_fmt: RespFmt = None, **kwargs):
        """POST请求

        Args:
            url: 请求URL
            data: 请求体数据字典
            timeout: 请求超时时间,单位秒
            resp_fmt: 响应格式,默认None 使用实例对象的 default_resp_fmt

        Returns:
            resp => dict or bytes
        """
        await self._request(HttpMethod.POST, url, data=data, timeout=timeout, **kwargs)
        return self._parse_response(resp_fmt)

    async def put(self, url: str, data: dict = None, timeout: timedelta = None, resp_fmt: RespFmt = None, **kwargs):
        """PUT请求

        Args:
            url: 请求URL
            data: 请求体数据字典
            timeout: 请求超时时间,单位秒
            resp_fmt: 响应格式,默认None 使用实例对象的 default_resp_fmt

        Returns:
            resp => dict
        """
        await self._request(HttpMethod.PUT, url, data=data, timeout=timeout, **kwargs)
        return self._parse_response(resp_fmt)

    async def delete(self, url: str, data: dict = None, timeout: timedelta = None, resp_fmt: RespFmt = None, **kwargs):
        """DELETE请求

        Args:
            url: 请求URL
            data: 请求体数据字典
            timeout: 请求超时时间,单位秒
            resp_fmt: 响应格式,默认None 使用实例对象的 default_resp_fmt

        Returns:
            resp => dict
        """
        await self._request(HttpMethod.DELETE, url, data=data, timeout=timeout, **kwargs)
        return self._parse_response(resp_fmt)

封装细节

这里封装就是简单的内部维护一个 httpx 的异步客户端,然后初始化一些默认的参数

  • default_timeout: 默认请求超时时间,单位秒,默认10s
  • default_headers: 默认请求头字典
  • default_resp_fmt: 默认响应格式json
  • client: httpx 异步客户端
  • response: 每次实例请求的响应

class AsyncHttpClient:
    """异步HTTP客户端"""

    def __init__(self, timeout=timedelta(seconds=10), headers: dict = None, resp_fmt: RespFmt = RespFmt.JSON):
        """构造异步HTTP客户端"""
        self.default_timeout = timeout
        self.default_headers = headers or {}
        self.default_resp_fmt = resp_fmt
        self.client = httpx.AsyncClient()
        self.response: httpx.Response = None

然后实现几个常用的请求,get、post、put、delete方法

async def post(self, url: str, data: dict = None, timeout: timedelta = None, resp_fmt: RespFmt = None, **kwargs):
    """POST请求

    Args:
        url: 请求URL
        data: 请求体数据字典
        timeout: 请求超时时间,单位秒
        resp_fmt: 响应格式,默认None 使用实例对象的 default_resp_fmt

    Returns:
        resp => dict or bytes
    """
    await self._request(HttpMethod.POST, url, data=data, timeout=timeout, **kwargs)
    return self._parse_response(resp_fmt)

每个请求方法冗余了一些常用的参数字段,例如

  • params 查询字符串入参

  • data body入参

  • timeout: 请求超时时间,单位秒

  • resp_fmt: 响应格式,默认None 使用实例对象的 default_resp_fmt

    • 默认json,一般我们http的数据交互都是使用 json了
  • **kwargs 预留其他关键字参数的入参

    • 这样有助于有些参数没想到要设计但经常用,可以通过kwargs来弥补

其实 get、post、put、delete方法没做什么事,就是标记了下使用什么请求方法、参数,最终都是让 _request方法处理。

async def _request(
        self,
        method: HttpMethod, url: str,
        params: dict = None, data: dict = None,
        timeout: timedelta = None, **kwargs
):
    """内部请求实现方法

    创建客户端会话,构造并发送HTTP请求,返回响应对象

    Args:
        method: HttpMethod 请求方法, 'GET', 'POST' 等
        url: 请求URL
        params: 请求查询字符串参数字典
        data: 请求体数据字典
        timeout: 超时时间,单位秒
        kwargs: 其他关键字参数

    Returns:
        httpx.Response: HTTP响应对象
    """
    timeout = timeout or self.default_timeout
    headers = self.default_headers or {}
    self.response = await self.client.request(
        method=method.value,
        url=url,
        params=params,
        data=data,
        headers=headers,
        timeout=timeout.total_seconds(),
        **kwargs
    )
    return self.response

处理完再根据指定的响应格式进行解析

def _parse_response(self, resp_fmt: RespFmt = None):
    """解析响应

    Args:
        resp_fmt: 响应格式

    Returns:
        resp Union[dict, bytes, str]
    """
    resp_fmt = resp_fmt or self.default_resp_fmt
    resp_content_mapping = {
        RespFmt.JSON: self.json,
        RespFmt.BYTES: self.bytes,
        RespFmt.TEXT: self.text,
    }
    resp_func = resp_content_mapping.get(resp_fmt)
    return resp_func()
    
  
def json(self):
    return self.response.json()

def bytes(self):
    return self.response.content

def text(self):
    return self.response.text

通过字典的方法来处理不同的解析格式,简化了 if elif 的操作,这里封装主要是将一些常用操作封装起来,让代码更简洁,当然也可以获取响应对象后,自己自由处理,最后看看封装后的使用Demo

from py_tools.connections.http import AsyncHttpClient
from py_tools.enums.http import RespFmt

async def httpx_demo(url):
    print("httpx_demo")

    async with httpx.AsyncClient() as client:
        resp = await client.get(url)
        # print(resp.text)
        return resp
        
        
async def main():
    url = "https://juejin.cn/"
    
    resp_obj = await httpx_demo(url)
    resp_text = resp_obj.text

    resp_text = await AsyncHttpClient().get(url, resp_fmt=RespFmt.TEXT)

if __name__ == '__main__':
    asyncio.run(main())

封装后简洁了许多,虽然方法有些冗余参数,但在业务中使用就不会出现好多嵌套的缩进,也牺牲了一些灵活性,因为只封装一些常用的请求操作,但一开始也想不全,只有在业务中不断的磨练,以及大家一起提建议贡献,才能慢慢的变得更好用。有时候适当的冗余封装也挺不错的。

四、同步http客户端

同步的其实 requests 已经够简洁了,没必要再封装了,这里为了统一公共库的调用,就二次封装下,思路还是跟异步的一样,有一点不一样的就是,get、post、put、delete方法返回的是 self 的引用,用于一些链式操作。一开始我想把异步的也变成链式调用,发现做不到,方法如果不await拿不到结果,返回的是 协程对象,所以一时半会弄不出来,就用了一个参数的方式来处理。

class HttpClient:
    """同步HTTP客户端

    通过request封装,实现了常见的HTTP方法,支持设置超时时间、请求参数等,链式调用

    Examples:
        >>> HttpClient().get("http://www.baidu.com").text
        >>> HttpClient().get("http://www.google.com", params={"name": "hui"}).bytes
        >>> HttpClient().post("http://www.google.com", data={"name": "hui"}).json

    Attributes:
        default_timeout: 默认请求超时时间,单位秒
        default_headers: 默认请求头字典
        client: request 客户端
        response: 每次实例请求的响应
    """

    def __init__(self, timeout=timedelta(seconds=10), headers: dict = None):
        """构造异步HTTP客户端"""
        self.default_timeout = timeout
        self.default_headers = headers or {}
        self.client = requests.session()
        self.response: requests.Response = None

    def _request(
            self,
            method: HttpMethod, url: str,
            params: dict = None, data: dict = None,
            timeout: timedelta = None, **kwargs
    ):
        """内部请求实现方法

        创建客户端会话,构造并发送HTTP请求,返回响应对象

        Args:
            method: HttpMethod 请求方法, 'GET', 'POST' 等
            url: 请求URL
            params: 请求查询字符串参数字典
            data: 请求体数据字典
            timeout: 超时时间,单位秒
            kwargs: 其他关键字参数

        Returns:
            httpx.Response: HTTP响应对象
        """
        timeout = timeout or self.default_timeout
        headers = self.default_headers or {}
        self.response = self.client.request(
            method=method.value,
            url=url,
            params=params,
            data=data,
            headers=headers,
            timeout=timeout.total_seconds(),
            **kwargs
        )
        return self.response

    @property
    def json(self):
        return self.response.json()

    @property
    def bytes(self):
        return self.response.content

    @property
    def text(self):
        return self.response.text

    def get(self, url: str, params: dict = None, timeout: timedelta = None, **kwargs):
        """GET请求

        Args:
            url: 请求URL
            params: 请求查询字符串参数字典
            timeout: 请求超时时间,单位秒

        Returns:
            self 自身对象实例
        """

        self._request(HttpMethod.GET, url, params=params, timeout=timeout, **kwargs)
        return self

    def post(self, url: str, data: dict = None, timeout: timedelta = None, **kwargs):
        """POST请求

        Args:
            url: 请求URL
            data: 请求体数据字典
            timeout: 请求超时时间,单位秒

        Returns:
            self 自身对象实例
        """
        self._request(HttpMethod.POST, url, data=data, timeout=timeout, **kwargs)
        return self

    async def put(self, url: str, data: dict = None, timeout: timedelta = None, **kwargs):
        """PUT请求

        Args:
            url: 请求URL
            data: 请求体数据字典
            timeout: 请求超时时间,单位秒

        Returns:
            self 自身对象实例
        """
        self._request(HttpMethod.PUT, url, data=data, timeout=timeout, **kwargs)
        return self

    async def delete(self, url: str, data: dict = None, timeout: timedelta = None, **kwargs):
        """DELETE请求

        Args:
            url: 请求URL
            data: 请求体数据字典
            timeout: 请求超时时间,单位秒

        Returns:
            self 自身对象实例
        """
        self._request(HttpMethod.DELETE, url, data=data, timeout=timeout, **kwargs)
        return self

---------------------------END---------------------------

题外话

当下这个大数据时代不掌握一门编程语言怎么跟的上脚本呢?当下最火的编程语言Python前景一片光明!如果你也想跟上时代提升自己那么请看一下.

在这里插入图片描述

感兴趣的小伙伴,赠送全套Python学习资料,包含面试题、简历资料等具体看下方。


👉优快云大礼包🎁:全网最全《Python学习资料》免费赠送🆓!(安全链接,放心点击)

一、Python所有方向的学习路线

Python所有方向的技术点做的整理,形成各个领域的知识点汇总,它的用处就在于,你可以按照下面的知识点去找对应的学习资源,保证自己学得较为全面。

img
img

二、Python必备开发工具

工具都帮大家整理好了,安装就可直接上手!img

三、最新Python学习笔记

当我学到一定基础,有自己的理解能力的时候,会去阅读一些前辈整理的书籍或者手写的笔记资料,这些笔记详细记载了他们对一些技术点的理解,这些理解是比较独到,可以学到不一样的思路。

img

四、Python视频合集

观看全面零基础学习视频,看视频学习是最快捷也是最有效果的方式,跟着视频中老师的思路,从基础到深入,还是很容易入门的。

img

五、实战案例

纸上得来终觉浅,要学会跟着视频一起敲,要动手实操,才能将自己的所学运用到实际当中去,这时候可以搞点实战案例来学习。

img

六、面试宝典

在这里插入图片描述

在这里插入图片描述

简历模板在这里插入图片描述

👉优快云大礼包🎁:全网最全《Python学习资料》免费赠送🆓!(安全链接,放心点击)

若有侵权,请联系删除

python-httpx 发送http2.0时代请求 在日常开发中,经常会发送各种各样的网络请求。Python中常用的网络请求库有requests、aiohttp、httpx等,httpx是基于Python3的新一代的网络请求库,它的功能很丰富,做个简答的介绍。 httpx是Python新一代的网络请求库,它包含以下特点 特点 基于Python3的功能齐全的http请求模块 既能发送同步请求,也能发送异步请求 支持HTTP/1.1和HTTP/2 能够直接向WSGI应用程序或者ASGI应用程序发送请求 安装 httpx需要Python3.6+(使用异步请求 阅读详情

相关推荐

从零构建桌面AI助手:基于LangGraph与Electron的Agent开发实践

AI Agent(智能体)作为连接大语言模型与现实世界的关键技术,正成为AI应用开发的核心范式。其核心原理在于通过规划、工具调用和状态管理,赋予模型自主执行复杂任务的能力。这一技术价值在于将LLM从单纯的对话接口,升级为能够感知环境、使用工具、并具备记忆的智能系统,极大地拓展了AI在自动化办公、数据分析、个性化服务等场景的应用边界。本文聚焦于一个具体的工程实践:如何整合LangGraph状态管理、RAG检索增强生成与Electron桌面框架,构建一个能处理本地文档、调用工具并拥有长期记忆的桌面智能助手。文中

weixin_33816946的博客 476

python --httpx异步请求

异步支持 HTTPX默认情况下提供标准的同步API,但是如果需要,还可以为你提供异步客户端的选项 。要发出异步请求,你需要一个httpx.AsyncClient import asyncio import httpx async def main(): async with httpx.AsyncClient() as client: response = await client.get('https://example.org/') loop = asyncio.get

weixin_44634704的博客 3614

Selenium与Playwright深度对比:架构、特性与选型实战指南

浏览器自动化是现代Web开发和测试中的关键技术,它允许程序模拟用户操作,实现自动化测试、数据采集和流程自动化。其核心原理是通过协议与浏览器引擎通信,控制页面元素并响应事件。在众多工具中,Selenium和Playwright代表了两种主流的技术路线。Selenium基于W3C标准的WebDriver协议,扮演“翻译官”角色,具有无与伦比的浏览器兼容性和庞大的多语言生态,但存在性能开销和等待机制复杂的问题。Playwright则采用直连浏览器开发者工具协议的“指挥官”模型,通过WebSocket实现高性能通信

weixin_33749131的博客 503

Python3的下一代HTTP客户端——HTTPX

在 Python 中,访问网络资源最有名的库就是requestsaiohttp和httpx。一般情况下,requests只能发送同步请求;aiohttp只能发送异步请求;httpx既能发送同步请求,又能发送异步请求。下面,就着重介绍一下httpx的使用方法。

bagell的博客 1554

Python自动化测试框架对比:unittest与pytest的深度解析与实战选型

在Python自动化测试领域,测试框架是保障软件质量与开发效率的核心工具。其核心原理在于通过组织、执行测试用例并验证预期结果,实现代码行为的自动化验证。从技术价值看,优秀的测试框架能显著降低维护成本、提升测试覆盖率,并促进持续集成流程。在应用场景上,无论是单元测试、集成测试还是端到端测试,选择合适的框架都至关重要。本文聚焦于Python生态中两大主流框架——unittest与pytest,通过对比其设计哲学、Fixture机制、断言系统及插件生态,并结合自动化测试与测试框架等热词,为不同项目阶段与团队背景下

weixin_33698043的博客 373

HLS加密流媒体自动化处理实战:从m3u8解密到任务完成

HTTP Live Streaming (HLS) 作为一种主流的自适应流媒体传输协议,通过将视频内容分割为连续的TS切片并使用m3u8索引文件进行组织,实现了跨平台的高效视频分发。其核心安全机制在于对TS切片进行AES-128加密,并通过动态密钥分发来保护内容,这构成了流媒体版权保护的技术基础。从工程实践角度看,理解并模拟客户端完整的密钥获取、切片下载与解密流程,对于开发自动化媒体处理工具、进行协议兼容性测试或构建个人学习辅助系统具有重要价值。本文聚焦于**加密m3u8**流媒体的自动化处理链路,详细剖析

weixin_42539414的博客 327

DeepSeek-V4-Pro与GLM-5.1代码生成模型实战评测:算法、源码与工程能力全解析

在人工智能与软件工程交叉领域,代码生成模型正成为提升开发效率的关键技术。其核心原理是基于大规模代码语料库进行预训练,通过深度学习理解编程语言的语法、语义和设计模式。这类技术的核心价值在于将自然语言需求转化为可执行代码,从而降低开发门槛、减少重复劳动。在实际应用场景中,开发者常利用其进行算法实现、代码审查、模块构建乃至系统架构设计。本次评测聚焦于当前备受关注的DeepSeek-V4-Pro和GLM-5.1两大模型,通过模拟真实开发任务,系统评估了它们在**线程安全LRU缓存**实现、**开源项目源码分析**以

weixin_33901641的博客 325

Gcat邮件C&C攻击:原理、PoC实现与防御策略

命令与控制(C&C)是网络攻击中的关键技术,攻击者通过隐蔽信道远程操控受害主机。传统C&C常使用恶意域名或IP,易被流量检测识别。现代攻击转向滥用Gmail等可信云服务,利用其HTTPS加密流量伪装正常通信,实现高隐匿性。这种“就地取材”攻击模式,通过IMAP/SMTP协议构建异步指令传递系统,将邮件主题或正文作为指令载体,周期性轮询执行系统命令并回传结果。从防御视角,需结合网络流量元数据分析、终端进程监控与用户行为基线,检测异常邮件客户端行为与规律性连接。理解此类攻击有助于构建更立体的安全防御体系,应对滥

Hi, Sun 426

如何在浏览器中构建完全开源的三国杀游戏体验

你是否曾经想过,能否在浏览器中直接体验完整的三国杀游戏,无需下载任何客户端?无名杀项目正是这样一个基于Web技术构建的完全开源的三国杀实现方案。这个项目不仅保留了经典的三国杀核心玩法,还提供了丰富的扩展能力和自定义选项,让玩家和开发者都能在开源框架下创造属于自己的游戏体验。 ## 项目架构与核心技术实现 无名杀采用了现代化的Web技术栈,将传统的桌面游戏完整迁移到了浏览器环境中。项目的核心架构

gitblog_00011的博客 801

Ceph对象存储与块存储选型实战:RGW vs RBD深度对比

对象存储和块存储是现代分布式存储的两大基础范式,其本质差异在于数据组织方式(离散对象 vs 连续块)、访问协议(HTTP RESTful vs 块设备驱动)及元数据管理模型(用户态分布式 vs 内核态强一致)。对象存储凭借水平扩展性、API友好性和海量小文件处理能力,成为AI数据湖、日志归档与Web应用的理想底座;块存储则依托低延迟随机IO和POSIX语义,支撑数据库、虚拟机等强事务场景。Ceph作为统一存储平台,通过RGW提供S3兼容对象接口,通过RBD暴露块设备能力,二者在真实生产中常共存协同。本文聚焦

weixin_30633405的博客 423

文件上传漏洞实战:绕过大小限制的攻防技术与SRC挖掘

文件上传是Web应用中的基础功能,其安全机制涉及前端校验、服务端验证及服务器配置等多层防护。攻击者常通过分析各层实现原理,寻找逻辑缺陷或配置疏漏,从而绕过限制上传恶意文件。在安全测试中,绕过文件大小限制具有重要技术价值,它往往是突破防御体系、实现后续利用的关键第一步。该技术广泛应用于后台管理、用户中心等文件处理场景,通过代理工具篡改请求、利用压缩解压逻辑差异、或构造条件竞争等方式,可有效规避常见校验。掌握文件上传漏洞的绕过技巧,能显著提升在SRC漏洞挖掘中发现中高危漏洞的成功率,是渗透测试人员必备的实战能力

weixin_33701294的博客 349

OpenClaw部署实战:Node.js环境配置与Qwen网关接入全解析

AI Agent网关是连接大模型与业务逻辑的关键中间件,其核心在于模型抽象、智能路由与多源调度。OpenClaw作为轻量级开源模型网关框架,不运行模型,而是通过标准化协议统一纳管Qwen、DeepSeek、Ollama等异构API服务,实现能力抽象、故障熔断与多模态协同。它依赖Node.js生态构建,因其在流式响应(SSE/WebSocket)、CLI与前端类型共用、动态插件加载等方面具备不可替代的工程优势。实际部署中,90%问题源于Node.js版本错配(如v24+不兼容)、全局npm权限失控及Qwen端

weixin_33692284的博客 474

AI智能体框架深度对比:Hermes Agent与OpenClaw的架构、选型与实战

在AI应用开发领域,智能体(Agent)框架正成为连接大语言模型(LLM)与实际业务操作的关键桥梁。其核心原理在于实现“感知-思考-行动”的自主循环,通过工具调用(Tool Calling)和任务规划(Task Planning),赋予LLM理解和执行复杂指令的能力。这一技术价值在于将AI从对话交互升级为能驱动工作流的自动化执行者,广泛应用于自动化办公、智能客服、数据分析和跨系统集成等场景。本文聚焦于当前两大主流框架Hermes Agent和OpenClaw,深入剖析其架构差异:前者以智能体驱动为核心,强调

weixin_30239339的博客 776

国产大模型编程实战评测:GLM-5.1、Qwen3.6-Plus与Claude Opus工程落地对比

大模型编程能力正从概念验证迈向真实工程交付,核心在于代码生成是否符合生产级规范、能否通过本地可复现的端到端验证。本文聚焦AI辅助开发中的关键环节——技术文档协作平台的全栈实现,覆盖React+FastAPI架构设计、SQLite数据建模、Docker容器化部署及严格代码审查,深入剖析国产大模型(GLM-5.1、Qwen3.6-Plus)在中文技术语境下的工程适配性、上下文一致性与调试协同能力。相比通用代码评测,本实践强调环境真实性(M2 Mac本地运行)、约束明确性(禁用模板/插件)和交付闭环性(一键doc

aoe41606的博客 406

电商秒杀自动化技术解析:从网络请求到风控对抗的工程实践

网络爬虫与自动化测试是当今互联网开发中的基础技术,其核心原理是通过程序模拟用户行为,实现数据的自动化采集与交互。在技术实现层面,这通常涉及HTTP/HTTPS协议通信、会话管理、以及动态内容的解析。从工程价值看,这类技术能显著提升数据获取与流程处理的效率,广泛应用于市场分析、软件测试和业务流程自动化等场景。特别是在电商领域,高并发请求处理与风控对抗成为关键技术挑战。本文以“抢购助手”为例,深入探讨了如何通过异步高并发请求(如aiohttp)优化网络通信,并详细解析了如何利用动态代理IP池等策略应对平台的风控

hqmln的博客 534

转转反爬虫机制深度解析:从JS逆向到工程化爬虫系统构建

在Web数据采集领域,反爬虫机制是开发者必须面对的核心挑战。其基本原理是通过技术手段区分自动化脚本与真实用户访问,保护网站数据安全与服务器资源。从技术价值看,理解反爬机制不仅能提升数据采集效率,更是深入掌握现代Web应用架构、网络协议及安全策略的实践途径。常见的应用场景包括市场数据分析、价格监控和舆情监测等。本文聚焦转转平台这一典型案例,其反爬体系融合了动态令牌、请求签名、行为指纹检测及验证码等多层防御。其中,JavaScript逆向与自动化浏览器驱动是突破动态令牌的关键技术,而构建包含代理IP池、请求调度

weixin_33693070的博客 509
上一篇: 一步到位!Python中Reduce函数轻松解决复杂数据聚合
下一篇: 用 Python 脚本实现电脑唤醒后自动拍照 截屏并发邮件通知
Python_P叔
博客等级 码龄3年 5455粉丝 827原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值