Schema库的简单学习

小鱼儿 2022-05-14 01:39 314阅读 0赞

*  Schema库的简单学习
    
     *  核心类
     *  一个类、一个方法
     *  Schema类传入基础类型str,int,float,object
     *  Schema类传入可调用的对象func，class with \_\_call\_\_
     *  Schema类传入带有validate方法的对象And，Or，Use，Regex，Const
        
         *  Regex正则匹配
         *  And且
         *  Or或
         *  Use创建数据
         *  Const常量
     *  Schema类传入容器对象list，tuple，set，frozenset
     *  Schema类传入字典
     *  Schema的ignore\_extra\_keys字段
     *  友好的错误提示

# Schema库的简单学习 #

Schema是一个简单易用的python数据校检三方库，[Schema on Github][].

在web app中，经常需要接收用户传过来的数据，然后做处理。但是用户由于各种原因，输入的数据并不如人意。前端发送json形式数据到后端api，以往的解决方案甚是暴力，对json的key的值进行各种if检验，甚至要去做正则匹配。使用schema库能够非常优雅的解决这个问题。

Schema和marshmallow的取舍。之前学习过marshmallow，它有一个方法Schema.validate，同样可以完成数据校检，但是需要先生成一个独特的Schema类，用起来更适合序列化/反序列化的场景。而Schema库只做一件事，那就是数据校检。

## 核心类 ##

*  Schema 数据检验最重要的类
 *  Regex 正则匹配检验用到的类
 *  Use
 *  And
 *  Or

## 一个类、一个方法 ##

这是schema库里最重要的概念。  
\- 一个类是Schema类，可以理解为schema库的入口，什么都可以往里面传。  
\- 一个方法是validate方法，它接入一个数据或者一个obj。  
\- 执行校检就是处理validate接收的数据和Schema类接收的schema之间的关系。

## Schema类传入基础类型`str,int,float,object` ##

>>> from schema import Schema
    >>> Schema(str).validate('abc')
    'abc'
    >>> Schema(int).validate(123)
    123
    >>> Schema(float).validate(1.23)
    1.23
    >>> Schema(object).validate('abcd')
    'abcd'
    >>> Schema(str).validate(123)
    schema.SchemaUnexpectedTypeError: 123 should be instance of 'str'

基础类型没什么好说的，只能检验最简单的数据。注意object是基类，也就是validate里的数据符合语法就会原样输出，但我们可以基于此做些类的判断

>>> from schema import Schema
    >>> from datetime import datetime as dt
    >>> now = dt(2018, 8, 30)
    >>> Schema(object).validate(now)
    datetime.datetime(2018, 8, 30, 0, 0)
    >>> Schema(dt).validate(now)
    datetime.datetime(2018, 8, 30, 0, 0)

到这里，可以发现有点像[isinstance][]，看了下代码，果然是这么实现的…

## Schema类传入可调用的对象`func，class with __call__` ##

>>> from schema import Schema
    >>> import os
    >>> Schema(os.path.exists).validate('/home/light')
    '/home/light'
    >>> Schema(os.path.exists).validate('/thgil/emoh')
    schema.SchemaError: exists('/thgil/emoh') should evaluate to True
    >>> Schema(lambda n: n > 0).validate(123)
    123
    >>> Schema(lambda n: n > 0).validate(-12)
    SchemaError: <lambda>(-12) should evaluate to True

可以看到，当Schema类传入的是可调用对象，那么它会将validate里的数据传入可调用对象，当可调用对象返回的值不为False就返回值。

# 底层实现
    # schema指的是有__call__方法的对象
    if schema(data):
        return data

## Schema类传入带有validate方法的对象`And，Or，Use，Regex，Const` ##

If Schema(…) encounters an object with method validate it will run this method on corresponding data as data = obj.validate(data). This method may raise SchemaError exception, which will tell Schema that that piece of data is invalid, otherwise—it will continue validating.  
渣翻：如果Schema类传入了带有validate方法的对象，那么将不使用Schema自己的validate方法，而是转给那个对象去执行。  
举个栗子：

>>> from schema import Schema,And,Or,Use,Regex,Const
    >>> Schema(And(int, lambda x:x>10)).validate(20)
    20
    >>> And(int, lambda x:x>10).validate(20)
    20

### Regex正则匹配 ###

>>> Regex(r'^foo').validate('foobar')
    'foobar'
    >>> Schema(Regex(r'^foo')).validate('foobar')
    'foobar'
    >>> Regex(r'^[A-Z]+$', flags=re.I).validate('those-dashes-dont-match')
    schema.SchemaError: Regex('^[A-Z]+$', flags=re.IGNORECASE) does not match 'those-dashes-dont-match'
    >>> Regex(r'^[A-Z-]+$', flags=re.I).validate('those-dashes-will-match')
    'those-dashes-will-match'

正则表达式需要用到re库。flags是re里的概念，re.I可以理解为忽略大小写。

### And且 ###

看到and，or肯定能想到与或非门。and就有点与的想法。

>>> And(int, lambda x:x>10).validate(20)
    20
    >>> And(str, Regex(r'^[a-zA-Z0-9]+')).validate('asdwasd')
    'asdwasd'
    >>> And(str, Regex(r'^[a-zA-Z0-9]'), lambda x:len(x)<10).validate('qwertyu')
    'qwertyu'
    >>> And(str, Regex(r'^[a-zA-Z0-9]'), lambda x:len(x)<10).validate('qwertyuiopasdfghjkl')
    schema.SchemaError: <lambda>('qwertyuiopasdfghjkl') should evaluate to True

第一个例子，需要数据是int类型并且大于10；第二个例子，需要数据是字符串，并且正则匹配下成功；第三个例子，需要数据是字符串，并且正则匹配下成功，并且长度小于10.

### Or或 ###

>>> Or(str, int, float).validate('abc')
    'abc'
    >>> Or(str, int, float).validate(123)
    123
    >>> Or(str, int, float).validate(1.23)
    1.23
    >>> Or(Regex(r'^[a-zA-Z0-9]'), lambda x:len(x)<10).validate('qwertyuiopasdfghjkl')
    'qwertyuiopasdfghjkl'

### Use创建数据 ###

Use的用法有点不像是校检，而是格式化数据。

>>> Use(str).validate(123)
    '123'
    >>> Use(int).validate('123')
    123
    >>> Use(int).validate('abc')
    schema.SchemaError: int('abc') raised ValueError("invalid literal for int() with base 10: 'abc'",)

它会尝试着将validate的数据转换为指定的类型。单独的使用可能作用不大，但在后面的字典校验中作用很大。

### Const常量 ###

const的使用同样不像是校检，而是为了数据安全。  
Sometimes you need to transform and validate part of data, but keep original data unchanged. Const helps to keep your data safe。  
看了下底层代码，并不能理解为什么这样就能保证数据的安全。

>>> from schema import Use, Const, And, Schema
    >>> from datetime import datetime
    >>> is_future = lambda date: datetime.now() > date
    >>> to_json = lambda v: {
       "timestamp": v}
    >>> Schema(And(Const(And(Use(datetime.fromtimestamp), is_future)), Use(to_json))).validate(1234567890)
    {
       "timestamp": 1234567890}
    >>> Schema(And(And(Use(datetime.fromtimestamp), is_future), Use(to_json))).validate(1234567890)
    {
       'timestamp': datetime.datetime(2009, 2, 14, 7, 31, 30)}

可以看到添加了const的数据直接保留传入数据，而不是通过datetime.fromtimestamp()方法转成实际年月日。

## Schema类传入容器对象`list，tuple，set，frozenset` ##

>>> Schema([1, 0]).validate([1, 1, 0, 1])
    [1, 1, 0, 1]
    >>> Schema((int, float)).validate((5, 7, 8, 'not int or float here'))
    SchemaError: Or(<type 'int'>, <type 'float'>) did not validate 'not int or float here'
    'not int or float here' should be instance of 'float'

简单理解就是，validate的值可以匹配到Schema里的任何一项就ok。  
对于validate数据就是遍历。  
对于Schema的schema就是or。

## Schema类传入字典 ##

这一段是最重要的，毕竟现在前后端传递数据还是使用的json格式，也就是键值对，也可以转成字典数据。

定义两个概念：  
\- `模式字典`：Schema类里使用的字典，会有各种形式  
\- `数据字典`：validate方法里的字典，可以当做普通的字典

# 常见用法，key固定检验value值；或者key和value都要检查
    >>> Schema({
       'name': str, 'age': lambda n: 18 <= n <= 99}).validate({
       'name': 'Sue', 'age': 28})
    {
       'age': 28, 'name': 'Sue'}
    >>> Schema({str: int, int: None}).validate({
       'key1': 1, 2: None})
    {
       2: None, 'key1': 1}
    >>> Schema({str: int, int: None}).validate({
       'key1': 1, 2: 2})
    SchemaError: Key '2' error: None does not match 2

# 特殊用法
    # 看第二个validate测试会很奇怪，为什么模式字典三项，而数据字典可以有四项。
    # 理解就是数据字典的每一项只要可以匹配模式字典，并且模式字典都被匹配过，就算成功匹配。
    >>> schema = Schema({
       'key1': str,'key2': str, str: object})
    >>> schema.validate({
       'key1': 'a','key2': 'b','key3': 'c'})
    {
       'key1': 'a', 'key2': 'b', 'key3': 'c'}
    >>> schema.validate({
       'key1': 'a','key2': 'b','key3': 'c', 'key4': 1})
    {
       'key1': 'a', 'key2': 'b', 'key3': 'c', 'key4': 1}
    >>> schema.validate({
       'key1': 'a','key2': 'b'})
    SchemaMissingKeyError: Missing keys: <type 'str'>
    # 上面可能有点绕，我们引入一个新的类optional，它的意思就是可选，也就是这个key在不在都行。
    >>> schema = Schema({
       'name': str, Optional('occupation'): str})
    >>> schema.validate({
       'name': 'Sam', 'occupation': '1'})
    {
       'name': 'Sam', 'occupation': '1'}
    >>> schema.validate({
       'name': 'Sam'})
    {
       'name': 'Sam'}
    # 结合上面两个注释的解释，我们可以写出一个特殊的匹配。
    # 下面的匹配模式意思是，接受一个学生字典，必须要有id（数字且大于0），名字（字符串），年龄（数字且大于8），其他项目。
    >>> student_schema = Schema({
       'id': And(int, lambda x: x>0), 'name': str, 'age':And(int, lambda x: x>8), Optional(str):object})
    >>> student_schema.validate({
       'id': 1, 'name': 'Ash', 'age': 12})
    {
       'age': 12, 'id': 1, 'name': 'Ash'}
    >>> student_schema.validate({
       'id': 1, 'name': 'Ash', 'age': 12, 'sex': 'girl'})
    {
       'age': 12, 'id': 1, 'name': 'Ash', 'sex': 'girl'}
    >>> student_schema.validate({
       'id': 2, 'name': 'Bob', 'age':14, 'city': 'hz', 'sex': 'boy'})
    {
       'age': 14, 'city': 'hz', 'id': 2, 'name': 'Bob', 'sex': 'boy'}
    # 我们对学生匹配模式做个假定，倘若性别不写就是’null‘，城市不写就是’hz‘.
    # Optional的default字段
    >>> student_schema = Schema({
       'id': And(int, lambda x: x>0), 'name': str, 'age':And(int, lambda x: x>8), Optional('sex', default='null'): str, Optional('city', default='hz'): str, Optional(str): object})
    >>> student_schema.validate({
       'id': 1, 'name': 'Ash', 'age': 12})
    {
       'age': 12, 'city': 'hz', 'id': 1, 'name': 'Ash', 'sex': 'null'}
    >>> student_schema.validate({
       'id': 1, 'name': 'Ash', 'age': 12, 'sex': 'girl'})
    {
       'age': 12, 'city': 'hz', 'id': 1, 'name': 'Ash', 'sex': 'girl'}
    >>> student_schema.validate({
       'id': 2, 'name': 'Bob', 'age':14, 'city': 'zh', 'sex': 'boy'})
    {
       'age': 14, 'city': 'zh', 'id': 2, 'name': 'Bob', 'sex': 'boy'}
    # 最后一个类Forbidden，禁止数据字典出现某个key
    >>> from schema import Forbidden
    >>> Schema({Forbidden('age'): object}).validate({
       'age': 50})
    SchemaForbiddenKeyError: Forbidden key encountered: 'age' in {
       'age': 50}
    >>> Schema({Forbidden('age'): str, 'age': int}).validate({
       'age': 50})
    {
       'age': 50}

## Schema的ignore\_extra\_keys字段 ##

>>> schema = Schema({
       'name': str}, ignore_extra_keys=True)
    >>> schema.validate({
       'name': 'Sam', 'age': '42'})
    {
       'name': 'Sam'}

## 友好的错误提示 ##

schema库默认的错误提示抛去堆栈的报错，最后一行的报错信息已经足够，但是schema提供了一个自定义报错提示的接口。  
You can pass a keyword argument error to any of validatable classes (such as Schema, And, Or, Regex, Use) to report this error instead of a built-in one.

>>> Schema(Use(int, error='Invalid year')).validate('XVII')
    Traceback (most recent call last):
    ...
    SchemaError: Invalid year

[Schema on Github]: https://github.com/keleshev/schema
[isinstance]: http://www.runoob.com/python/python-func-isinstance.html