python中 jsonchema 与 shema 效率比较

Love The Way You Lie 2021-11-02 02:12 251阅读 0赞

前面几篇文章总结了python中jsonschema与schema的用法，这里测试一下两者的效率：

**上代码：**

import time
    from jsonschema import validate, draft7_format_checker
    from jsonschema.exceptions import SchemaError, ValidationError
    from schema import Schema, And, Optional, SchemaError, Regex
    
    
    def tags_check(tags_list):
        if len(tags_list) < 1 or len(tags_list) > 5:
            return False
        for tag in tags_list:
            if len(tag) < 2:
                return False
        return True
    
    
    def id_generator(start=1):
        while 1:
            yield start
            start += 1
    
    
    class DataFactory(object):
        def __init__(self):
            self.id_g = id_generator()
    
        def create_data(self):
            idn = next(self.id_g)
            price = 5.5 + idn
            json_data = {
                "id": idn,
                "name": "jarvis手册%d" % idn,
                "info": "贾维斯平台使用手册%d" % idn,
                "price": price,
                "tags": ["jar"],
                "date": "2019-5-25",
                "others": {
                    "info1": "1111",
                    "info2": "2222"
                }
            }
            return json_data
    
    
    schema1 = {
        "$schema": "http://json-schema.org/draft-07/schema#",
        "title": "book info",
        "description": "some information about book",
        "type": "object",
        "properties": {
            "id": {
                "description": "The unique identifier for a book",
                "type": "integer",
                "minimum": 1
            },
            "name": {
                "description": "book name",
                "type": "string",
                "minLength": 3,
                "maxLength": 30
            },
            "info": {
                "description": "simple information about book",
                "type": "string",
                "minLength": 10,
                "maxLength": 60
            },
            "price": {
                "description": "book price",
                "type": "number",
                "multipleOf": 0.5,
                "minimum": 5.0,
                "maximum": 111111.0,
            },
            "tags": {
                "type": "array",
                "additonalItems": {
                    "type": "string",
                    "miniLength": 2
                },
                "miniItems": 1,
                "maxItems": 5,
            },
            "date": {
                "description": "书籍出版日期",
                "type": "string",
                "format": "date",
            },
            "bookcoding": {
                "description": "书籍编码",
                "type": "string",
                "pattern": "^[A-Z]+[a-zA-Z0-9]{12}$"
            },
            "others": {
                "description": "其他信息",
                "type": "object",
                "properties": {
                    "info1": {
                        "type": "string"
                    },
                    "info2": {
                        "type": "string"
                    }
                }
            }
        },
        "required": [
            "id", "name", "info", "price", "tags"
        ]
    }
    
    schema2 = {
        "id": And(int, lambda x: 1 <= x, error="id必须是整数，大于等于100"),
        "name": And(str, lambda s: 3 <= len(s) <= 30, error="name长度3-10"),
        "info": And(str, lambda s: 10 <= len(s) <= 60, error="info信息出错"),
        "price": And(float, lambda x: (5.0 < x < 111111.0) and (x % 0.5 == 0), error="price必须是大于5.0小于111.0的小数，且能被0.5整除"),
        "tags": And(list, tags_check, error="tags出错"),
        Optional("date"): And(str, error="日期格式出错"),
        Optional("bookcoding"): And(str, Regex("^[A-Z]+[a-zA-Z0-9]{12}$"), error="书籍编码出错"),
        Optional("others"): {
            "info1": str,
            "info2": str
        },
    }
    
    
    def time_jsonschema(data):
        start_time = time.time()
        for json_data in data:
            try:
                validate(instance=json_data, schema=schema1, format_checker=draft7_format_checker)
            except SchemaError as e:
                print("验证模式出错：{}\n提示信息：{}".format(" --> ".join([i for i in e.path]), e.message))
            except ValidationError as e:
                print("出错字段：{}\n提示信息：{}".format(" --> ".join([i for i in e.path]), e.message))
            else:
                continue
        end_time = time.time()
        return end_time - start_time
    
    
    def time_schema(data):
        start_time = time.time()
        for json_data in data:
            try:
                Schema(schema2).validate(json_data)
            except SchemaError as e:
                print(e)
            else:
                continue
        end_time = time.time()
        return end_time - start_time
    
    
    if __name__ == "__main__":
        data = DataFactory()
        data_list = [data.create_data() for i in range(10000)]
        t1 = time_jsonschema(data_list)
        t2 = time_schema(data_list)
        print("jsonschema：schema = {}：{} = {}：1\n".format(t1, t2, t1/t2))

**结果分析：**

# 10条数据时：
    jsonschema：schema = 0.012000083923339844：0.0019941329956054688 = 5.517694882831181：1
    # 100条数据时：
    jsonschema：schema = 0.10173273086547852：0.023936033248901367 = 4.180191742616664：1
    # 1000条数据时：
    jsonschema：schema = 0.9435069561004639：0.2263953685760498 = 4.127518805860752：1
    # 10000条数据时：
    jsonschema：schema = 9.319035053253174：2.2689626216888428 = 4.1371787451116295：1

数据在10条的时候，多次测验，最终结果不稳定，耗时比在6.0 ，5.5，3.6左右，波动较大。  
数据在100条的时候，多次测验，最终结果比较稳定，耗时比在3.85—4.3之间  
数据在1000条的时候，多次测验，最终结果的耗时比在4.0—4.2之间  
数据在10000条的时候，由于每次测试时间都比较长，故测试数据相对比较少，但耗时比在4.1左右

试验次数不是很多，基于上面代码和测试数据，schema 效率比 jsonschema 大约高出 4倍

转载于:https://www.cnblogs.com/ChangAn223/p/11250627.html