前言

这几年一直在it行业里摸爬滚打，一路走来，不少总结了一些python行业里的高频面试，看到大部分初入行的新鲜血液，还在为各样的面试题答案或收录有各种困难问题

于是乎，我自己开发了一款面试宝典，希望能帮到大家，也希望有更多的Python新人真正加入从事到这个行业里，让python火不只是停留在广告上。

微信小程序搜索：Python面试宝典

或可关注原创个人博客：https://lienze.tech

也可关注微信公众号，不定时发送各类有趣猎奇的技术文章：Python编程学习

表关系

多对一

一对多关系创建表通过db.ForeignKey关联

建立多对一的关系，比如一个老师有多个学生，一个学生只能有一个老师

• 老师表

class Teacher(db.Model):
    __tablename__ = "teachers"
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(32))
    students = db.relationship("Student", backref="teachers", lazy="dynamic")

• 学生表

class Student(db.Model):
    __tablename__ = "students"
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(32))
    teacher_id = db.Column(db.Integer, db.ForeignKey("teachers.id", ondelete="SET NULL"))

db.Column(db.Integer, db.ForeignKey(“teachers.id”, ondelete=“SET NULL”))

构建外键: 通过db.ForeignKey进行设置，括号内参数为对应表的id属性，ondelete属性代表当前外键约束效果

1. RESTRICT

   若子表中有父表对应的关联数据，删除父表对应数据，会阻止删除，也是默认项

2. NO ACTION

   在MySQL中，同RESTRICT

3. CASCADE

   级联删除

4. SET NULL

   父表对应数据被删除，子表对应数据项会设置为NULL

db.relationship(“Teacher”, backref=“teachers”, lazy=“dynamic”)

构建关联关系: 类似手动声明了django的orm中_set字段，一般关联外键是为了方便进行关联表直接的orm正反查询，常建议写在一的一方

lazy: 指定sqlalchemy数据库什么时候加载数据

1. select: 就是访问到属性的时候，就会全部加载该属性的数据
2. joined: 对关联的两个表使用联接
3. subquery: 与joined类似，但使用子子查询
4. dynamic: 不加载记录，但提供加载记录的查询，也就是生成query对象，在这个对象基础上还支持继续进行filter、all等操作
   • dynamic属性只能用在多对一中为一的一方，比如学生老师中的老师一方，这样lazy属性对应的就是多的一方了

一对一关系:在relationship里面lazy变量去掉,换成uselist=False

多对一添加

创建或者查询老师，将老师数据对应的id赋值到学生数据中

t1 = Teacher.query.first() # 查询获得
#-------------------------
t1 = Teacher(name="t1")
db.session.add(t1)
db.session.commit()

s1 = Student(name="s1")
s1.teacher_id = t1.id
db.session.add(s1)
db.session.commit()

使用关联关系db.relationship进行添加，同样也可以添加一个已的老师作为外键，或者在添加过程中创建一个新的老师

这里使用时，通过db.relationship(“Teacher”, backref="teachers", lazy=“dynamic”)关系中，在学生表指明的teachers属性进行赋值

s = Student(name="s", teachers=Teacher(name="t")) # 创建个新老师
# ----------------------------------------------
t = Teacher.query.first() # 查询已有老师
s = Student(name="s", teachers=t) # 用已有的老师

db.session.add(s)
db.session.commit()

除了在建立学生时，正向赋值老师外键，关系型外键还支持反向创建，比如在建立老师过程中，将关联这个老师的学生们创建出来

注意关联这个老师的学生们是一个集合，并不是单独一条数据，所以字段赋值时采用序列形式

t = Teacher(name="t") # 创建老师对象
t.students = [Student(name="s1"), Student(name="s2")] # 老师外键关联对象赋值关联他的学生们
db.session.add(t)
db.session.commit()

同理可得，其实也可以在创建老师时，赋值外键关联对象时，使用已经查找到的学生们，比如

t = Teacher(name="t") # 创建老师对象
t.students = Student.query.all() # 老师外键关联对象赋值关联他的学生们
db.session.add(t)
db.session.commit()

多对一查询

普通的查询，比如通过一个学生，查询这个学生的老师名

s = Student.query.first()
t = Teacher.query.get(s.teacher_id)

非常的麻烦，需要两步，但是现在如果通过关联关系db.relationship就比较简单了

数据查询

首先是正向查询，查询一个学生的老师

s = Student.query.first()
s.teachers.name # 通过关联关系就可以直接拿到对应老师，不需要再用id获取

如果是反向查询，查询一个老师对应的学生们

t = Teacher.query.get(4)
t.students.all() # 由于此时设置的是dynamic属性，返回的数据结果为一个AppenderBaseQuery对象，继续对其进行查询结果即可拿到真正数据

表查询

查询哪些学生的老师叫t，如果在表结构层面正向查询，通过原始的id查询就像下面这样

s = Student.query.filter(
  	Student.teacher_id.in_(db.session.query(Teacher.id).filter(Teacher.name == "t"))
).all()

如果在关联关系上进行正向查询，那么可以

s = Student.query.filter(
  Student.teachers == Teacher.query.filter_by(name="t").first()).all()

s = Student.query.filter(Student.teachers.has(Teacher.name == "t")).all()
# 通过has语句，在多的一方使用，因为Student.teachers只能是一

反向查询比如查询哪些老师带的学生名字叫s，那么可以这么查

t = Teacher.query.filter(Teacher.students.any(Student.name == "s")).all()
# 使用any语句，在一的一方使用，因为Teacher.students是多

或者使用query.jion连接来实现外键的查询

t = Teacher.query.join(Student).filter(Student.name.like("%s%")).all()
t = Teacher.query.join(Student).filter(Student.name.contains("s")).all()

多对一修改

更新某个学生的外键为另外一个，使用关联关系直接赋值即可

s = Student.query.first()
s.teachers = Teacher.query.first()
db.session.commit()

修改张姓老师下的所有学生外键为另一个，所有姓张的老师都辞职了，不干了，他的学生统统转移到另外一个老师下

Student.query.filter(
  Student.teachers.has(Teacher.name.startswith("张"))
).update({
    
    "teacher_id": Teacher.query.get(4).id}, synchronize_session=False)
db.session.commit()

多对一删除

删除姓名为张开头老师的所有学生

Student.query.filter(
Student.teachers.has(Teacher.name.startswith("张"))).delete(synchronize_session="fetch")
db.session.commit()

删除老师的话，那么对应动作取决于外键设置的ondelete属性

多对多

sqlalchemy的多对多使用第三张表完成关联关系

比如关注功能，用户可以被多个用户所关注，那么就可以采用多对多来完成，注意为了方便使用orm

• 用户表

class User(db.Model):
    __tablename__ = 'users'

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(32))
    
    fans = db.relationship("User", secondary="follows", backref=db.backref("idols", lazy="dynamic"),
                           lazy="dynamic", # 由于是多对多，所以生成query对象可以继续查询
                           primaryjoin=(Follow.idol == id), # 左侧，用于获取 我的粉丝
                           secondaryjoin=(Follow.fans == id) # 右侧，用于获取 我的偶像
                          )
    
    def __repr__(self): return self.name

backref

​ 替换了原来的参数，变为了一个属性参数，并使反向关系的结果也成为一个query对象，支持继续查询过滤

secondary

​ 用来指明中间的关系表，构建额外多对多关系的表

primaryjoin

​ 多对多中用于从子对象查询其父对象的 condition（child.parents），默认只考虑外键

secondaryjoin

​ 多对多中用于从父对象查询其所有子对象的 condition（parent.children），同样的，默认情况下只考虑外键

• 实现关注的第三张表

class Follow(db.Model):
    __tablename__ = 'follows'

    id = db.Column(db.Integer, primary_key=True)
    idol = db.Column(db.Integer, db.ForeignKey("users.id"))  # 偶像
    fans = db.Column(db.Integer, db.ForeignKey("users.id"))  # 粉丝
    db.UniqueConstraint('idol', 'fans', name="follow_relation")

    def __repr__(self): return self.name