flask 中的ORM

1 响应(response)
    1 什么是响应
        响应就是由服务器端带给客户端的内容,对应着请求,响应可以是普通的字符串,模板 或重定向
        return ‘普通字符串‘
        return render_template(‘xxx.html‘)
    2 响应对象
        响应对象:将响应的内容封装到一个对象中,可以完成更多的响应的行为(如:增加cookies,..)
        在Flask中,使用 make_response() 构建响应对象
2 文件上传
    1 注意问题
        表单中如果有文件上传的话,必须遵循以下两个要求
        1 提交方式 method 必须为 post
        2 表单的 enctype 属性值必须为 multipart/form-data
    2 服务器端
        1 通过 request.files 获取文件上传
            f = request.files[‘文件框的name值‘]
        2 通过 f.save(保存路径) 将文件保存至指定目录处
            通过 f.filename 获取文件的名称
            f.save(‘/static‘)#文件路径
3 模型 - Models
    1 什么是模型
        模型,是根据数据库中表的结构而创建出来的class
        表中的每一个列对应到编程语言中就class中的一个属性
    2 模型的框架- orm
        1 数据表(table)到编程类(class)的映射
            数据库中的每一张表 对应到 编程语言中 都有一个类
            在ORM中:
                允许将数据表 自动生成一个类
                允许将类自动 生成一张数据表
        2 数据类型的映射
            将数据库表中的字段以及数据类型 对应到 编程语言中类的属性
            在ORM中:
                允许将表中的字段和数据类型自动映射到编程语言中
                也允许将类中的属性和数据类型也自动映射到表中
        3 关系映射
            将数据库中表与表之间的关系 对应 到编程语言中类与类之间的关系
            数据库中表与之间的关系
                1 一对一
                    外键,主键,唯一约束
                    A表中的一条数据只能与B表中的一条数据相关联
                2 一对多
                    外键,主键
                    一门课程可以被多个老师所教授

                    A表中的一条数据可以与B表中的任意多条数据相关联,反之,B表中的一条数据只能与A表中的一条数据相关联
                3 多对多
                    通过第三张关联表去关联两张表
                    A 表中的一条数据可以与B表中的任意多条数据相关联,B表中的一条数据也可以与A表中的任意多条数据相关联
    3 ORM优点
        1 封装了数据库中所有的操作,大大提高了开发效率
        2 可以省略庞大的数据访问层,即便不用SQL编码也能完成对数据的CRUD的操作
        3 Flas 中的ORm框架
            1 数据库和框架配置
                在python 和 Flask中,使用的ORM框架是 - SqlAlchemy
                在Flask 中想使用SqlAlchemy的话,需要进行安装
                    pip3 install sqlalchemy
                    pip3 install flask-sqlalchemy
            2 创建数据库
                flask
    from flask import Flask
    from flask_sqlalchemy import SQLAlchemy

    app = Flask(__name__)
    app.config[‘SQLALCHEMY_DATABASE_URI‘] = ‘mysql://用户名:密码@localhost:3306/数据库名‘
    db = SQLAlchemy(app)

app.config[‘SQLALCHEMY_DATABASE_URI‘] = ‘mysql+pymysql://root:[email protected]:3306/flask?charset=utf8‘
app.config[‘SQLALCHEMY_COMMIT_ON_TEARDOWN‘]    = True  #指定执行完操作后自动提交

模型 :
    1 定义模型
        模型:数据库中的表在编程语言中的体现,其本质就是一个python类(模型类 或实体类)
        class MODELMANE(db.Models)
            __tablename__= ‘TABLENAME‘
            COLUMN_NAME = db.Column(db.TYPE,OPTIONS)
        1 MODELMANE : 定义模型类的名称,根据表名设定
        2 TABLENAME : 映射到数据库中表的名称
        3 COLUMN_NAME: 属性名,映射到数据表就是列名
        4 TYPE : 映射到列的数据类型
        5 OPTIONS:列选项
            db.TYPE如下
             类型名            python类型            说明
             Integer        int                    普通整数,32位
             SamllInteger    int                    小范围整数,通常16位
             BigInteger        int或long            不限精度整数
             float            float                浮点数
             Numeric        decimal.Decimal        定点数
             String            str                    变长字符串
             Text            str                    变长字符串,优化
             Unicode            unicode                变长Unicode字符串
             UnicodeText        unicode                优化后的变长Unicode串2
             Date            datetime.date        日期
             Time            datetime.time        时间
             DateTime        datetime.datetime    日期和时间

            OPTIONS 列选项
            选项名                说明
            primary_key            如果设置为True表示该列为主键
            unique                如果设置为True表示该列值唯一
            index                如果设置为True表示该列要创建索引
            mullable            如果设置为True表示该列允许为空
            default                表示该列的默认值

        出错选项【no modul name mysql_db】
            解决1 :
                import pymysql
                pymysql.install_as_MySQLdb()
            解决2:
                在连接路径上
                ‘mysql+pymysql://root:[email protected]:3306/flask?charset=utf8‘  # 在mysql后面 添加【‘+pymysql‘】

        1 数据库操作 - 插入
            1 创建实体对象
            2 完成插入
                db.session.add(实体对象)
                db.session.commit()
        2 数据库操作--查询
            1 基于db.session进行查询
                1 db.session.query()
                    该函数会返回一个query对象,类型为BaseQuery
                    该对象中包含了实体类对应的表中的所有的数据
                    该函数可以接收一个或多个参数,参数们表示的是查询的实体对象是谁
                2 查询执行函数
                    目的:在query()的基础上得到最终想要的结果
                    语法:db.session.query(),查询执行函数()
                    函数            说明
                    all()            以列表的方式返回query()中所有查询的结果
                    first()            返回查询结果中的第一个结果,如果没有结果,则返回None
                    first_or_404()    返回查询结果中的第一个结果,如果没有结果,则终止并返回404

                3 查询过滤器函数
                    作用:在查询的基础上,筛选部分行数据
                    语法:db.session.query().过滤器函数().查询执行函数()
                    过滤器函数            说明
                    filter()            按指定条件进行过滤(多表,单表,定位)
                    filter_by()            按等值条件过滤时使用
                    limit()                按限制行数获取
                    order_by()            根据指定条件进行排序
                    group_by()            根据指定条件进行分组
                    过滤器函数详解
                    1 filter()
                        注意:条件必须由 模型类,属性 构成
                        1 查询年龄大于30的User的信息
                            db.session.query(User).filter(User.age>30)
                        2 查询年龄大于30并且ID大于1的User的信息
                            db.session.query(User).filter(User.age>30,User.id>1)
                        3 查询年龄大于30或者id 大于1的Users的信息
                            注意:查询或的操作,要借助于 or_
                            db.session.query(Users).filter(or_(Users.age>30,Users.id>2))
                        4 查询ID等于2 的信息的必须用 ==
                        5 查询email 中包含‘w’的Users的信息,模糊查询
                            注意:模糊查询like需要使用实体类中属性提供的like()
                            db.session.query(Users).filter(Users.email.like(‘%w‘))
                        6 查询尖id在[32,33]的值
                            需要使用实体类中属性提供的in_([])
                            db.session.query(Users).filter(Users.age.in_([32,33]))
                    2 聚合函数
                        db.session.query(func.聚合函数(‘列名‘).label(‘别名‘))
                        聚合函数:
                            sum()
                            count()
                            max()
                            min()
                            avg()
                    3 filter_by()
                        查询 id =5 的 Users的信息
                        db.session.query(Users).filter_by(id=5).all()
                    4 limit()
                        db.session.query(Users).limit(2)
                        db.session.query(Users).limit(2).offset(1)
                    5 order_by()
                        #按照id 列的值降序排列
                        db.session.query(Users).order_by(‘id desc‘)
                        # 按照age列 的值降序排序,二级排序按照id升序排序
                        db.session.query(Users).order_by(‘id desc,id asc‘).all()

            2 基于Models 类进行查询
                Models.query.查询过滤器函数(条件参数),查询执行函数()
            3 删除
                1 查询出要删除的实体对象
                    db.session.query(Models).filter_by(xxx).first()
                2  根据提供的 删除方法进行删除
                    db.session.delete(u)
                    注意:
                        真正的删除并不是通过删除操作完成,而是通过修改完成的
            4 修改
                1 查
                    将 要修改的信息查询出来
                2 改
                    实体对象。属性 = 值
                3 保存
                    db.session.add(实体对象)
        2 关系映射
            1 一对多
                语法:db
                 1 在:“多”的实体中
                    增加一个列,引用自’一‘表的主键列,外键列名 = db.Column()
                     外键列名 = db.Column(db.Integer,db.ForeignKey(‘主键表.列‘))
                2 在‘一’的实体中
                    增加关联属性以及反向引用关系
                    et:
                        关联属性:
                            在course对象中,通过一个属性能够得到对应的所有的teacher们
                            关联属性,是应该加载Course的实体类中
                        反向引用:
                            在 student对象中,通过一个属性能够得到对应的course
                            反向引用关系属性,是应该加在 Teacher 的实体类中
                    增加关联属性和反向引用关系:
                    属性名= db.relationship(‘多表实体类名‘,关系选项)
                    关系选项
                    选项名                说明
                    backref                在关系的另一个模型中添加的反向引用属性名
                       (准备在“多”的实体中增加对“一”的实体引用的属性名)
                    lazy                指定如何加载当前的相关记录
                        ...                select:首次访问时加载记录
                                        immediate:源对象加载后马上加载相关数据
                                        subquery:效果同上,利用子查询方式加载记录  (数据量大的时候,这个子查询效果更好)
                                        noload: 永不加载记录
                                        dynamic:默认不加载记录,但会提供加载记录的查询
                    uselist                如果设置为 Flase ,表示不使用列表表示关联数据,而使用标量
                    secondary            指定多对多关系映射中的关联表的名字

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
db = SQLAlchemy(app)
app.config[‘SQLALCHEMY_DATABASE_URI‘]= ‘mysql+pymysql://root:[email protected]:3306/flask‘
app.config[‘SQLALCHEMY_COMMIT_ON_TEARDOWN‘] = True

class Course(db.Model):
    __tablename__=‘course‘
    id = db.Column(db.Integer,primary_key=True)
    cname = db.Column(db.String(30),nullable=True)
    #增加关联属性和反向引用关系
    # 关联属性在course对象中通过哪个属性能够得到对应的所有的teacher
    #反向引用关系:在teacher对象中通过哪个属性能找到它对应的course
    teachers = db.relationship(‘Teacher‘,backref =‘course‘,lazy =‘dynamic‘)

    def __init__(self,name):
        self.cname=name

    def __repr__(self):
        return ‘<Coure:%r>‘%self.cname

class Teacher(db.Model):
    __tablename__=‘teacher‘
    id = db.Column(db.Integer,primary_key=True)
    tname = db.Column(db.String(30),nullable=True)
    tage = db.Column(db.Integer)
    course_id = db.Column(db.Integer,db.ForeignKey(‘course.id‘))
    def __repr__(self):
        return ‘<Teacher %r>‘%self.name

db.create_all()

@app.route(‘/‘)
def hello_world():
    return ‘Hello World!‘

@app.route(‘/01-addcourse‘)
def add_course():
    course1 = Course(‘python基础‘)
    course2 = Course(‘python高级‘)
    course3 = Course(‘数据基础‘)
    db.session.add(course1)
    db.session.add(course2)
    db.session.add(course3)
    return ‘1‘

@app.route(‘/02-register‘)
def register_teacher():
    teacher = Teacher()
    teacher.tname=‘吕老师‘
    teacher.tage = 28
    course = Course.query.filter_by(id=3).first()
    # teacher.course = course #通过关联属性course对象赋值
    teacher.course_id = 1
    db.session.add(teacher)
    return ‘1‘

@app.route(‘/03-query-teacher‘)
def query_teacher():
    # 通过 course 查找对应的所有的老师们
    # 查找course_id 为1的course对象
    # course = Course.query.filter_by(id=1).first()
    # print(course.cname)
    # for tea in course.teachers.all():
    #     print(tea.tname)

    #通过teacher 查找对应的course
    teacher = Teacher.query.filter_by(id=1).first()
    print(‘老师姓名‘,teacher.tname)
    course = teacher.course
    print(course.cname)

    pass

if __name__ == ‘__main__‘:
    app.run(debug=True)

--反向映射并查询


        2 一对一          1 什么是一对一            A表中的一条记录只能与B表中的一条记录相关联            B表中的一条记录只能与A表中的一条记录相关联          2 在SQLALchemy 中的体现            1 在任意一个类中增加              外键列名 = db.Column(db.Integer,db.ForeignKey(‘主键表.主键列‘))            2 在另外一个类中增加              关联属性和 反向引用关系属性              属性 = db.relationship(‘关联的实体类‘,backref=‘反向引用属性名‘,uselist=False)

    数据库中的一行:实体
    实体完整性:表中的实体不能完全重复-主键

原文地址:https://www.cnblogs.com/Skyda/p/9898292.html

时间: 2024-10-11 21:00:51

flask 中的ORM的相关文章

flask 中的ORM ( 二 )

1 关系映射 1 多对多 1 什么是多对多 A表中的一条数据可以与B表中任意多条数据相关联 B表中的一条数据可以与A表中任意多条数据相关联 2 实现 在数据库中使用第三张表(关联表) 在编程语言中,可以不编写对应的实体类 1 创建第三张表 student_course = db.Table( 'student_course',# 在数据库中的表名 db.Column('id',db.Integer,primary_key = True), db.Column('student_id',db.In

整合Flask中的目录结构

一.SQLAlchemy-Utils 由于sqlalchemy中没有提供choice方法,所以借助SQLAlchemy-Utils组件提供的choice方法 import datetime from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String, Text, ForeignK

flask框架----整合Flask中的目录结构

一.SQLAlchemy-Utils 由于sqlalchemy中没有提供choice方法,所以借助SQLAlchemy-Utils组件提供的choice方法 import datetime from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String, Text, ForeignK

Flask学习【第11篇】:整合Flask中的目录结构

SQLAlchemy-Utils 由于sqlalchemy中没有提供choice方法,所以借助SQLAlchemy-Utils组件提供的choice方法 import datetime from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String, Text, ForeignKey

Python框架学习之Flask中的数据库操作

数据库操作在web开发中扮演着一个很重要的角色,网站中很多重要的信息都需要保存到数据库中.如用户名.密码等等其他信息.Django框架是一个基于MVT思想的框架,也就是说他本身就已经封装了Model类,可以在文件中直接继承过来.但是在Flask中,并没有把Model类封装好,需要使用一个扩展包,Flask-SQLAlchemy.它是一个对数据库的抽象,让开发者不用这些编写SQL语句,而是使用其提供的接口去操作数据库,这其中涉及到一个非常重要的思想:ORM什么是ORM呢?下面我们就来详细讲解一下.

Flask中使用mysql

Flask中使用mysql 先安装相关模块: pip  install  Flask-MySQL 先准备一下数据库 登录: mysql  -u  root  -p 创建Database和创建Table mysql> CREATE DATABASE EmpData; mysql> use EmpData; mysql> CREATE TABLE User( userId INT NOT NULL AUTO_INCREMENT, userName VARCHAR(100) NOT NULL,

flask中&#39;bool&#39; object has no attribute &#39;__call__&#39;问题

#写flask时报错 <ul class="nav navbar-nav"> <li><a href="/">Home</a></li> </ul> </div> <ul class="nav navbar-nav navbar-right"> {% if current_user.is_authenticated() %} <li><

解决Flask中文件操作出现UnicodeDecodeError UnicodeDecodeError: &#39;ascii&#39; codec can&#39;t decode byte 0xe6 in positio

写一个Flask应用的功能时需要读文件,文件内容含指定字符串的话(即有个if key in filecontent的比较)就把文件内容输出到页面,,结果报错UnicodeDecodeError,查阅Flask的文档却似乎讲Flask默认哪里都是utf8编码,可现在却出了个由于字符是utf8而不是ascii报的错 最后解决了 我灵机一点把filecontent解码一下,写成filecontent.decode('utf8'),就顺利的运行了 版权声明:本文为博主原创文章,未经博主允许不得转载. 解

Flask中处理依赖的技巧

Flask应用中通常会用工厂模式 来创建应用对象,这样方便配置和测试.现在我们就用实例来学习Flask的处理依赖 应用代码 # app/__init__.pyfrom flask import Flaskfrom flask_xxxext import Xxxfrom flask_yyyext import Yyy# ... 一些flask拓展xx = Xxx()yy = Yyy() def create_app(config=None): app = Flask(__name__) xx.in