在这个快节奏的时代，时间成为了我们最宝贵的资源。  
如何高效利用时间，不仅关系到工作的效率，更影响着生活的质量。  
在日常生活和~~工作~~（摸鱼，划水）当中，输入是一个频繁且必不可少的行为。  
一个高效的输入法对于提升我们的工作效率和时间管理至关重要。  
目前常见的输入法有拼音、五笔、笔画，语音。  
而在这些输入法中，我个人觉得综合能力最好的是双拼输入法。



## 双拼输入法的优势
双拼输入法结合了全拼的易学易用和五笔的高效精准两大优势。它的主要特点包括：

1. **准确率高**：辅码的加入大大降低了重码率，使得输入更为精准。
2. **易于学习**：相比复杂的五笔，双拼的学习难度更低，更适合大众。
3. **效率提升**：相比全拼，双拼在输入速度上有显著提升，尤其是在处理长词汇时更显优势。

## 双拼的工作原理
我们先区分一下双拼，全拼，简拼。
下面表格，对比了双拼、全拼和简拼输入法的主要特点（这个是GPT给出来的）：

| 输入法 | 定义 | 输入方式举例（“中国”） | 特点 | 适用人群 |
| ------ | ---- | ---------------------- | ---- | -------- |
| 全拼   | 使用汉语拼音的完整音节来输入汉字 | zhongguo | 需输入完整拼音，易学习 | 汉语初学者、对汉语拼音熟悉的用户 |
| 双拼   | 将每个拼音音节缩减为两个键位的输入方式 | vsgo（微软双拼为例） | 提高输入速度，需适应新的键位映射 | 经常使用文字输入的用户 |
| 简拼   | 只输入汉字拼音首字母的方式 | zg | 输入极快，但需熟悉拼音和候选字词 | 对中文拼音非常熟悉且能迅速识别候选字词的用户 |


全拼就是日常大家使用最多的拼音输入法。  
简拼没什么可说的，直接打首字母，在个别时候有用。  
前面两个都很好理解，双拼第一看上去有点懵逼，看完图和我的讲解立刻就明白。

![微软双拼.png](https://img.huacai.one/huacai-blog/34cb50311819f5282e0e5c98adf5bb34.%C3%A5%C2%BE%C2%AE%C3%A8%C2%BD%C2%AF%C3%A5%C2%8F%C2%8C%C3%A6%C2%8B%C2%BC.webp)

看完还是没理解，没关系让我细说。  
中国使用全拼的时候是`zhongguo`，使用双拼是`vsgo`到底是个啥情况。  
首先，让我们一起回顾小学一年级学过的拼音。
- 拼音是有声母和韵母
- 韵母是有单韵母和双韵母
- 任何的汉字都能用声母+韵母来表示，其中声母可以为空，韵母不可以。  

OK，小学一年级知识复习完毕，开始学习微软双拼。    
微软双拼在小学一年级学过的知识基础上做了定义：
- 任何一个汉字都是可以用两个键来表示，第一个是声母，第二个是韵母。  
- 如果没有声母，就用字母`o`来假装声母  

`中`的声母是`zh`，在键位表中对应是`v`![image.png](https://img.huacai.one/huacai-blog/365cf5023c855cb683afaeef0262d992.image.webp)；韵母是`ong`，对应`s`![image.png](https://img.huacai.one/huacai-blog/fa5b41613213843a50e9d96179abdd13.image.webp)，所以最后只需要输入`vs`，![image.png](https://img.huacai.one/huacai-blog/776c817358d809ebcf00ba16dc900f85.image.webp)

`国`的声母是`g`，是单个声母，所以就不需要变化，一样是输入`g`即可。实际上特殊的声母只有三个`zh ch sh` 韵母是`uo`，对应字母是`o` 
![image.png](https://img.huacai.one/huacai-blog/74587ad7a5fee8b043609cd9e1100997.image.webp)

`中国`在双拼中完整表示方式

![image.png](https://img.huacai.one/huacai-blog/db8a13d5ee1d4ddc55f7a4d6bf840c67.image.webp)
在这里搜狗输入法很贴心的帮我们在中间加了一个`'`来作分隔符  

到这里我相信你已经明白了双拼是怎么一回事了吧，是不是很简单呢。  
双拼比全拼更加高效的原理，我相信也很直观了，双拼任何字都只需要两个字母就能搞定，综合起来肯定会比要完整输入的全拼更加高效。

## 学习双拼的方法

既然原理已经搞明白，那么剩下来的就是实践了。  
根据我个人的经验，只需要花费3天左右，输入速度就能跟上全拼的速度。  
字母的对应关系要怎么记忆呢？这个是劝退很多人的地方。  
首先我们得接受一个事实，新上手的东西肯定需要一个过渡期。  
我个人推荐两种方法：

- 方法1：
把对应关系表放在电脑桌面，忘记就立刻查看。

- 方法2：
想象记忆法，比如`s`表示的韵母是`iong`和`ong`，就想象成`s`身材，跟胸有关系，那么就很容易记住啦。`z`躲在左下角，很鸡贼`zei`，那么就很容易记录`z`表示`zei`。剩下的就靠你们自己发挥喽

## 一些疑问
-  我现在用全拼就很舒服了，为啥还要学这玩意？  
>  是的，完全可以继续全拼。本文观点仅提供给希望改进输入方式，提高效率的小伙伴

- 我现在的问题不是输入快不快，而是不知道要输入什么，你懂吗？
> 本文无法解决输入什么的问题，是基于已经知道要输入什么的前提讨论

- 双拼能在手机和电脑上使用吗？哪些输入能使用啊？
> 是的，手机和电脑都很好的支持，包括Mac和Windows，系统自带的输入都能完美支持，第三方输入法也是完全没问题

## 总结
- 双拼输入法有一点学习门槛，长期使用收益很明显，适合长期主义和追求高效输入的人
- 本文仅介绍了双拼的基本使用和原理，没有提及双拼的进阶使用方式，辅助码

我的高效工具《一》：双拼输入法

# 1、背景
最近在技术群里面讨论到使用python操作jmeter的话题  
有人提到了subprocess启动命令行来操作jmeter，也有人提到了jmeterapi，另外也有人提到了pymeter  
除了这些，实际上我之前也基于docker+subprocess来操作jmeter的项目  
jmeterapi这个库年久失修，就不想搞它了，下面跟我一起试试pymeter吧  



![image.png](https://img.huacai.one/huacai-blog/93db27ef5b3929849758d5b0893b11bb.image.webp)

![image.png](https://img.huacai.one/huacai-blog/c4d0eb1c94633dc8b9c378cb03fc5b36.image.webp)

# 2、环境准备
直接参考项目的说明即可
![image.png](https://img.huacai.one/huacai-blog/9ff4e9bbed51adf92d8bbf6ea68df8d4.image.webp)


# 3、Jmeter测试
## 3.1 写测试用例
使用方法比较简单，设置GUI类似，只是前后顺序不相同：
- 创建线程组
- 把sample，断言，抽取等配置加入线程组
- 创建报告收集器
- 把线程组和报告收集器加入测试计划
- 运行测试计划

```python
# 省略 import

class TestTestPlanClass(TestCase):
    def test_1(self: Any) -> None:
        # 创建一个JsonExtractor对象,参数分别是"variable"和"args.var"
        json_extractor: JsonExtractor = JsonExtractor("variable", "args.var")

        # 创建一个均匀随机计时器，时间间隔在1000至2000毫秒之间
        timer: UniformRandomTimer = UniformRandomTimer(1000, 2000)

        ra: ResponseAssertion = ResponseAssertion.contains_substrings("var")
        # 创建一个HttpSampler对象，用于发送HTTP请求并记录响应
        http_sampler: HttpSampler = HttpSampler(
            "Echo",
            "http://119.91.147.215:18080/get?var=${__Random(0,10)}",
            timer,
            json_extractor,
            ra,
        )

        # 创建一个DummySampler对象，仅用于模拟一些操作，不实际执行任何网络请求
        dummy_sampler: DummySampler = DummySampler("dummy ${variable}", "hi dummy")

        # 创建一个线程组，其中包含10个线程，每个线程的运行时间为1秒，整个线程组的持续时间为60秒
        tg: ThreadGroupWithRampUpAndHold = ThreadGroupWithRampUpAndHold(
            100, 3, 60, http_sampler, dummy_sampler, name="Some Name"
        )

        # 创建一个HTML报告生成器
        html_reporter: HtmlReporter = HtmlReporter()

        # 创建一个测试计划，其中包含tg线程组和html_reporter报告生成器
        tp: TestPlan = TestPlan(tg, html_reporter)

        # 运行测试计划，返回统计数据
        stats = tp.run()

        # 打印测试的统计數據
        print(
            f"duration= {stats.duration_milliseconds}",
            f"mean= {stats.sample_time_mean_milliseconds}",
            f"min= {stats.sample_time_min_milliseconds}",
            f"median= {stats.sample_time_median_milliseconds}",
            f"90p= {stats.sample_time_90_percentile_milliseconds}",
            f"95p= {stats.sample_time_95_percentile_milliseconds}",
            f"99p= {stats.sample_time_99_percentile_milliseconds}",
            f"max= {stats.sample_time_max_milliseconds}",
            sep="\t",
        )

        # 断言99%分位数的样本时间小于2000毫秒
        self.assertLess(stats.sample_time_99_percentile_milliseconds, 30)
  ```
## 3.2 运行和收集结果
### 3.2.1 pycharm启动
如果你使用的PyCharm，会自动识别
  
![image.png](https://img.huacai.one/huacai-blog/d6fea1354aae24357ad2608467dfea1c.image.webp)

### 3.2.2 命令行启动

```shell
# rikasai @ huacai-mbp in ~/code/python/pymeter-demo [22:23:38] C:1
$ python main.py
 +    579 in 00:00:07 =   86.2/s Avg:   139 Min:     9 Max:   500 Err:     0 (0.00%) Active: 100 Started: 100 Finished: 0
 +   3964 in 00:00:30 =  131.9/s Avg:   142 Min:     8 Max:   500 Err:     0 (0.00%) Active: 100 Started: 100 Finished: 0
 =   4543 in 00:00:37 =  123.6/s Avg:   142 Min:     8 Max:   500 Err:     0 (0.00%)
duration= 64265 mean= 144       min= 8  median= 54      90p= 404        95p= 451        99p= 491        max= 500
F +      7 in 00:00:03 =    2.1/s Avg:   864 Min:   225 Max:   977 Err:     0 (0.00%) Active: 6 Started: 6 Finished: 0
duration= 14276 mean= 323       min= 223        median= 230     90p= 960        95p= 973        99p= 1012       max= 1207
.
======================================================================
FAIL: test_1 (__main__.TestTestPlanClass)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/Users/rikasai/code/python/pymeter-demo/main.py", line 67, in test_1
    self.assertLess(stats.sample_time_99_percentile_milliseconds, 30)
AssertionError: 491 not less than 30

----------------------------------------------------------------------
Ran 2 tests in 79.631s

FAILED (failures=1)
(pymeter-demo) 
```
> 需要注意的是，这里断言失败，是unittest断言失败，这个数据并不会在jmeter报告中体现 
### 3.2.3 查看报告
报告会自动生成在output文件夹下面，一个test函数对应一份报告  
使用浏览器打开index.html就能看到完整的报告  
![image.png](https://img.huacai.one/huacai-blog/9d48bfc0b2bb947f13a047dcadcb613e.image.webp)

![image.png](https://img.huacai.one/huacai-blog/2198e03e0591959919a4fe2fc1ba1d27.image.webp)

![image.png](https://img.huacai.one/huacai-blog/2cea7b734517aba920ff569b2e3ff43a.image.webp)

![image.png](https://img.huacai.one/huacai-blog/1f6cc386df82364aeb896e955b7fc6ec.image.webp)

# 4、总结
- python结合jmeter-dsl的特性，使用起来很方便
- 常用的部分功能（线程组，部分断言，报告）已经支持
- 目前整体完成度还是偏低，插件，复杂的断言，各种sample还未支持

# 5、参考链接：
- 我的docker jmeter项目：https://github.com/lihuacai168/Jmeter-Toolkit
- pymeter项目：https://github.com/eldaduzman/pymeter

Python操作Jmeter探索：pymeter实操指南

# 引言
在看过OpenAI的开发者大会之后，我一直就很期待着GPTs的表现。  
今天打开ChatGPT官网之后，它终于来了！！！  
接下来，给大家演示一下它的威力，简直是碉堡了！  



![image.png](https://img.huacai.one/huacai-blog/42143482229cdaa0ca842428961a0189.image.webp)

# 知识库
很久之前，就想用大模型做一个知识库，毕竟现在传统的wiki知识库搜索效率真的不高，并且搜索关键字有一大堆类似的内容，需要人为一个个去过滤。
用过ChatGPT都知道，它的自然语言理解能力很好，但它有个很致命的缺点，它训练的材料是来自互联网。  
我们私有的文档，它肯定不知道。
但现在GPTs的出现，允许我们自己上传文档，打造属于自己的GPT！  

## 先看效果

以我的开源项目为例：  
使用文档是这里https://www.yuque.com/lihuacai/fasterunner/toq6z9  
我把语雀文档导出为PDF，直接丢给GPTs（详细创建步骤下面说）  

直接问频率最高的一个问题：“如何部署”  
![image.png](https://img.huacai.one/huacai-blog/26eb0057ff47af99495ca4686bf90a36.image.webp)

这个问题它给出的答案，我很满意，可以给到90+，完全没问题。  
优点：
- 提问时，完全不需要再给上下文，理解能力很棒
- 回答的很准确核心步骤都有了，很有条理，也不啰嗦，很好的概括语雀文档的内容
- 对PDF的识别很准确，这全部是PDF的内容

不足：
- 没有说先拉取代码。  
- 启动服务没有给出完整命令

但这些都是小瑕疵，没啥问题

![image.png](https://img.huacai.one/huacai-blog/e7bf6563ad71cf9971127a4a2d282a85.image.webp)

# GPTs配置

## 前提

你首先是`Plus`用户

## 配置步骤
非常简单

### 创建GPT
![image.png](https://img.huacai.one/huacai-blog/90de5dcc229d62b788c76d66e8c2b35e.image.webp)

### 自定义配置
![image.png](https://img.huacai.one/huacai-blog/4a8cf34cf172ffe655d549541c345eff.image.webp)

![image.png](https://img.huacai.one/huacai-blog/5c619a4dcd2ec48d03fcb9c1ce4d3085.image.webp)

### 发布GPT
![image.png](https://img.huacai.one/huacai-blog/f831da2ed1a4c75c5048e7b251bf906a.image.webp)

# 总结
- GPTs的功能非常强大，大有发展前景
- GPTs也非常简单（只需是Plus和网络正常）
- 企业本地私有化部署将会有很大的市场

GPTs,iPhone的App Store时代来了

# 引言
昨晚在技术群里面讨论到单元测试和代码的测可性  
![image.png](https://img.huacai.one/huacai-blog/79f771072a02f179085016bb972a8266.image.webp)



让我想起来曾犯过的一些错误。  
现在需要实现一个定时执行的任务函数 `mytask`，其核心功能是调用一个第三方接口，并使用当前日期 `today` 作为参数。这个函数的设计直接从系统获取当前日期，并没有提供修改日期的选项。

示例代码：
```python
def mytask():
    dt = datetime.today()  # 获取并使用当前日期
    # 调用第三方接口
    # 更新数据库
```

这种设计在日常运行中没有问题，但是当遇到需要针对特定日期重新执行任务的情况时，就显得不够灵活。  
例如，在一个愉快的周末后，领导告诉你第三方接口上周五出现了bug，导致数据出错，需要重新获取数据。  
这时，由于 `mytask` 函数中的日期是动态获取的，重新执行任务并不能获得上周五的数据。

一种粗暴的解决方案是直接修改代码中的 `today` 为上周五的日期，重新部署并执行一次。然而，这种方法显然不是长久之计。

更好的做法是将日期作为一个参数传递给 `mytask` 函数，这样既可以保持定时任务的正常运行，也可以在需要时手动指定日期来重跑任务。

优化后的代码：
```python
from typing import Optional
from datetime import datetime

def mytask(dt: Optional[datetime] = None):
    dt = dt or datetime.today()  # 允许传递特定日期
    # 调用第三方接口
    # 更新数据库
```

这样，`mytask` 函数就不再依赖于固定的日期值，而是可以根据需要传入任何日期。当需要重新拉取特定日期的数据时，只需要手动调用 `mytask` 并传入相应的日期参数即可。这种设计增强了代码的灵活性和可测性，使得维护和测试变得更加方便。
下面将通过四个例子继续探讨如何改进代码的可测性。

# 例1：隔离外部依赖以便模拟测试

不良示范：
```python
def send_email():
    smtp_server.connect()  # 直接连接SMTP服务器
    # 发送邮件
```
好的代码示范：
```python
from typing import Any

def send_email(smtp_server: Any):
    smtp_server.connect()  # 将SMTP服务器作为参数传递
    # 发送邮件
```
将外部服务如SMTP服务器作为参数传递，方便在测试中使用模拟对象。

# 例2：分离业务处理器和请求处理

不良示范：
```python
# 依赖于具体的请求对象，与特定的web框架紧密耦合
from flask import request

def process_request():
    data = request.get_json()  # 直接从请求对象中获取数据
    # 在此处包含数据处理逻辑
    # ...
    return {"status": "success", "data": processed_data}

```
好的代码示范：
```python
# 解耦数据处理逻辑，不再依赖特定的请求对象或web框架
from typing import Dict

def process_data(data: Dict) -> Dict:
    # 独立的数据处理逻辑
    # ...
    return {"status": "success", "data": processed_data}

# Web框架的请求处理函数只负责调用业务逻辑函数
def api_endpoint(request_data: Dict):
    # 从请求中提取数据并传递给独立的处理函数
    result = process_data(request_data)
    return result
```
在这种方式中，process_data 函数现在是一个纯粹的业务逻辑函数，它只关心数据的处理，不再关心数据来源。  
而 api_endpoint 函数则作为web框架的入口点，负责接收请求和调用业务逻辑函数。  
这样的分离使得 process_data 更容易进行单元测试，同时也提高了代码的可重用性。
# 例3：使用配置文件而非硬编码

不良示范：
```python
def connect_database():
    db = "MySQL"  # 数据库类型硬编码
    # 连接数据库
```
好的代码示范：
```python
from typing import Any

def connect_database(config: Any):
    db = config.database_type  # 从配置文件读取数据库类型
    # 连接数据库
```
避免硬编码，使用配置文件来管理设置，这样可以在不同环境下灵活配置，同时便于测试。

# 例4：采用单一职责原则

不良示范：
```python
def manage_user(request):
    if request.type == "create":
        # 创建用户
    elif request.type == "delete":
        # 删除用户
```
好的代码示范：
```python
from typing import Any

def create_user(user_data: Any):
    # 仅包含创建用户的逻辑

def delete_user(user_id: int):
    # 仅包含删除用户的逻辑
```
按照单一职责原则设计函数，每个函数只做一件事情，这样便于单元测试和维护。

# 总结
以上五个例子展示了代码可测性的重要性以及提升可测性的常见策略。  
通过参数化输入、隔离外部依赖、解耦业务逻辑、使用配置文件和单一职责原则，可以构建出更健壮、更易于测试和维护的代码。

掌握这五招，让你的代码质量翻倍！

# 1.背景

在接口测试时,绝大部分的响应都json格式,json的取值就一定绕不过jsonpath.  
某天,就在技术群讨论了jsonpath相关的问题.  
讨论归讨论,结果最终还是的看实际代码怎么样.  
接下来,将会实测python中几个常用jsonpath库(`jsonpath,jsonpath-ng,jmespath,gjson`)性能到底如何 

![image.png](https://img.huacai.one/huacai-blog/fdda1c01b401b6fb58290fa32b446154.image.webp)

# 2.耗时和内存测试

## 2.1 运行1次的耗时和内存
```shell
/Users/rikasai/.virtualenvs/jsonpath_compare/bin/python /Users/rikasai/code/python/jsonpath_compare/main.py 
test_jsonpath 总耗时: 0.002014 秒
test_jsonpath 使用了 0.038136 MB 内存，峰值为 0.039424 MB

test_gjson 总耗时: 0.001517 秒
test_gjson 使用了 0.023019 MB 内存，峰值为 0.028319 MB

test_jsonpath_ng 总耗时: 0.027746 秒
test_jsonpath_ng 使用了 0.2931 MB 内存，峰值为 0.323259 MB

test_jmespath 总耗时: 0.000571 秒
test_jmespath 使用了 0.022307 MB 内存，峰值为 0.025619 MB
```
运行一次的结果大概已经能看到jsonpath_ng,不管内存占用还是耗时都是跟另外三个相差甚远  

## 2.2 运行1000次的耗时和内存
```shell
/Users/rikasai/.virtualenvs/jsonpath_compare/bin/python /Users/rikasai/code/python/jsonpath_compare/main.py 
test_jsonpath 总耗时: 0.126801 秒
test_jsonpath 使用了 0.218614 MB 内存，峰值为 2.219974 MB

test_gjson 总耗时: 0.264562 秒
test_gjson 使用了 0.108182 MB 内存，峰值为 2.135345 MB

test_jsonpath_ng 总耗时: 17.054877 秒
test_jsonpath_ng 使用了 3.061619 MB 内存，峰值为 6.086255 MB

test_jmespath 总耗时: 0.137950 秒
test_jmespath 使用了 0.137203 MB 内存，峰值为 1.973523 MB
```
1次可能说明不了问题,运行1000次, 跟运行1次时结果是类似.  
可以看到jsonpath_ng相比另外三个要,耗时和内存占用都是非常离谱,完全不应该放在一起比较那种  
另外三个jmespath,jsonpath,gjson不相伯仲  

# 3.性能分析

## 3.1 cProfile对比
下面分别对比这四个库,json执行一次jsonpath取值,涉及函数调用次数和原始调用耗时  
完整的调用统计非常多,只放出调用次数较多的部分,按照调用次数到序排序  
### 3.1.1 jsonpath

> 在cProfile的输出中，ncalls列表示函数被调用的次数。看到219/196这意味着函数被递归地调用了。  
> 第一个数字219表示函数被调用的总次数。  
> 第二个数字196表示函数被非递归地调用的次数。
```shell
/Users/rikasai/.virtualenvs/jsonpath_compare/bin/python /Users/rikasai/code/python/jsonpath_compare/main.py 
         1417 function calls (1350 primitive calls) in 0.001 seconds

   Ordered by: call count

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
      251    0.000    0.000    0.000    0.000 {method 'append' of 'list' objects}
  219/196    0.000    0.000    0.000    0.000 {built-in method builtins.len}
      160    0.000    0.000    0.000    0.000 {built-in method builtins.isinstance}
      119    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:164(__getitem__)
       61    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:233(__next)
       56    0.000    0.000    0.000    0.000 {built-in method builtins.min}
       50    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:160(__len__)
       46    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:254(get)
       33    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:172(append)
       33    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:249(match)
       25    0.000    0.000    0.000    0.000 {built-in method builtins.ord}
     24/8    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:174(getwidth)
```
### 3.1.2 gjson
```shell
         1167 function calls (1088 primitive calls) in 0.001 seconds

   Ordered by: call count

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
      176    0.000    0.000    0.000    0.000 {method 'append' of 'list' objects}
  164/146    0.000    0.000    0.000    0.000 {built-in method builtins.len}
      127    0.000    0.000    0.000    0.000 {built-in method builtins.isinstance}
       59    0.000    0.000    0.000    0.000 {method 'startswith' of 'str' objects}
       52    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:164(__getitem__)
       42    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:233(__next)
       34    0.000    0.000    0.000    0.000 {built-in method builtins.min}
       27    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:254(get)
       26    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:160(__len__)
       26    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:249(match)
```
### 3.1.3 jsonpath_ng
```shell
 24933 function calls (24438 primitive calls) in 0.013 seconds

   Ordered by: call count

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
     3668    0.000    0.000    0.000    0.000 {method 'get' of 'dict' objects}
     3634    0.000    0.000    0.000    0.000 {method 'append' of 'list' objects}
     2528    0.000    0.000    0.000    0.000 {built-in method builtins.id}
     2241    0.000    0.000    0.000    0.000 {built-in method builtins.getattr}
1623/1420    0.000    0.000    0.000    0.000 {built-in method builtins.len}
      984    0.001    0.000    0.002    0.000 /Users/rikasai/.virtualenvs/jsonpath_compare/lib/python3.9/site-packages/ply/yacc.py:2165(lr0_goto)
      897    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:233(__next)
      850    0.000    0.000    0.000    0.000 {built-in method builtins.isinstance}
      795    0.000    0.000    0.000    0.000 /Users/rikasai/.virtualenvs/jsonpath_compare/lib/python3.9/site-packages/ply/yacc.py:127(__getattribute__)
      795    0.000    0.000    0.000    0.000 /Users/rikasai/.virtualenvs/jsonpath_compare/lib/python3.9/site-packages/ply/yacc.py:130(__call__)
      622    0.000    0.000    0.000    0.000 {method 'match' of 're.Pattern' objects}
      386    0.000    0.000    0.000    0.000 /Users/rikasai/.pyenv/versions/3.9.11/lib/python3.9/sre_parse.py:164(__getitem__)
      299    0.000    0.000    0.000    0.000 {built-in method builtins.min}
```

### 3.1.4 jmespath
```shell
163 function calls (154 primitive calls) in 0.000 seconds

   Ordered by: call count

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
       28    0.000    0.000    0.000    0.000 /Users/rikasai/.virtualenvs/jsonpath_compare/lib/python3.9/site-packages/jmespath/lexer.py:129(_next)
       14    0.000    0.000    0.000    0.000 /Users/rikasai/.virtualenvs/jsonpath_compare/lib/python3.9/site-packages/jmespath/parser.py:463(_current_token)
       12    0.000    0.000    0.000    0.000 /Users/rikasai/.virtualenvs/jsonpath_compare/lib/python3.9/site-packages/jmespath/lexer.py:26(tokenize)
       11    0.000    0.000    0.000    0.000 {method 'get' of 'dict' objects}
       11    0.000    0.000    0.000    0.000 {built-in method builtins.getattr}
       10    0.000    0.000    0.000    0.000 /Users/rikasai/.virtualenvs/jsonpath_compare/lib/python3.9/site-packages/jmespath/parser.py:460(_advance)
      8/1    0.000    0.000    0.000    0.000 /Users/rikasai/.virtualenvs/jsonpath_compare/lib/python3.9/site-packages/jmespath/visitor.py:87(visit)
        6    0.000    0.000    0.000    0.000 {built-in method builtins.len}
        6    0.000    0.000    0.000    0.000 /Users/rikasai/.virtualenvs/jsonpath_compare/lib/python3.9/site-packages/jmespath/parser.py:469(_lookahead_token)
        4    0.000    0.000    0.000    0.000 /Users/rikasai/.virtualenvs/jsonpath_compare/lib/python3.9/site-packages/jmespath/parser.py:466(_lookahead)
      3/1    0.000    0.000    0.000    0.000 /Users/rikasai/.virtualenvs/jsonpath_compare/lib/python3.9/site-packages/jmespath/parser.py:118(_expression)
```

### 3.1.5 cProfile结论
cProfile结果和上面的耗时和结果大体是吻合的  
很明显的看到jsonpath_ng取值一次居然涉及到了24933次函数调用   
而jsonpath和gjson都是一千多次,jmespath最好,仅仅需要163次,遥遥领先!  

还是有一个疑惑,上面1000次耗时和内存测试,发现jmespath,jsonpath,gjson是不相伯仲的  
但jmespath函数调用确实比另外两个相差了至少1000次,结果似乎对不上  

把运行次数拉大到10000次,结果就很明显了,确实是jmespath更强

```shell
test_jsonpath 总耗时: 1.746682 秒
test_jsonpath 使用了 0.210114 MB 内存，峰值为 19.831589 MB

test_gjson 总耗时: 2.730377 秒
test_gjson 使用了 0.184749 MB 内存，峰值为 18.914425 MB

test_jmespath 总耗时: 1.194248 秒
test_jmespath 使用了 0.127859 MB 内存，峰值为 18.852175 MB
```
> 为什么这里jsonpath_ng没有10000次的测试结果,因为太消耗时间了,被我手动终止...

## 3.2 火焰图
四个库同时运行1000次,因为jsonpath_ng占用时间太大了  
可以看到,大部分的耗时都是在这个函数`parse_token_stream（isonpath_ng/parser.py:47）`  
如果需要优化,可以从这个地方着手
![image.png](https://img.huacai.one/huacai-blog/c5714b3a8a0ec2a9c0479264b524d139.image.webp)


# 4.总结

通过以上的测试和分析，我们可以得出以下结论：

1. 在耗时和内存占用方面，`jsonpath-ng`的表现是最差的，与其它三个库相比，无论是运行1次还是1000次，`jsonpath-ng`的耗时和内存占用都是最高的。因此，在性能要求较高的场景下，`jsonpath-ng`不是一个好的选择。

2. `jmespath`在运行1次和1000次的耗时和内存占用都表现较好，且cProfile的结果显示`jmespath`的函数调用次数也是最少的，因此，`jmespath`是性能最好的一个选项。

3. `jsonpath`和`gjson`在耗时和内存占用方面表现相近，且都优于`jsonpath-ng`。在函数调用次数方面，`jsonpath`和`gjson`也相近，但略多于`jmespath`。

综上所述，如果你在寻找一个性能优越的jsonpath库，`jmespath`是最佳选择。而`jsonpath`和`gjson`则是性能较为中等的选项，`jsonpath-ng`则是最不推荐的选项。

# 5.附录
本次测试的所有代码和用到的数据都会可以直接在我的GitHub仓库看到
https://github.com/lihuacai168/jsonpath_compare