资讯专栏INFORMATION COLUMN

marshmallow之schema嵌套

miracledan / 2810人阅读

摘要:嵌套可以嵌套使用以表示对象间的关系如外键关系。在下面的例子中,和对象是一对多的关系必须使用或参数避免无限递归也可以使用导入模块的方式传递嵌套,如自嵌套给传递字符串参数表示和对象本身的关系

schema嵌套

schema可以嵌套使用以表示对象间的关系(如外键关系)。

例如下例中Blog有一个用User对象表示的author属性:

import datetime as dt

class User(object):
    def __init__(self, name, email):
        self.name = name
        self.email = email
        self.created_at = dt.datetime.now()
        self.friends = []
        self.employer = None

class Blog(object):
    def __init__(self, title, author):
        self.title = title
        self.author = author  # A User object

使用Nested子类接收嵌套的schema表示二者的关系:

from marshmallow import Schema, fields, pprint

class UserSchema(Schema):
    name = fields.String()
    email = fields.Email()
    created_at = fields.DateTime()

class BlogSchema(Schema):
    title = fields.String()
    author = fields.Nested(UserSchema)

序列化后的blog对象将包含嵌套的user对象:

user = User(name="Monty", email="monty@python.org")
blog = Blog(title="Something Completely Different", author=user)
result = BlogSchema().dump(blog)
pprint(result)
# {"title": u"Something Completely Different",
#  "author": {"name": u"Monty",
#             "email": u"monty@python.org",
#             "created_at": "2014-08-17T14:58:57.600623+00:00"}}

如果field嵌套对象是一个集合,必须设置many=True,如collaborators = fields.Nested(UserSchema, many=True)

指定嵌套对象的序列化字段

设置only参数显式地指定对嵌套对象的哪些属性进行序列化:

class BlogSchema2(Schema):
    title = fields.String()
    author = fields.Nested(UserSchema, only=["email"])

schema = BlogSchema2()
result = schema.dump(blog)
pprint(result)
# {
#     "title": u"Something Completely Different",
#     "author": {"email": u"monty@python.org"}
# }

使用点分隔符可以表示深层嵌套对象的属性:

class SiteSchema(Schema):
    blog = fields.Nested(BlogSchema2)

schema = SiteSchema(only=["blog.author.email"])
result, errors = schema.dump(site)
pprint(result)
# {
#     "blog": {
#         "author": {"email": u"monty@python.org"}
#     }
# }

如果给only参数传递的是字符串(上面的例子传递的是列表),将返回单个值(上面的例子返回的是键值映射)或值的列表(需要设置many=True):

class UserSchema(Schema):
    name = fields.String()
    email = fields.Email()
    friends = fields.Nested("self", only="name", many=True)
# ... create ``user`` ...
result, errors = UserSchema().dump(user)
pprint(result)
# {
#     "name": "Steve",
#     "email": "steve@example.com",
#     "friends": ["Mike", "Joe"]
# }
双向嵌套

对于两个互相嵌套的对象,可以使用类名引用嵌套的schema,即便是引用时该schema还没有被定义。

在下面的例子中,Author和Book对象是一对多的关系:

class AuthorSchema(Schema):
    # 必须使用only或exclude参数避免无限递归
    books = fields.Nested("BookSchema", many=True, exclude=("author", ))
    class Meta:
        fields = ("id", "name", "books")

class BookSchema(Schema):
    author = fields.Nested(AuthorSchema, only=("id", "name"))
    class Meta:
        fields = ("id", "title", "author")
from marshmallow import pprint
from mymodels import Author, Book

author = Author(name="William Faulkner")
book = Book(title="As I Lay Dying", author=author)
book_result, errors = BookSchema().dump(book)
pprint(book_result, indent=2)
# {
#   "id": 124,
#   "title": "As I Lay Dying",
#   "author": {
#     "id": 8,
#     "name": "William Faulkner"
#   }
# }

author_result, errors = AuthorSchema().dump(author)
pprint(author_result, indent=2)
# {
#   "id": 8,
#   "name": "William Faulkner",
#   "books": [
#     {
#       "id": 124,
#       "title": "As I Lay Dying"
#     }
#   ]
# }

也可以使用导入模块的方式传递嵌套schema,如books = fields.Nested("path.to.BookSchema", many=True, exclude=("author", ))

schema自嵌套

给Nested传递字符串参数self表示和对象本身的关系:

class UserSchema(Schema):
    name = fields.String()
    email = fields.Email()
    friends = fields.Nested("self", many=True)
    # Use the "exclude" argument to avoid infinite recursion
    employer = fields.Nested("self", exclude=("employer", ), default=None)

user = User("Steve", "steve@example.com")
user.friends.append(User("Mike", "mike@example.com"))
user.friends.append(User("Joe", "joe@example.com"))
user.employer = User("Dirk", "dirk@example.com")
result = UserSchema().dump(user)
pprint(result.data, indent=2)
# {
#     "name": "Steve",
#     "email": "steve@example.com",
#     "friends": [
#         {
#             "name": "Mike",
#             "email": "mike@example.com",
#             "friends": [],
#             "employer": null
#         },
#         {
#             "name": "Joe",
#             "email": "joe@example.com",
#             "friends": [],
#             "employer": null
#         }
#     ],
#     "employer": {
#         "name": "Dirk",
#         "email": "dirk@example.com",
#         "friends": []
#     }
# }

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/43866.html

相关文章

  • marshmallow快速上手

    摘要:方法对应的是方法,它反序列化一个字典为数据结构。某些例如和内置了验证器验证集合时,错误字典将基于无效字段的索引作为键通过给的参数传递对象,可以执行额外的验证验证函数可以返回布尔值或抛出异常。 快速上手 Declaring Schemas 首先创建一个基础的user模型(只是为了演示,并不是真正的模型): import datetime as dt class User(object)...

    jhhfft 评论0 收藏0
  • marshmallowSchema延伸功能

    摘要:创建实例时如果传递了,表示需要接收输入数据集合,装饰器注册预处理和后处理方法时需要传递参数。 预处理和后处理方法 数据的预处理和后处理方法通过pre_load, post_load, pre_dump和post_dump装饰器注册: from marshmallow import Schema, fields, pre_load class UserSchema(Schema): ...

    hzx 评论0 收藏0
  • marshmallow自定义Field

    摘要:有三种方式创建自定义的。下面的例子判断某个对象是否是某个对象的作者,以及的属性是否出现单词自定义错误信息字段验证产生的错误信息可以在类级别或实例级别配置。在类级别时,可以定义为错误码和错误信息的字典映射在类实例化时,给参数传参对象 有三种方式创建自定义的field。 创建Field类的子类 创建继承自marshmallow.fields.Field类的子类并实现_serialize和/...

    AWang 评论0 收藏0
  • Python序列化模型数据为JSON

    摘要:下面我们来说说如何使用来减轻序列化模型的工作量。主要包括如下个步骤定义模式序列化模型下面我们分别来看看。不得不说这个库对于序列化模型其实挺实用的。 原文地址: http://52sox.com/use-python-serialization-orm-data-to-json/ 相信使用Python做Web开发的朋友都会遇到这样1个问题,那就是在项目开发中使用模型框架,比如SQLAlc...

    nifhlheimr 评论0 收藏0
  • python和flask框架开发以太坊智能合约

    摘要:是以太坊开发的个人区块链,可用于部署合约,开发应用程序和运行测试。安装是一个用于与以太坊交互的库。启动以太坊测试区块链服务器要部署智能合约,我们应该启动测试以太坊服务器。最后,你将在以太坊合约中设置调用用户对象时获得的值。 将数据存储在数据库中是任何软件应用程序不可或缺的一部分。无论如何控制该数据库都有一个该数据的主控。区块链技术将数据存储到区块链网络内的区块中。因此,只要某个节点与网...

    enrecul101 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<