Python good包_程序模块 - PyPI

苗条帅气的验证库

good的Python项目详细描述

良好

苗条而美观的验证库。

核心功能：

简单
可定制
支持嵌套模型验证
错误路径（包含错误的字段）
用户友好的错误消息
国际化！
健壮性：每秒10000次验证
python 2.7、3.3+兼容
100%记录和单元测试

灵感来源于令人惊叹的alecthomas/voluptuous和100%兼容。整个内部结构都经过了重新设计，以达到可读性和健壮性。是的，文档现在已经详尽无遗：）

翻拍的基本原理是让它模块化，有一个很小的核心，其他一切都建立在这个基础上，确保所有错误消息都是用户友好的开箱即用，并调整性能。

物欲减退替代品
模式
- 可调用项
- 优先级
- 创建模式
- 验证
错误
- 无效
  - 无效。enrich（）
- 多个无效
标记
验证工具
- 助手
  - 对象
  - 消息
  - 测试
  - 消息
  - 名称
  - 真理
- 谓词
- 类型
  - 键入
  - 强制
- 值
- 布尔型
- 数字
  - 范围
  - 夹钳
- 字符串
- 日期
- 文件
  - isfile
  - isdir
  - 路径存在

替代品数量急剧下降

尽管善是以肉欲为原型的，而且是高度兼容的，仍然有一些差异肯定会破坏您的项目。

如果您还没有准备好进行这样的更改--很好。voluptuous是解决方案：兼容层，用于从voluptuous 0.8.5切换 100%兼容。

这是一个通过所有有趣的单元测试的替换，因此应该工作得很好。下面是如何使用它

#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before

包括所有功能，绝对兼容，除了错误信息文本，变得更加方便用户：）

迁移步骤：

还要注意仍然存在的细微差异：

祝你好运！：）< >

`模式`

验证方案。

模式是一种python结构，其中的节点与相应的值进行模式匹配。它充分利用了python的灵活性，允许您匹配值、类型、数据结构等等。

当一个模式被创建时，它被编译成一个可调用的函数来进行验证，因此它不需要每次都要分析架构。

一旦定义了模式，就可以通过调用它来触发验证：

fromgoodimportSchemaschema=Schema({'a':str})# Testschema({'a':'i am a valid string'})

存在以下规则：

文字：通过直接比较（相等检查）验证纯值：

Schema(1)(1)#-> 1Schema(1)(2)#-> Invalid: Invalid value: expected 1, got 2

类型：类型schema生成一个严格的类型（v）==模式检查输入值：
```
Schema(int)(1)#-> 1Schema(int)(True)#-> Invalid: Wrong type: expected Integer number, got BooleanSchema(int)('1')#-> Invalid: Wrong type: expected Integer number, got Binary String
```
对于python2，basestring有一个异常：它不会进行严格的类型检查，而是进行isinstance（）
有关放松的isinstance（）检查，请参见验证程序。

枚举： python 3.4枚举S 或后端口的enum34

测试输入值是否为有效的枚举值

fromenumimportEnumclassColors(Enum):RED=0xFF0000GREEN=0x00FF00BLUE=0x0000FFschema=Schema(Colors)schema(0xFF0000)#-> <Colors.RED: 0xFF0000>schema(Colors.RED)#-> <Colors.RED: 0xFF0000>schema(123)#-> Invalid: Invalid Colors value, expected Colors, got 123

输出始终是提供的枚举类型值的实例。

可调用：应用于值，结果用作最终值。
在失败的情况下，可调用函数应该会引发无效的错误，但是一些常见的错误类型是自动转换：请参见可调用函数。
此外，允许验证器将值转换为所需的表单。例如，返回一个可调用函数，该函数将输入值转换为int
```
defCoerceInt(v):# naive Coerce(int) implementationreturnint(v)Schema(CoerceInt)(1)#-> 1Schema(CoerceInt)('1')#-> 1Schema(CoerceInt)('a')#-> Invalid: invalid literal for int(): expected CoerceInt(), got a
```

架构：架构可以包含子架构：

sub_schema=Schema(int)schema=Schema([None,sub_schema])schema([None,1,2])#-> [None, 1, 2]schema([None,'1'])#-> Invalid: invalid value

由于schema是可调用的，只需调用它即可透明地进行验证：）

此外，以下类型的实例在编译阶段转换为可调用的：

iterables（list，tuple，set，自定义iterables）：
iterable被视为一组有效值，将输入中的每个值与架构中的每个值进行比较。
为了使输入有效，它需要具有相同的iterable类型，并且值在架构中应至少有一个匹配的值。
```
schema=Schema([1,2,3])# List of valid valuesschema([1,2,2])#-> [1, 2, 2]schema([1,2,4])#-> Invalid: Invalid value @ [2]: expected List[1|2|3], got 4schema((1,2,2))#-> Invalid: Wrong value type: expected List, got Tuple
```
iterable中的每个值也是一个模式，验证需要输入值的每个成员都与模式的任何匹配。因此，iterable是为iterable的每个成员定义或验证规则的一种方法：
```
Schema([# All values should be# .. int ..int,# .. or a string, casted to int ..lambdav:int(v)])([1,2,'3'])#-> [ 1, 2, 3 ]
```
此示例的工作方式如下：
1. 验证输入值是否具有匹配的类型：列表在本例中
2. 对于列表中的每个成员，测试架构中是否有匹配的值。
  例如，对于值1--int匹配（立即instanceof（）检查）。但是，对于value'3'--int失败，但是callable成功地做到了这一点，没有错误，并转换值。
  因为列表是有序的，所以使用第一个没有失败的模式。
映射（dict，自定义映射）：
输入映射中的每个键值对都根据相应的模式对进行验证：
```
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before
```
0 验证时，键和值都是模式，允许使用嵌套模式和有趣的验证规则。例如，让我们使用验证器来匹配特定的密钥： #from voluptuous import * # no morefromgood.voluptuousimport*# replacement# .. and use it like before 1 工作原理如下：测试输入是否具有匹配的类型（dict）对于输入映射中的每个键，将从架构中选择匹配的键使用架构中的相应值验证输入值。此外，某些键可以标记为Required和Optional。默认行为是需要所有键，但可以通过提供默认密钥=可选的模式参数。最后，映射不允许任何额外的键（架构中未定义的键）。若要更改此设置，请提供 extra_keys=allow到schema构造函数。请注意，默认密钥和额外密钥设置不会传播到子架构，仅应用于到顶层映射。如果需要，用另一个schema（）包装子模式并提供设置，或者显式使用标记。


这些是仅仅是基本的规则，当然schema可以做得更多！
额外的逻辑是通过标记和验证程序实现的，
以下章节将对其进行说明。
可调用项
最后，在使用自定义可调用函数进行验证时，需要考虑以下事项：抛出错误。如果callable抛出invalid异常，则它将按原样用于它提供的所有丰富信息。
架构足够聪明，可以填充大多数参数（请参见invalid.enrich），
因此，使用自定义消息就足够了，而且可能需要设置一个人性化的预期的字段。
此外，特定的错误类型会自动包装到invalid中：
断言错误，类型错误，值错误。
schema尽力做到最好，但是这样的消息对于用户来说可能是不明确的。
因此，在创建自定义验证器时总是会引发有意义的错误。
不过，这也为使用python类型转换和验证程序（如lambda v:int（v））提供了可能性，
因为它们中的大多数都抛出typeerror或valueerror
命名。
如果提供的可调用项未指定无效。应为预期值，
改为使用可调用的名称。
例如，在报告的错误中，def initify（v）：pass变成'initify（）'。
如果需要在可调用对象上使用自定义名称——请在可调用对象上设置name属性。
这对类最有效，但是函数也可以接受name属性。
为了方便起见，可在可调用项上使用装饰符。
指定名称并覆盖验证程序失败时使用的错误消息。
信号。
可调用的可能会决定该值非常无效，因此应该从经过清理的输出中删除该值。
在这种情况下，可调用函数应该引发good.schema.signals.removeValue
这由remove（）标记使用，但也可以被其他可调用项利用。
优先级
每种模式类型都有一个优先级（源），
定义映射架构中匹配键的序列：
文字具有最高优先级
类型的优先级低于文本，因此模式可以为单个键定义特定的规则，
然后通过类型匹配声明一般规则：
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before
2
可调用、可访问、映射——优先级较低。
此外，标记具有单独的优先级，
它可以是比文本更高的值（remove（）标记）或低于可调用的值（extra标记）。
创建模式
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before
3
从给定的架构定义创建编译的架构对象。
在引擎盖下，它使用schema compiler：如果感兴趣，请参阅源代码。
参数：
模式：模式定义
默认密钥：默认映射密钥行为：
a标记类用作映射键的默认值，这些键不是用任何东西标记的。
默认为标记。必需
额外密钥：默认额外密钥行为：子架构，或a标记类。
默认为标记。拒绝
投掷：
架构错误：架构编译错误
正在验证
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before4
如果有一个模式，则可以通过调用输入值上的模式来验证用户输入。
调用时，架构将返回经过清理的值，或引发异常。
参数：
值：输入要验证的值
返回：无清除值
投掷：
好。多个值无效：多个值的验证错误。请参见multipleinvalid
好。无效：单个值的验证错误。请参见无效
错误
来源：good/schema/errors.py rel="nofollow">good/schema/errors.py
当验证用户输入时，收集所有错误并抛出这些错误
在整个输入值被验证之后。这确保您可以同时报告所有的错误。对于简单的模式，例如schema（int），只有一个错误可用：例如，错误的值类型。
在这种情况下，会引发错误。
但是，对于具有嵌入结构等的复杂架构，可能会发生多个错误：
然后，[multipleinvalid]被报告。
所有错误都可以在顶层找到：
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before5
无效
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before6
单个值的验证错误。
保证此异常包含对用户有意义的文本值。
参数：
消息：验证错误消息。
预期值：预期值：验证程序预期值的相关信息。
如果验证器没有指定它——则使用验证器的名称。
提供的：提供的值：有关用户实际提供的值的信息
如果验证器没有指定它——输入值被类型转换为字符串并存储在这里。
路径：错误值的路径。
例如，如果在['a'].b[1]处遇到无效值，则路径=['a'，'b'，1]。
验证器：失败的验证器：架构项
**info：验证器可能提供的自定义值。没有内置的验证器使用它。
无效的.enrich（）
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before7
用附加信息充实此错误。
这对invalid和multipleinvalid都有效（由于invalid是iterable）：
在后一种情况下，默认值将应用于所有收集到的错误。
指定的参数仅设置在无效的错误上，这些错误在属性上没有任何值。
一个排除是路径：如果提供，它将被预先设置为invalid.path。
当使用多个不同模式验证整个输入时，此功能尤其有用：
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before
8
这在验证容器中的值时使用。
参数：
应为：无效。应为默认值
提供的：无效。提供的默认值
路径：前缀，以前置到无效的.path
验证器：无效。验证器默认值
返回：无效多重有效
多重有效
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before9
多个值的验证错误。
当schema报告多个错误（例如多个字典键）时，会引发此错误。
 multipleInvalid具有与 invalid相同的属性ODE < < /A>
但这些值取自列表中的第一个错误。
此外，它还具有errors属性，该属性是由架构收集的invalid错误的列表。
列表保证是简单的：例如，不会有multipleinvalid的底层层次结构。
注意，无效和多重有效都是可接受的，这允许在奇点中处理它们：
fromgoodimportSchemaschema=Schema({'a':str})# Testschema({'a':'i am a valid string'})
0
在本例中，我们为用户创建一个映射到错误字符串的路径字典（作为字符串）。
参数：
错误：报告的错误。
如果它包含multipleinvalid错误，则列表将递归展开
因此，所有这些都保证是"invalid" rel="nofollow">的实例。
标记
标记是一个代理类，它包装一些模式。
立即，示例是：
fromgoodimportSchemaschema=Schema({'a':str})# Testschema({'a':'i am a valid string'})
1
这样，标有required（）的键如果没有提供值，将报告错误。
通常，标记"修饰"映射键，但其中一些键可以是"独立的"：
fromgoodimportSchemaschema=Schema({'a':str})# Testschema({'a':'i am a valid string'})2
每个标记都有自己独特的行为，因为没有任何内容被硬编码到核心模式中。
继续阅读以了解标记如何工作。
必需的
fromgoodimportSchemaschema=Schema({'a':str})# Testschema({'a':'i am a valid string'})3
required（key）用于修饰映射键，因此指定这些键必须始终存在于
输入映射。
编译时，使用默认键作为默认标记：
fromgoodimportSchemaschema=Schema({'a':str})# Testschema({'a':'i am a valid string'})
4
请记住，映射键也是模式，需要将希望始终具有匹配项：
fromgoodimportSchemaschema=Schema({'a':str})# Testschema({'a':'i am a valid string'})5
此外，所需的标记具有特殊的行为，允许设置键
如果未提供密钥，则设置为默认值。有关默认值的文档中的更多详细信息
参数：
可选
fromgoodimportSchemaschema=Schema({'a':str})# Testschema({'a':'i am a valid string'})
6
可选（键）有争议的是指定不需要映射键。
只有当aschema具有default\u keys=required:
然后，它用required（）装饰所有键，除非键已经用某些标记装饰。
optional（）步骤：这些键已被修饰，因此没有用required（）包装。
因此，它只用于防止schema将required（）放在键上。
在所有其他意义上，它绝对没有特殊的行为。
因此，可能会丢失可选键，但如果提供了可选键，则其值必须与值架构匹配。
示例：用作默认键
fromgoodimportSchemaschema=Schema({'a':str})# Testschema({'a':'i am a valid string'})7
示例：不需要用于标记特定键：
fromgoodimportSchemaschema=Schema({'a':str})# Testschema({'a':'i am a valid string'})8
参数：
删除
fromgoodimportSchemaschema=Schema({'a':str})# Testschema({'a':'i am a valid string'})9
remove（key）标记用于声明如果遇到密钥，
应在不验证值的情况下删除。
remove具有最高优先级，因此它比架构中的其他内容都要优先操作。
示例：
Schema(1)(1)#-> 1Schema(1)(2)#-> Invalid: Invalid value: expected 1, got 20
但是，对值使用remove（）更为自然。
请记住，在这种情况下，'name'将变为required（），
如果没有用optional（）装饰：
Schema(1)(1)#-> 1Schema(1)(2)#-> Invalid: Invalid value: expected 1, got 21
奖励：remove（）也可用于iterables中：
Schema(1)(1)#-> 1Schema(1)(2)#-> Invalid: Invalid value: expected 1, got 22
参数：
拒绝
Schema(1)(1)#-> 1Schema(1)(2)#-> Invalid: Invalid value: expected 1, got 23
拒绝（键）标记用于报告每次与输入中的内容匹配时，都会出现错误。
它的优先级比大多数其他模式都低，因此只会发生拒绝
如果没有其他架构与此值匹配。
示例：
Schema(1)(1)#-> 1Schema(1)(2)#-> Invalid: Invalid value: expected 1, got 24
参数：
允许
Schema(1)(1)#-> 1Schema(1)(2)#-> Invalid: Invalid value: expected 1, got 25
允许（键）是禁止操作的标记，从不抱怨任何事情。
设计用于extra
参数：
额外的
Schema(1)(1)#-> 1Schema(1)(2)#-> Invalid: Invalid value: expected 1, got 26
extra是一个catch all标记，用于定义架构中未定义的映射键的行为。
它具有最低优先级，并将其函数委托给其值，该值可以是架构或其他标记。
如果不带参数，则使用identity函数lambda x:x编译，该函数是一个catch all:
它匹配任何值。与最低优先级一起，extra将只捕获与其他值不匹配的值。
每个映射都隐式地有一个extra，并且extra\u键参数控制默认行为。
带有extra:<；schema>；的示例：
Schema(1)(1)#-> 1Schema(1)(2)#-> Invalid: Invalid value: expected 1, got 27
带有extra:reject的示例
Schema(1)(1)#-> 1Schema(1)(2)#-> Invalid: Invalid value: expected 1, got 2
8
使用extra:remove的示例：无提示地放弃所有额外值：
Schema(1)(1)#-> 1Schema(1)(2)#-> Invalid: Invalid value: expected 1, got 2
9
带有extra:allow的示例：allow any extra values:
Schema(int)(1)#-> 1Schema(int)(True)#-> Invalid: Wrong type: expected Integer number, got BooleanSchema(int)('1')#-> Invalid: Wrong type: expected Integer number, got Binary String
0
参数：
整个
Schema(int)(1)#-> 1Schema(int)(True)#-> Invalid: Wrong type: expected Integer number, got BooleanSchema(int)('1')#-> Invalid: Wrong type: expected Integer number, got Binary String1
整个是一个方便的标记，它使用作为值提供的验证器验证整个映射。
它具有绝对最低的优先级，低于extra，因此它从不匹配任何键，但仍执行到
验证映射本身。
这就打开了在多个字段上定义规则的可能性。
此功能由组验证程序利用。
例如，我们要求映射不超过3个键：
Schema(int)(1)#-> 1Schema(int)(True)#-> Invalid: Wrong type: expected Integer number, got BooleanSchema(int)('1')#-> Invalid: Wrong type: expected Integer number, got Binary String2
在本例中，对每个输入字典都执行entire，并神奇地调用它映射到的模式。
maxkeys（n）模式是一个验证器，如果字典太大，它就会抱怨字典的大小。
模式捕获由其引发的断言错误并将其转换为无效
请注意，此标记映射到的架构不能替换映射对象，但它可以改变给定的映射。
参数：
验证工具
这里列出的所有验证器都继承自定义标准接口的validatorbase。
目前，无论它是可调用的、类还是validatorbase的子类都没有区别，
但在未来，它可能会获得特殊功能。
助手
收集各种帮助程序以更改验证过程。
对象
Schema(int)(1)#-> 1Schema(int)(True)#-> Invalid: Wrong type: expected Integer number, got BooleanSchema(int)('1')#-> Invalid: Wrong type: expected Integer number, got Binary String3
指定提供的映射应验证对象。
它使用相同的映射验证规则，但使用属性：
Schema(int)(1)#-> 1Schema(int)(True)#-> Invalid: Wrong type: expected Integer number, got BooleanSchema(int)('1')#-> Invalid: Wrong type: expected Integer number, got Binary String4
在内部，它验证对象的\uu dict\u：因此，类属性被排除在验证之外。
验证在包装器类的帮助下执行，包装器类将对象属性代理为映射键，
然后模式将其验证为映射。
这将继承架构的默认必需/额外键行为。
要覆盖，请使用optional（）和extra标记。
参数：
模式：对象模式，作为映射给定
cls：需要特定类的实例。如果无，则允许所有类。
消息
Schema(int)(1)#-> 1Schema(int)(True)#-> Invalid: Wrong type: expected Integer number, got BooleanSchema(int)('1')#-> Invalid: Wrong type: expected Integer number, got Binary String5
如果发生验证错误，则重写包装架构报告的错误消息。
在验证时，如果架构抛出invalid--消息将被msg覆盖
其他一些错误类型被转换为无效的：请参见有关架构调用的说明
Schema(int)(1)#-> 1Schema(int)(True)#-> Invalid: Wrong type: expected Integer number, got BooleanSchema(int)('1')#-> Invalid: Wrong type: expected Integer number, got Binary String6
参数：
模式：修改错误的包装模式
消息：要使用的错误消息，而不是基础架构报告的错误消息
测试
Schema(int)(1)#-> 1Schema(int)(True)#-> Invalid: Wrong type: expected Integer number, got BooleanSchema(int)('1')#-> Invalid: Wrong type: expected Integer number, got Binary String7
使用提供的函数测试该值，希望它不会抛出错误。
如果没有抛出错误——该值是有效的，并且使用原始输入值。
如果抛出任何错误，则认为该值无效。
这对于丢弃包装验证程序生成的转换尤其有用：
Schema(int)(1)#-> 1Schema(int)(True)#-> Invalid: Wrong type: expected Integer number, got BooleanSchema(int)('1')#-> Invalid: Wrong type: expected Integer number, got Binary String8
参数：
乐趣：可调用以使用或验证函数测试值。
请注意，这将不适用于可变输入值，因为它们已被修改到位！
消息
Schema(int)(1)#-> 1Schema(int)(True)#-> Invalid: Wrong type: expected Integer number, got BooleanSchema(int)('1')#-> Invalid: Wrong type: expected Integer number, got Binary String9
适用于可调用的便利装饰符
fromenumimportEnumclassColors(Enum):RED=0xFF0000GREEN=0x00FF00BLUE=0x0000FFschema=Schema(Colors)schema(0xFF0000)#-> <Colors.RED: 0xFF0000>schema(Colors.RED)#-> <Colors.RED: 0xFF0000>schema(123)#-> Invalid: Invalid Colors value, expected Colors, got 1230
参数：
消息：要改用的错误消息
名称：也重写架构名称。参见
返回：callabledecorator
名称
fromenumimportEnumclassColors(Enum):RED=0xFF0000GREEN=0x00FF00BLUE=0x0000FFschema=Schema(Colors)schema(0xFF0000)#-> <Colors.RED: 0xFF0000>schema(Colors.RED)#-> <Colors.RED: 0xFF0000>schema(123)#-> Invalid: Invalid Colors value, expected Colors, got 1231
在可调用的验证器上设置名称。
当使用lambdas填充无效字段时，对于用户友好的报告非常有用
fromenumimportEnumclassColors(Enum):RED=0xFF0000GREEN=0x00FF00BLUE=0x0000FFschema=Schema(Colors)schema(0xFF0000)#-> <Colors.RED: 0xFF0000>schema(Colors.RED)#-> <Colors.RED: 0xFF0000>schema(123)#-> Invalid: Invalid Colors value, expected Colors, got 1232
注意，它只对lambdas有用，因为函数名在以下情况下可用：
请参见有关架构可调用项的说明
参数：
名称：要在可调用验证器上分配的名称
验证器：验证器可调用。如果没有提供，则返回一个decorator：
fromenumimportEnumclassColors(Enum):RED=0xFF0000GREEN=0x00FF00BLUE=0x0000FFschema=Schema(Colors)schema(0xFF0000)#-> <Colors.RED: 0xFF0000>schema(Colors.RED)#-> <Colors.RED: 0xFF0000>schema(123)#-> Invalid: Invalid Colors value, expected Colors, got 1233
返回：可调用同一验证器可调用
真理
fromenumimportEnumclassColors(Enum):RED=0xFF0000GREEN=0x00FF00BLUE=0x0000FFschema=Schema(Colors)schema(0xFF0000)#-> <Colors.RED: 0xFF0000>schema(Colors.RED)#-> <Colors.RED: 0xFF0000>schema(123)#-> Invalid: Invalid Colors value, expected Colors, got 1234
适用于可调用项的便利装饰符
fromenumimportEnumclassColors(Enum):RED=0xFF0000GREEN=0x00FF00BLUE=0x0000FFschema=Schema(Colors)schema(0xFF0000)#-> <Colors.RED: 0xFF0000>schema(Colors.RED)#-> <Colors.RED: 0xFF0000>schema(123)#-> Invalid: Invalid Colors value, expected Colors, got 1235
参数：
消息：验证错误消息
需要：需要值字符串表示，或无从包装的可调用函数中获取它
返回：callabledecorator
谓词
可能
fromenumimportEnumclassColors(Enum):RED=0xFF0000GREEN=0x00FF00BLUE=0x0000FFschema=Schema(Colors)schema(0xFF0000)#-> <Colors.RED: 0xFF0000>schema(Colors.RED)#-> <Colors.RED: 0xFF0000>schema(123)#-> Invalid: Invalid Colors value, expected Colors, got 1236
验证该值是否与给定架构匹配或是否为"无"。
这支持可为空的值，并为它们提供了良好的表示形式。
fromenumimportEnumclassColors(Enum):RED=0xFF0000GREEN=0x00FF00BLUE=0x0000FFschema=Schema(Colors)schema(0xFF0000)#-> <Colors.RED: 0xFF0000>schema(Colors.RED)#-> <Colors.RED: 0xFF0000>schema(123)#-> Invalid: Invalid Colors value, expected Colors, got 123
7
请注意，它还具有类似于的默认行为-like行为
初始化丢失的required（）键：
fromenumimportEnumclassColors(Enum):RED=0xFF0000GREEN=0x00FF00BLUE=0x0000FFschema=Schema(Colors)schema(0xFF0000)#-> <Colors.RED: 0xFF0000>schema(Colors.RED)#-> <Colors.RED: 0xFF0000>schema(123)#-> Invalid: Invalid Colors value, expected Colors, got 1238
参数：
模式：提供值的模式
无：空值文本
任意
fromenumimportEnumclassColors(Enum):RED=0xFF0000GREEN=0x00FF00BLUE=0x0000FFschema=Schema(Colors)schema(0xFF0000)#-> <Colors.RED: 0xFF0000>schema(Colors.RED)#-> <Colors.RED: 0xFF0000>schema(123)#-> Invalid: Invalid Colors value, expected Colors, got 1239
按顺序尝试提供的架构，并使用第一个成功的架构。
这是或条件谓词：任何模式都应该匹配。
如果两个架构都不匹配，则会报告错误。
defCoerceInt(v):# naive Coerce(int) implementationreturnint(v)Schema(CoerceInt)(1)#-> 1Schema(CoerceInt)('1')#-> 1Schema(CoerceInt)('a')#-> Invalid: invalid literal for int(): expected CoerceInt(), got a
0
参数：
*模式：要尝试的模式列表。
全部
defCoerceInt(v):# naive Coerce(int) implementationreturnint(v)Schema(CoerceInt)(1)#-> 1Schema(CoerceInt)('1')#-> 1Schema(CoerceInt)('a')#-> Invalid: invalid literal for int(): expected CoerceInt(), got a1
值必须通过用谓词包装的所有验证器。
这是和条件谓词：所有模式都应按顺序匹配，
它实际上是一个验证器的组合：all（f，g）（值）=g（f（值））
defCoerceInt(v):# naive Coerce(int) implementationreturnint(v)Schema(CoerceInt)(1)#-> 1Schema(CoerceInt)('1')#-> 1Schema(CoerceInt)('a')#-> Invalid: invalid literal for int(): expected CoerceInt(), got a2
参数：
*模式：要应用的模式列表。
两者都不是
defCoerceInt(v):# naive Coerce(int) implementationreturnint(v)Schema(CoerceInt)(1)#-> 1Schema(CoerceInt)('1')#-> 1Schema(CoerceInt)('a')#-> Invalid: invalid literal for int(): expected CoerceInt(), got a3
值不能与任何架构匹配。
这是not条件谓词：如果每个架构都引发了错误，则认为值有效。
defCoerceInt(v):# naive Coerce(int) implementationreturnint(v)Schema(CoerceInt)(1)#-> 1Schema(CoerceInt)('1')#-> 1Schema(CoerceInt)('a')#-> Invalid: invalid literal for int(): expected CoerceInt(), got a4
参数：
*架构：要检查的架构列表。
包含
defCoerceInt(v):# naive Coerce(int) implementationreturnint(v)Schema(CoerceInt)(1)#-> 1Schema(CoerceInt)('1')#-> 1Schema(CoerceInt)('a')#-> Invalid: invalid literal for int(): expected CoerceInt(), got a5
inclusive验证定义的包含映射键组：
如果提供了其中任何一个，则所有这些都将成为必需的。
这是为了支持映射中的"子结构"，只有在一起指定时才有意义。
由于此验证器对整个映射起作用，最好的方法是将其与
标记：
defCoerceInt(v):# naive Coerce(int) implementationreturnint(v)Schema(CoerceInt)(1)#-> 1Schema(CoerceInt)('1')#-> 1Schema(CoerceInt)('a')#-> Invalid: invalid literal for int(): expected CoerceInt(), got a6
注意inclusive只支持文本。
参数：
*键：相互包含的键（文本）列表。
独家
defCoerceInt(v):# naive Coerce(int) implementationreturnint(v)Schema(CoerceInt)(1)#-> 1Schema(CoerceInt)('1')#-> 1Schema(CoerceInt)('a')#-> Invalid: invalid literal for int(): expected CoerceInt(), got a7
exclusive验证定义的映射键的独占组：
如果提供了其中任何一个键，则其余的键都不能使用。
这支持有选择的"子结构"：如果用户从其中一个选择字段--
那他就不能利用别人了。
它适用于整个映射，因此最好与entire标记一起使用。
默认情况下，独占要求用户选择其中一个选项，
但这可以用作为参数的标记类来覆盖
defCoerceInt(v):# naive Coerce(int) implementationreturnint(v)Schema(CoerceInt)(1)#-> 1Schema(CoerceInt)('1')#-> 1Schema(CoerceInt)('a')#-> Invalid: invalid literal for int(): expected CoerceInt(), got a8
让我们用支持多种身份验证的api演示一下，
但要求用户只选择一个：
defCoerceInt(v):# naive Coerce(int) implementationreturnint(v)Schema(CoerceInt)(1)#-> 1Schema(CoerceInt)('1')#-> 1Schema(CoerceInt)('a')#-> Invalid: invalid literal for int(): expected CoerceInt(), got a9
注意exclusive只支持文本。
参数：
*键：互斥键（文本）列表。
可以包含标记类，
它定义了当没有提供键时的行为。默认值是必需的
类型
键入
sub_schema=Schema(int)schema=Schema([None,sub_schema])schema([None,1,2])#-> [None, 1, 2]schema([None,'1'])#-> Invalid: invalid value0
使用isinstance（）检查值是否具有特定类型。
与执行严格检查的模式类型不同，此检查是放松的，接受子类型
同样，
sub_schema=Schema(int)schema=Schema([None,sub_schema])schema([None,1,2])#-> [None, 1, 2]schema([None,'1'])#-> Invalid: invalid value1
参数：
*键入：要检查实例的类型。
如果提供多种类型，则任何一种都可以接受。
强制
sub_schema=Schema(int)schema=Schema([None,sub_schema])schema([None,1,2])#-> [None, 1, 2]schema([None,'1'])#-> Invalid: invalid value2
将值强制为具有提供的可调用类型。
强制将构造函数应用于输入值，并返回转换为所提供类型的值。如果构造函数因typeerror或valueerror而失败，则该值将被视为无效，并且强制会抱怨
上面有一条自定义消息。但是，如果构造函数引发了--错误对象将被用作它。
sub_schema=Schema(int)schema=Schema([None,sub_schema])schema([None,1,2])#-> [None, 1, 2]schema([None,'1'])#-> Invalid: invalid value3
参数：
构造函数：可调用，用于类型转换输入值
值
输入
sub_schema=Schema(int)schema=Schema([None,sub_schema])schema([None,1,2])#-> [None, 1, 2]schema([None,'1'])#-> Invalid: invalid value4
验证集合中是否有值。
这是一个简单的容器值检查，其中容器是文本的集合。
与any相反，它不会将参数编译为模式，
从而获得更好的性能。
sub_schema=Schema(int)schema=Schema([None,sub_schema])schema([None,1,2])#-> [None, 1, 2]schema([None,'1'])#-> Invalid: invalid value
5
同样的例子也适用于any，但速度较慢：-）
参数：ode>容器：允许值的集合。除了naive tuple/list/set/dict之外，它还可以是任何在操作中支持的对象。
长度
sub_schema=Schema(int)schema=Schema([None,sub_schema])schema([None,1,2])#-> [None, 1, 2]schema([None,'1'])#-> Invalid: invalid value
6
验证提供的集合的长度是否在特定范围内。
sub_schema=Schema(int)schema=Schema([None,sub_schema])schema([None,1,2])#-> [None, 1, 2]schema([None,'1'])#-> Invalid: invalid value7
由于映射也有长度，因此也可以验证它们：
sub_schema=Schema(int)schema=Schema([None,sub_schema])schema([None,1,2])#-> [None, 1, 2]schema([None,'1'])#-> Invalid: invalid value8
参数：
min：最小允许长度，或无限制。
max：最大允许长度，或无限制。
默认值
sub_schema=Schema(int)schema=Schema([None,sub_schema])schema([None,1,2])#-> [None, 1, 2]schema([None,'1'])#-> Invalid: invalid value
9
如果未提供值，则将其初始化为默认值。
"not provided"是指none，因此基本上它用默认值替换nones
schema=Schema([1,2,3])# List of valid valuesschema([1,2,2])#-> [1, 2, 2]schema([1,2,4])#-> Invalid: Invalid value @ [2]: expected List[1|2|3], got 4schema((1,2,2))#-> Invalid: Wrong value type: expected List, got Tuple0
它对除none和默认值之外的所有值都引发无效：
schema=Schema([1,2,3])# List of valid valuesschema([1,2,2])#-> [1, 2, 2]schema([1,2,4])#-> Invalid: Invalid value @ [2]: expected List[1|2|3], got 4schema((1,2,2))#-> Invalid: Wrong value type: expected List, got Tuple
1
此外，默认值具有内置的必需标记的特殊行为：
如果未提供所需的密钥，则使用默认值创建该密钥：
schema=Schema([1,2,3])# List of valid valuesschema([1,2,2])#-> [1, 2, 2]schema([1,2,4])#-> Invalid: Invalid value @ [2]: expected List[1|2|3], got 4schema((1,2,2))#-> Invalid: Wrong value type: expected List, got Tuple
2
参数：
默认值：要使用的默认值
回退
schema=Schema([1,2,3])# List of valid valuesschema([1,2,2])#-> [1, 2, 2]schema([1,2,4])#-> Invalid: Invalid value @ [2]: expected List[1|2|3], got 4schema((1,2,2))#-> Invalid: Wrong value type: expected List, got Tuple3
始终返回默认值。
工作方式类似于默认值，但在任何值上都不会失败。
典型的用法是在没有工作的情况下终止链：
schema=Schema([1,2,3])# List of valid valuesschema([1,2,2])#-> [1, 2, 2]schema([1,2,4])#-> Invalid: Invalid value @ [2]: expected List[1|2|3], got 4schema((1,2,2))#-> Invalid: Wrong value type: expected List, got Tuple4
类似于默认值，它也适用于映射。
在内部，默认值和回退通过向架构提供一个未定义的特殊值来工作：
如果模式成功地返回一些值而没有错误——那么它有一个命名为"默认行为"，
而这个验证器正好利用了这个特性。
"回退值"可以手动提供，其工作原理完全相同
（因为即使给定了未定义的值模式，值模式也能成功）：
schema=Schema([1,2,3])# List of valid valuesschema([1,2,2])#-> [1, 2, 2]schema([1,2,4])#-> Invalid: Invalid value @ [2]: expected List[1|2|3], got 4schema((1,2,2))#-> Invalid: Wrong value type: expected List, got Tuple5
参数：
默认值：始终返回的值
地图
schema=Schema([1,2,3])# List of valid valuesschema([1,2,2])#-> [1, 2, 2]schema([1,2,4])#-> Invalid: Invalid value @ [2]: expected List[1|2|3], got 4schema((1,2,2))#-> Invalid: Wrong value type: expected List, got Tuple6
转换将名称映射为值的枚举。
支持三种枚举：
映射。
提供了从名称到值的映射，
通过映射键将输入转换为值：
schema=Schema([1,2,3])# List of valid valuesschema([1,2,2])#-> [1, 2, 2]schema([1,2,4])#-> Invalid: Invalid value @ [2]: expected List[1|2|3], got 4schema((1,2,2))#-> Invalid: Wrong value type: expected List, got Tuple7
类。
提供了一个属性（名称）初始化为值的类，
将输入转换为按属性名匹配的值：
schema=Schema([1,2,3])# List of valid valuesschema([1,2,2])#-> [1, 2, 2]schema([1,2,4])#-> Invalid: Invalid value @ [2]: expected List[1|2|3], got 4schema((1,2,2))#-> Invalid: Wrong value type: expected List, got Tuple8
注意，类的所有属性都被使用，除了受保护的（\u name）和可调用的属性。
EnU.
支持python 3.4枚举
以及后端口的enum34
提供枚举，按名称将输入转换为值。
此外，枚举值可以安全通过：
schema=Schema([1,2,3])# List of valid valuesschema([1,2,2])#-> [1, 2, 2]schema([1,2,4])#-> Invalid: Invalid value @ [2]: expected List[1|2|3], got 4schema((1,2,2))#-> Invalid: Wrong value type: expected List, got Tuple9
请注意，在mode=map.val中，它的工作方式与schema（enum）
除了"straignt"模式（按键查找）外，它还支持反向匹配：
当mode=map.key时，仅转发匹配（按键）--默认值
当mode=map.val时，只进行反向匹配（按值）
当mode=map.both时，进行双向匹配（先按键，然后按值）另一个简洁的特性是map支持in包含检查，
它与（map（enum value））：in（map（enum value））中的一起工作得很好
实际进行转换。
Schema([# All values should be# .. int ..int,# .. or a string, casted to int ..lambdav:int(v)])([1,2,'3'])#-> [ 1, 2, 3 ]
0
参数：
枚举：枚举：dict，object，of enum
模式：匹配模式：map.key、map.val、map.both中的一个
布尔型
检查
Schema([# All values should be# .. int ..int,# .. or a string, casted to int ..lambdav:int(v)])([1,2,'3'])#-> [ 1, 2, 3 ]1
使用提供的布尔函数作为验证器，当它是false
Schema([# All values should be# .. int ..int,# .. or a string, casted to int ..lambdav:int(v)])([1,2,'3'])#-> [ 1, 2, 3 ]2
参数：
bValidator：布尔验证函数
消息：当false时要报告的错误消息
需要：需要值字符串表示，或无从包装的可调用函数中获取它
truthy
Schema([# All values should be# .. int ..int,# .. or a string, casted to int ..lambdav:int(v)])([1,2,'3'])#-> [ 1, 2, 3 ]3
断言该值在python意义上是真实的。
在所有"falsy"值上都失败：false，0，空集合等。
Schema([# All values should be# .. int ..int,# .. or a string, casted to int ..lambdav:int(v)])([1,2,'3'])#-> [ 1, 2, 3 ]4
错误
Schema([# All values should be# .. int ..int,# .. or a string, casted to int ..lambdav:int(v)])([1,2,'3'])#-> [ 1, 2, 3 ]5
断言该值在python意义上是错误的。
对truthy的补充。
布尔型
Schema([# All values should be# .. int ..int,# .. or a string, casted to int ..lambdav:int(v)])([1,2,'3'])#-> [ 1, 2, 3 ]6
将人类可读的布尔值转换为bool
支持以下值：无：假
bool：直接
int：0=false，其他都是truestr：文本布尔值，与yaml 1.1布尔文本兼容，即：
Schema([# All values should be# .. int ..int,# .. or a string, casted to int ..lambdav:int(v)])([1,2,'3'])#-> [ 1, 2, 3 ]
7
如果提供了未知的字符串文本，则会引发invalid。
示例：
Schema([# All values should be# .. int ..int,# .. or a string, casted to int ..lambdav:int(v)])([1,2,'3'])#-> [ 1, 2, 3 ]8
数字
范围
Schema([# All values should be# .. int ..int,# .. or a string, casted to int ..lambdav:int(v)])([1,2,'3'])#-> [ 1, 2, 3 ]9
验证该值是否在定义的范围（包括）内。
如果没有，则引发错误。
α#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before00
如果无法将该值与数字进行比较，则会引发invalid。
注意，在python2中，几乎所有内容都可以与数字进行比较，包括字符串、dict和列表！
参数：
min：最小允许值，或none不施加限制。
max：最大允许值，或无限制。
夹钳
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before
01
将一个值钳制到定义的范围（包括该范围）。
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before02
如果无法将该值与数字进行比较，则会引发invalid。
注意，在python2中，几乎所有内容都可以与数字进行比较，包括字符串、dict和列表！
参数：
min：最小允许值，或none不施加限制。
max：最大允许值，或无限制。
字符串
下
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before
03
将提供的字符串强制转换为小写，失败的是输入值不是字符串。
支持二进制和Unicode字符串。
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before04
上部
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before05
将输入字符串转换为大写。
大写
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before06
将输入字符串大写。
标题
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before07
将输入字符串转换为标题大小写
匹配
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before08
根据正则表达式验证输入字符串。
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before09
参数：
模式：要与之匹配的regexp模式：字符串或编译的模式
消息：错误消息覆盖
期望值：用户期望值的文本表示
更换
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before10
regexp替换。
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before11
参数：
模式：要与之匹配的regexp模式：字符串或编译的模式
repl：替换模式。
支持反向引用，就像在re模块。
消息：错误消息覆盖
期望值：用户期望值的文本表示
url
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before12
验证URL，确保它是绝对格式，包括协议。
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before13
参数：
协议：允许的协议列表。
如果用户没有提供协议，则默认使用第一个协议。
电子邮件
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before14
验证值是否为电子邮件地址。
这只是测试"@"符号是否存在，是否由一些字符包围。
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before15
日期
日期时间
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before16
验证输入是否为pythondatetime
支持以下输入值：
日期时间：传递
string：使用任何指定格式解析字符串
（请参见strptime（））
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before17
时区注意事项：
如果格式不支持时区，则始终返回naivedatetime对象（不带tzinfo）。
如果格式支持时区（使用%z/%z），
它返回一个感知对象（带有tzinfo）。
因为python2并不总是支持手动操作。
由于这种解决方法的有限性，对%z的支持只有在字符串末尾时才起作用！
结果，"00:00:00"被解析为一个天真的日期时间，"00:00:00+0200"导致感知的日期时间。
如果您的应用程序需要不同的规则，请使用本地化和astz：
本地化参数是要在天真的日期时间上设置的默认时区，
或应用于输入并应返回调整后的日期时间
astz参数是调整awaredatetime到或可调用的时区。
那么一般的配方是：
将本地化设置为您希望用户输入日期时间的时区（或可调用的时区）
将astz设置为您希望在结果中显示的时区。
这对于优秀的pytz库最有效。
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before
18
注意：要避免一些痛苦，请确保始终使用naive日期时间调整为UTC！
Armin Ronacher在这里解释它
综上所述，验证过程分为三步：
解析（仅限字符串）
如果是天真的，则应用本地化并使其感知（如果指定了本地化
如果知道--应用astz来转换它（如果指定了astz）
参数：
格式：支持的格式字符串，或一系列可供尝试的格式。
本地化：将天真日期时间调整到时区，使其感知
一个时区对象，
或者一个可调用的，应用于naive日期时间，并应返回一个调整后的值。
只要求天真日期时间s。
astz：将aware调整到另一个时区。
一个时区对象，
或应用于感知的日期时间并应返回调整后的值的可调用项。

＜P>仅调用awaredatetimes，包括由localize创建的
日期
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before
19
验证输入是否为pythondate
支持以下输入值：
日期：传递
日期时间：取.date（）部分
字符串：解析（请参见datetime）
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before20
参数：
时间
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before21
验证输入是否为pythontime
支持以下输入值：
时间：通过
datetime：接受.timetz（）部分
字符串：解析（请参见datetime）
因为时间会受到时区问题的影响，
确保您已经阅读了datetime文档的相关部分中的注释。
参数：
文件
isfile
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before22
确认文件存在。
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before23
isdir
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before24
确认目录存在。路径存在
#from voluptuous import *  # no morefromgood.voluptuousimport*# replacement# .. and use it like before25
确认路径存在。
标签：
from
import
schema
post1
voluptuous
expected
good
invalid
苗条
欢迎加入QQ群-->： 979659372
                                    
推荐PyPI第三方库
immutables
不可变集合
dja_skel
Django Skeleton Generatior
bbcu.bt-flor
bt-flor-从长读中构建转录本
nnisgf
神经网络智能包
NextFreeFileName
轻松找到下一个可用文件名
grpc-pytools
一些有用的python的grpc工具。
jpath
使用类似json的路径表示法访问嵌套的dict和list。
Red-Lavalink
用于Red Discordbot的Lavalink客户端库
us-polygon-mapper
从csv、python字典和pandas数据帧创建google maps us polygon maps
tilemapbase
在python/matplotlib中使用openstreetmap tiles作为基础地图
github-pages-publish
将文件从目录提交到当前git存储库的gh pages分支的脚本。
data-catapult
python批量数据加载etl库
drawer
动态可重用aspect weaver——python中动态aspect编织的实现。
sentiment_classifier
基于词义消歧、senti词网和电影评论语料库词频统计的情感分类
py-aiger-cnf
要在aiger和cnf之间转换的python库

导航栏项目描述版本历史下载文件项目链接首页标签许可证: BSD许可证（BSD 3条款）作者信息:: 暂无维护者 kolypto 最新PyPI项目 italian_vip_says UFx vofs fake_item_generator NerEva django-monologue fio_product_attribute_strict climailsystem pyshape tbb-devel npy-append-arra anthill.tal.macrorenderer odoo11-addon-stock-a uuuu contextil fyl_nester appomatic_renderable teacher chuletas slackbot_ce 最新Python常见问题使用登录请求.post导致“错误405不允许” 使用登录进行Python web抓取使用登录进行抓取使用登录页面从网站抓取数据使用白色圆圈背景使图像更平滑使用百分位数删除Pandas数据帧中的异常值使用百分号进行Python字典操作使用百分比delimi的Python字符串模板使用百分比分割Numpy ndarray最有效的方法是什么？使用百分比分配和修改变量（计算）使用百分比单位绘制数据使用百分比在单个采购订单中组合不同的订单类型使用百分比将数据帧的子集与完整数据帧进行比较使用百分比形式的BBOX选项，而不是绝对像素PyScreenShot Python 使用百分比登录列nam更新表

good 0.0.7.post1

good的Python项目详细描述

良好

目录

替代品数量急剧下降

模式

可调用项

优先级

创建模式

正在验证

错误

无效

无效的.enrich（）

多重有效

标记

必需的

可选

删除

拒绝

允许

额外的

整个

验证工具

助手

对象

消息

测试

消息

名称

真理

谓词

可能

任意

全部

两者都不是

包含

独家

类型

键入

强制

值

输入

长度

默认值

回退

地图

布尔型

检查

truthy

错误

布尔型

数字

范围

夹钳

字符串

下

上部

大写

标题

匹配

更换

url

电子邮件

日期

日期时间

日期

时间

文件

isfile

isdir

路径存在

推荐PyPI第三方库

immutables

dja_skel

bbcu.bt-flor

nnisgf

NextFreeFileName

grpc-pytools

jpath

Red-Lavalink

`模式`

`优先级`

`创建模式`

`无效的.enrich（）`

`标记`

`必需的`

`可选`

`删除`

`拒绝`

`允许`

`额外的`

`整个`

`对象`

`消息`

`测试`

`消息`

`名称`

`真理`

`可能`

`任意`

`全部`

`两者都不是`

`包含`

`独家`

`键入`

`强制`

`输入`

`长度`

`默认值`

`回退`

`地图`

`检查`

`truthy`

`错误`

`布尔型`

`范围`

`夹钳`

`字符串`

`下`

`上部`

`大写`

`标题`

`匹配`

`更换`

`url`

`电子邮件`

`日期时间`

`日期`

`时间`

`isfile`

`isdir`

`路径存在`

导航栏

项目链接

标签