preface
The main way to define objects in pydantic is through models (models inherit BaseModel). pydantic is mainly a parsing library, not a validation library. Verification is a means to achieve the goal: establish a model that conforms to the types and constraints provided. In other words, pydantic guarantees the types and constraints of the output model, not the input data. Although validation is not the primary purpose of pydantic, you can use this library for custom validation.
Basic model usage
User is a model. It has two field IDS, one is an integer, which is required, the other is a string, which is not required (it has a default value)
from pydantic import BaseModel class User(BaseModel): id: int name = 'yo yo'
Type name is inferred from the default value (string), so type comments are not required (but note the warning about field order when some fields do not have type comments)
user = User(id='123')
User this is an instance of user. Object initialization will perform all parsing and validation. If no ValidationError is raised, it indicates that the generated model instance is valid. The user instance has two attributes: id and name
user = User(id='123') print(user.id) # 123 print(user.name) # yo yo
The fields of the model can be accessed as common properties of user objects. The string '123' has been converted to int according to the field type name is not set when initializing the user, so it has a default value
So how do you know which required fields are required during initialization? Can pass__ fields_set__ method
print(user.__fields_set__) # {'id'}
. dict() can convert the attributes of the user object into dictionary format for output, and dict(user) is also equivalent
print(user.dict()) # {'id': 123, 'name': 'yo yo'} print(dict(user)) # {'id': 123, 'name': 'yo yo'}
. json() can convert the attributes of the user object into json format output
print(user.json()) # {"id": 123, "name": "yo yo"}
BaseModel model properties
The above example is just the tip of the iceberg showing what the model can do. The model has the following methods and properties: dict() returns a dictionary of model fields and values; see. Export model json() returns a JSON string representing dict(); see. Export model copy() returns a shallow copy of the model by default; see. Export model parseobj() a utility for loading any object into a model with error handling if the object is not a dictionary; see. auxiliary function parseraw() is a utility for loading strings of various formats; see. auxiliary function parsefile() likes parseraw(), but for file paths; see. auxiliary function fromorm() loads data from any class into the model; see. ORM mode schema() returns the dictionary that represents the model as JSON Schema; see. Schema Schemajson() returned by schema(); For the JSON string representation of. Schema construct() creates the class method of the model without running verification; see. Create a model without validation `__ fields_set the field name set when initializing the model instance__ Fields Dictionary of model fields__ Configure the cf ` model. Model config uration
Recursive model
You can use the model itself as a type in the annotation to define a more complex hierarchical data structure.
from typing import List from pydantic import BaseModel class Foo(BaseModel): count: int size: float = None class Bar(BaseModel): apple = 'x' banana = 'y' class Spam(BaseModel): foo: Foo bars: List[Bar] m = Spam(foo={'count': 4}, bars=[{'apple': 'x1'}, {'apple': 'x2'}]) print(m) #> foo=Foo(count=4, size=None) bars=[Bar(apple='x1', banana='y'), #> Bar(apple='x2', banana='y')] print(m.dict()) """ { 'foo': {'count': 4, 'size': None}, 'bars': [ {'apple': 'x1', 'banana': 'y'}, {'apple': 'x2', 'banana': 'y'}, ], } """
auxiliary function
Pydantic provides three classmethod auxiliary functions for the model of parsing data:
- parseobj: This is very similar to the model approach_ init, except that it requires a dictionary instead of a keyword parameter. ValidationError is thrown if the object passed is not dict.
- parse_raw: This requires a str or bytes, parses it into json, and passes the result to parse_obj. Parsing kimchi data is also supported by properly setting parameters. content_type
- parse_file: This requires a file path to read the file and pass the content to parse_raw. If content_ If type is omitted, it is inferred from the extension of the file.
parse_ Use of obj
from datetime import datetime from pydantic import BaseModel, ValidationError class User(BaseModel): id: int name = 'John Doe' signup_ts: datetime = None m = User.parse_obj({'id': 123, 'name': 'James'}) print(m) # id=123 signup_ts=None name='James'
parse_raw requires a str or bytes and resolves it to json
m = User.parse_raw('{"id": 123, "name": "James"}') print(m) # > id=123 signup_ts=None name='James'
parse_file can read the contents of a file data.json file
{ "id": 123, "name": "James" }
from pathlib import Path path = Path('data.json') # Read file contents m = User.parse_file(path) print(m) # > id=123 signup_ts=None name='James'
.write_text() can write its own content to the file
from pathlib import Path path = Path('data1.json') path.write_text('{"id": 345, "name": "James 11"}') m = User.parse_file(path) print(m) # > id=345 name='James 11'