Python 用列表数据理解棉花糖嵌套模式

我是python新手，我是usign序列化。无法使用嵌套的scehma。 ，我的代码

from sqlalchemy import Column, Float, Integer, String, Text, text,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship

Base = declarative_base()
metadata = Base.metadata




class CompanyDemo(Base):
    __tablename__ = 'company_demo'

    company_id = Column(Integer, primary_key=True,                                                     
    server_default=text("nextval('company_demo_company_id_seq'::regclass)"))
    name = Column(Text, nullable=False)
    address = Column(String(50))
    location = Column(String(50))


 class UsersDemo(Base):
    __tablename__ = 'users_demo'

    id = Column(Integer, primary_key=True,                                                                                                                    
    server_default=text("nextval('users_demo_id_seq'::regclass)"))
    company_id = Column(Integer,ForeignKey('company_demo.company_id'), nullable=False)
    email = Column(String)

company = relationship('CompanyDemo')

模式

    from marshmallow import Schema, fields, pprint


    class CompanySchema(Schema):
        company_id = fields.Int(dump_only=True)
        name = fields.Str()
        address = fields.Str()
        location = fields.Str()


    class UserSchema(Schema):
        email = fields.Str()   
        company = fields.Nested(CompanySchema)


    user = UserSchema()
    user = UserSchema(many=True)
    company = CompanySchema()
    company = CompanySchema(many=True)

还有我的烧瓶应用程序

    from flask import Flask, jsonify, url_for, render_template
    from sqlalchemy import create_engine
    from sqlalchemy.orm import sessionmaker
    from flask_sqlalchemy import SQLAlchemy
    from model import CompanyDemo, UsersDemo
    from schemas.userschema import user, company

    app = Flask(__name__)
    app.secret_key = "shiva"


    def db_connect():
        engine = create_engine('postgresql://ss@127.0.0.1:5432/test')
        Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
        # create a Session
        session = Session()
        session._model_changes = {}
        return session


    @app.route('/company', methods=["GET", "POST"])
    def get_all_company():
        db = db_connect()
        allcompany = db.query(CompanyDemo).join(UsersDemo).all()
        return jsonify(company.dump(allcompany, many=True).data)  # company is marshmallow schema


    if __name__ == '__main__':
        app.run(host='0.0.0.0', port=15418, debug=True)

我的代码有问题吗？我面临嵌套模式的问题，无法在输出中获取嵌套数据

输出如下

[{ “地址”：“qqq”， “公司id”：1， “地点”：“www”， “名称”：“eee”}{ “地址”：“www”， “公司id”：2， “位置”：“qqq”， “名称”：“aaa”}]

---

使用内存中SQLite的自包含示例：

from flask import Flask, jsonify
from flask_sqlalchemy import SQLAlchemy
from marshmallow import Schema, fields, pprint

app = Flask(__name__)
app.config['DEBUG'] = True
app.config['SECRET_KEY'] = 'super-secret'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
app.config['SQLALCHEMY_ECHO'] = True
db = SQLAlchemy(app)


class CompanyDemo(db.Model):
    __tablename__ = 'company_demo'

    company_id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.Text, nullable=False)
    address = db.Column(db.String(50))
    location = db.Column(db.String(50))

    def __unicode__(self):
        return u"{name} ({address})".format(name=self.name, address=self.address)


class UsersDemo(db.Model):
    __tablename__ = 'users_demo'

    id = db.Column(db.Integer, primary_key=True,)
    company_id = db.Column(db.Integer, db.ForeignKey('company_demo.company_id'), nullable=False)
    company = db.relationship('CompanyDemo')
    email = db.Column(db.String)

    def __unicode__(self):
        return u"{email}".format(email=self.email)


class CompanySchema(Schema):
    company_id = fields.Int(dump_only=True)
    name = fields.Str()
    address = fields.Str()
    location = fields.Str()


class UserSchema(Schema):
    email = fields.Str()
    company = fields.Nested(CompanySchema)

user_schema = UserSchema()
company_schema = CompanySchema()


@app.route('/')
def index():
    return "<a href='/dump_company'>Dump Company</a><br><a href='/dump_user'>Dump User</a>"

@app.route('/dump_user')
def dump_user():
    user = UsersDemo.query.first()
    return jsonify(user_schema.dump(user).data)

@app.route('/dump_company')
def dump_company():
    company = CompanyDemo.query.first()
    return jsonify(company_schema.dump(company).data)


def build_db():
    db.drop_all()
    db.create_all()
    company = CompanyDemo(name='Test 1', address='10 Downing Street', location='wherever')
    db.session.add(company)
    user = UsersDemo(email='fred@example.com', company=company)
    db.session.add(user)
    db.session.commit()


@app.before_first_request
def first_request():
    build_db()

if __name__ == '__main__':
    app.run(debug=True, port=7777)

从烧瓶导入烧瓶，jsonify
从flask_sqlalchemy导入sqlalchemy
从棉花糖导入模式，字段，pprint
app=烧瓶（名称）
app.config['DEBUG']=True
app.config['SECRET_KEY']='super SECRET'
app.config['SQLALCHEMY\u TRACK\u MODIFICATIONS']=False
app.config['SQLALCHEMY\u DATABASE\u URI']='sqlite://:memory:'
app.config['SQLALCHEMY_ECHO']=True
db=SQLAlchemy（应用程序）
类别CompanyDemo（数据库模型）：
__tablename_uuu='company_udemo'
公司id=db.Column（db.Integer，主键=True）
name=db.Column（db.Text，null=False）
地址=db.Column（db.String（50））
位置=分贝列（分贝字符串（50））
def ___; unicode（自）：
返回u“{name}（{address}）”格式（name=self.name，address=self.address）
类UsersDemo（db.Model）：
__tablename_uuu='users\u demo'
id=db.Column（db.Integer，主键=True，）
company\u id=db.Column（db.Integer，db.ForeignKey（'company\u demo.company\u id'），nullable=False）
company=db.relationship（'CompanyDemo'）
email=db.Column（db.String）
def ___; unicode（自）：
返回u“{email}”。格式（email=self.email）
类别CompanySchema（模式）：
公司id=fields.Int（dump\u only=True）
name=fields.Str（）
address=fields.Str（）
location=fields.Str（）
类UserSchema（模式）：
email=fields.Str（）
company=字段。嵌套（CompanySchema）
user_schema=UserSchema（）
公司模式=公司模式（）
@应用程序路径（“/”）
def index（）：
返回“
”
@app.route（“/dump\u user”）
def dump_user（）：
user=UsersDemo.query.first（）
返回jsonify（user_schema.dump（user.data））
@应用程序路径（“/dump_company”）
def dump_company（）：
company=CompanyDemo.query.first（）
返回jsonify（company\u schema.dump（company.data））
def build_db（）：
db.drop_all（）
db.create_all（）
company=CompanyDemo（名称='test1'，地址='唐宁街10'，位置='where'）
db.session.add（公司）
user=UsersDemo（email=）fred@example.com，company=company）
db.session.add（用户）
db.session.commit（）
@第一次请求前的应用程序
def first_request（）：
build_db（）
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
运行（调试=True，端口=7777）

您对嵌套字段的声明错误。它应该是

company=fields.Nested（CompanySchema）

对不起，我也尝试了company=fields.Nested（CompanySchema）。不走运！您已使用

CompanyScheme

转储，但嵌套字段的是

UserScheme

。