python(flask-sqlalchemy)

Flask-SQLAlchemy简介

1. 什么是Flask-SQLAlchemy?

优点：

Flask-SQLAlchemy 是一个 Flask 扩展,简化了在 Flask 程序中使用 SQLAlchemy 的操作。
SQLAlchemy 是一个很强大的关系型数据库框架,支持多种数据库后台。
SQLAlchemy 提供了高层 ORM,也提供了使用数据库原生 SQL 的低层功能。

缺点：

由于SQLAlchemy提供了一个支持多种数据库后台的强大数据库框架，导致需要花费时间将简洁的代码转换成相应数据库的代码。所以代码的执行效率不高。

2. 如何安装Flask-SQLAlchemy?

在当前的虚拟环境中安装：

pip install flask-sqlalchemy

3. 如何配置数据库?

可以通过sqlalchemy中文文档查看详细信息

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
# 配置mysql数据库的相关信息
# 在配置之前需要在数据库中创建一个数据库，为了可以接收中文设置编码格式为utf8
# mysql://用户名:密码@主机名/数据库
app.config['SQLALCHEMY_DATABASE_URI']='mysql://root:[email protected]/UserTest'
# sqlchemy将会追踪对象的修改并且发送信号
app.config['SQLALCHEMY_TRACK_MODIFICATION']=True
# 配置完数据库信息，实例化SQLAlchemy对象
db=SQLAlchemy(app)

4. 连接mysql数据库报错解决

问题：sqlalchemy需要通过MySQLdb连接数据库

解决：

import pymysql
# 将pymysql安装成MySQLdb
pymysql.install_as_MySQLdb()

5. 如何定义表模型?

模型这个术语表示程序使用的持久化实体。
模型列类型:
模型列属性


class User(db.Model):
    # 默认情况下表名为类的名称， 如果想要重新设置表名， __tablename__
    # 类变量 __tablename__ 定义在数据库中使用的表名.
    __tablename__ = "用户信息"
    # db.Column 类构造函数的第一个参数是数据库列和模型属性的类型。
    # db.Column 中其余的参数指定属性的配置选项。
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(30), unique=True, nullable=Flase)  
    password = db.Column(db.String(20), nullable=Flase)
    email = db.Column(db.String(20), unique=True)

6.对数据库的操作

在数据库中创建表
在表中对数据进行操作（增删改查）
- sqlalchemy查询过滤器
- sqlalchemy执行函数
- 分页对象paginate拥有的属性
- 分页对象paginate拥有的方法

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from datetime import  datetime
# **************************1. python3中MySQLdb报错解决方法*************************
import pymysql


pymysql.install_as_MySQLdb()

app = Flask(__name__)

# *************************2. 数据库的配置与实例化**********************************
# 对数据库操作(mysql, redis)
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:[email protected]/UserTest'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# 实例化对象
db = SQLAlchemy(app)
# ***********************3. 定义数据库模型************************************
# user ==== (id, username, password, email)
class User(db.Model):
    # 默认情况下表名为类的名称， 如果想要重新设置表名， __tablename__
    __tablename__ = "用户信息"
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(30), unique=True, index=True, nullable=False)  
    password = db.Column(db.String(20), nullable=False)
    email = db.Column(db.String(20), unique=True, index=True)
    # 设置默认值， 位当前用户的创建时间;
    add_time = db.Column(db.DateTime, default=datetime.now() )


if __name__ == '__main__':
    # 删除所有的表
    db.drop_all()
    # 创建所有的表
    db.create_all()

    # 插入数据(insert)
    # 实例化User对象，创建用户数据
    u1 = User(username="粉条", password="westos", email="[email protected]")
    u2 = User(username="粉丝", password="westos", email="[email protected]")
    # 将创建好的用户对象信息添加到表中，并将表数据保存在缓存中
    db.session.add(u1)
    db.session.add(u2)
    # 将缓存中的表数据发送给数据库
    db.session.commit()

    # 删除数据(delete)
    delete_user = User.query.filter_by(username="粉条").first()
    # 将要删除的用户对象从表中删除，并将表数据保存在缓存中
    db.session.delete(delete_user)
    # 将缓存中的表数据发送给数据库
    db.session.commit()

    # 更新数据(update)

    update_user = User.query.filter_by(username="粉丝").first()
    print(update_user.username)
    print(update_user.password)
    print(update_user.email)
    print(update_user.id)
    print("正在更新邮箱地址.......")
    update_user.email = '[email protected]'
    # 将更改好的用户对象信息添加到表数据中，并将表数据保存在缓存中
    db.session.add(update_user)
    db.session.commit()
    print(update_user.email)

    # 查看数据(select)
    users = User.query.all()
    print(users)

6.关联表模型的操作

在关系型数据库中，最主要的特点就是表与表之间相关联。其中关联的方式分为三种：

一对一
一对多（多对一）
多对多

在sqlalchemy的如何关联表模型？

根据表之间的关联方式设置外键，外键设置在多的一方。

from datetime import datetime

from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemy, Pagination
from flask_bootstrap import Bootstrap
import pymysql
from sqlalchemy import desc, func

pymysql.install_as_MySQLdb()
app = Flask(__name__)

app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:[email protected]/UserTest'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)



### 用户和角色是什么关系?
#    - 一对一
#    - 一对多: 角色是一， 用户是多， 外键写在多的一端
#   - 多对多
class Role(db.Model):
    __tablename__ = "用户角色"
    # id号递增autoincrement=True
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(20))
    # 反向引用, 
    # Role表中有属性users(users实际上是User对象，包含User中的所有属性)，
    # User类中有role这个属性（role实际上是Role对象，包含Role中的所有属性）;
    users = db.relationship('User', backref='role')

    def __repr__(self):
        return "<Role %s>" % (self.name)


class User(db.Model):
    __tablename__ = "网站用户"
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(30), unique=True, index=True, nullable=False)  
    password = db.Column(db.String(20), nullable=False)
    email = db.Column(db.String(20), unique=True, index=True)
    # 设置默认值， 位当前用户的创建时间;
    add_time = db.Column(db.DateTime, default=datetime.now())

    #### 重要的： 用户角色.id不能随便设置，用户角色是数据库中表的实际名称， 需要从Role中查询, （外键关联）
   
    role_id = db.Column(db.Integer, db.ForeignKey('用户角色.id'))

    # 定义了 __repr()__ 方法,返回一个具有可读性的字符串表示模型,可在调试和测试时使用。
    def __repr__(self):
        return "<User %s>" % (self.username)


if __name__ == '__main__':
    db.drop_all()
    db.create_all()

    # ***********************1. 添加数据
    # 1). 添加角色
    role1 = Role(name="普通用户")
    role2 = Role(name="会员")
    role3 = Role(name="管理员")
	# 一次添加多个角色对象到表数据中
    db.session.add_all([role1, role2, role3])
    db.session.commit()
    # 2). 添加用户
    # 设置role_id=1与角色表中的"普通用户"相关联
    user1 = User(username="westos1", password="westos1",
                 email="[email protected]", role_id=1)
    db.session.add(user1)
    db.session.commit()

    # **********************2. 查看数据信息
    print(User.query.all())
    print(Role.query.all())

    # 批量添加用户100个是普通用户， 50个是VIP用户， 10个管理员
    for item in range(100):
        user = User(
            username="fentiao%s" % (item),
            password="fentiao",
            email="fentiao%s" % (item),
            role_id=1
        )
        db.session.add(user)

    for item in range(50):
        user = User(
            username="vip%s" % (item),
            password="vip",
            email="vip%s" % (item),
            role_id=2
        )
        db.session.add(user)

    for item in range(10):
        user = User(
            username="admin%s" % (item),
            password="admin",
            email="admin%s" % (item),
            role_id=3
        )
        db.session.add(user)

    # 将批量添加的用户提交到数据库中.
    db.session.commit()

    # 获取所有的普通用户
    common_users = User.query.filter_by(role_id='1').all()
    print(common_users)
    vip_users = User.query.filter_by(role_id='2').all()
    print(vip_users)

    # 获取所有的普通用户转化成的sql语句查看;
    print(User.query.filter_by(role_id='1'))
    print(User.query)

    # filter过滤器的使用（更偏向于SQL语句）
    common_users = User.query.filter(User.role_id == 1).all()
    print(common_users)

    # limit过滤器, 只显示返回结果的前几条数据;
    common_users_limit = User.query.filter(User.role_id == 1).limit(5).all()
    print(common_users_limit)

    # offset过滤器: 偏移显示
    common_users_offset = User.query.filter(User.role_id == 1).offset(2).limit(3).all()
    print(common_users_offset)

    # order_by排序过滤器, 默认是升序的， 如果要降序desc(属性名)
    common_users_order = User.query.order_by(User.role_id).all()
    print(common_users_order)
    # 降序
    common_users_desc_order = User.query.order_by(desc(User.role_id)).all()
    print(common_users_desc_order)

    # group_by, 分组统计
    # 分组后不能直接通过.count获取每个分组的个数
    # 需要.add_columns(func.count(User.role_id))添加一列数据专门用来统计每个分组的个数
    # func需要从sqlalchemy中导入：from sqlalchemy import func
    users_analysis = User.query.add_columns(func.count(User.role_id)).group_by(User.role_id).all()
    print(users_analysis)

    # get方法
    print(User.query.get(1))
    # print(User.query.get_or_404(1000))

    # count
    print(User.query.filter_by(role_id=1).count())
    print(User.query.filter_by(role_id=2).count())
    print(User.query.filter_by(role_id=3).count())

    # paginate分页的对象
    # page=2： 要显示第2页的数据， per_page=5： 每页显示数据的条数
    # 101+50+10
    usersPageObj = User.query.paginate(page=2, per_page=5)

    print("当前页面的记录数:", usersPageObj.items)
    print("分页查询的源sql语句:", usersPageObj.query)
    print("当前显示的页数:", usersPageObj.page)
    print("上一页的页数:", usersPageObj.prev_num)
    print("下一页的页数:", usersPageObj.next_num)
    print("是否包含上一页:", usersPageObj.has_prev)
    print("是否包含下一页:", usersPageObj.has_next)
    print("总页数:", usersPageObj.pages)
    print("每页记录的数量:", usersPageObj.per_page)
    print("记录总数:", usersPageObj.total)

    # *********************
    print("页码显示:", list(usersPageObj.iter_pages()))
    print("上一页的数据:", usersPageObj.prev().items)
    print("下一页的数据:", usersPageObj.next().items)



    # Role表反向引用
    print("反向引用".center(100, '*'))
    admin_role = Role.query.filter_by(name="管理员").first()
    print(admin_role.id)
    print(admin_role.name)
    print(admin_role.users)


    # User表中
    admin_user = User.query.filter_by(username='admin1').first()
    admin_user_id = admin_user.role_id
    print(Role.query.filter_by(id=admin_user_id).first().name)

    #
    admin_user = User.query.filter_by(username='admin1').first()
    print(admin_user.role.name)

案例：将数据库中的数据显示在前端

业务逻辑：

# app.py文件中;

from datetime import datetime

from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemy, Pagination
from flask_bootstrap import Bootstrap
import pymysql
from sqlalchemy import desc, func

pymysql.install_as_MySQLdb()
app = Flask(__name__)



app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql://root:[email protected]/UserTest'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
bt = Bootstrap(app)

### 用户和角色是什么关系?
#    - 一对一
#    - 一对多: 角色是一， 用户是多， 外键写在多的一端
#   - 多对多
class Role(db.Model):
    __tablename__ = "用户角色"
    # id号递增autoincrement=True
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(20))
    # 反向引用, Role表中有属性users， User类中有role这个属性;
    users = db.relationship('User', backref='role')

    def __repr__(self):
        return "<Role %s>" % (self.name)


class User(db.Model):
    __tablename__ = "网站用户"
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(30), unique=True, index=True, nullable=False)  # unique=True用户名不能重复
    password = db.Column(db.String(20), nullable=False)
    email = db.Column(db.String(20), unique=True, index=True)
    # 设置默认值， 位当前用户的创建时间;
    add_time = db.Column(db.DateTime, default=datetime.now())
    #### 重要的： 用户角色id不能随便设置， 需要从Role中查询, （外键关联）
    role_id = db.Column(db.Integer, db.ForeignKey('用户角色.id'))

    # 定义了 __repr()__ 方法,返回一个具有可读性的字符串表示模型,可在调试和测试时使用。
    def __repr__(self):
        return "<User %s>" % (self.username)


# http://www.csdn.net/list/
# http://www.csdn.net/list/1/
# http://www.csdn.net/list/2/
@app.route('/list/')
@app.route('/list/<int:page>/')
# 当路由为/list/时，page默认为第一页
def list(page=1):
    # 每页显示的数据
    per_page = 10
    # 返回的是 Pagination对象
    userPageObj = User.query.paginate(page=page, per_page=per_page)
    return render_template('list.html',
                           userPageObj=userPageObj
                           )

if __name__ == '__main__':
    app.run()

页面逻辑：

{% extends 'bootstrap/base.html' %}


{% block title %}

    用户显示
{% endblock %}


{% block content %}
    <div class="container">
        <div class="col-lg-8 col-lg-offset-2">
            <div class="page-header">
                <h1>用户信息</h1>
            </div>


            <table class="table table-hover">
                <tr>
                    <th>编号</th>
                    <th>姓名</th>
                    <th>邮箱</th>
                    <th>创建时间</th>
                    <th>用户角色</th>
                </tr>

                {% for user in userPageObj.items %}
                    <tr>
                        <th>{{ user.id }}</th>
                        <th>{{ user.username }}</th>
                        <th>{{ user.email }}</th>
                        <th>{{ user.add_time }}</th>
                        <th>{{ user.role.name }}</th>

                    </tr>
                {% endfor %}
            </table>


            <nav aria-label="Page navigation">
                <ul class="pagination">
                    {#
1. 上一页的显示url获取
    /list/2/ ===== url_for('list', userPageObj.prev_num)

2. 上一页信息逻辑判断
    1). 判断是否有上一页信息；
    2). 如果有， 创建链接;
    3). 如果没有， 该链接设为不可点击的链接

3. 上一页显示使用的类属性和方法:
    1). dataObj.has_prev:
        判断用户是否有上一页？
        如果有，返回True； 如果没有，返回False;

    2).dataObj.prev_num:
        获取上一页的页数编号;
#}
                    {% if userPageObj.has_prev %}
                        <li>

                            <a href="{{ url_for('list', page=userPageObj.prev_num) }}" aria-label="Previous">
                                <span aria-hidden="true">&laquo;</span>
                            </a>
                        </li>
                    {% else %}
                        <li class="disabled">
                            <a href="#" aria-label="Previous">
                                <span aria-hidden="true">&laquo;</span>
                            </a>
                        </li>

                    {% endif %}


                    {#

详细页的显示
依次创建每个分页表框:
    1). 是否为none, 设置类名为diabled；
    2). 是否为当前页， 设置类名为active；
    3）.其他，正常设置;
#}

                    {% for page in userPageObj.iter_pages() %}
                        {% if page is none %}
                            <li class="disabled"><a href="#">......</a></li>
                        {% elif page == userPageObj.page %}

                            <li class="active"><a href="{{ url_for('list', page=page) }}">{{ page }}</a></li>
                        {% else %}
                            <li><a href="{{ url_for('list', page=page) }}">{{ page }}</a></li>
                        {% endif %}
                    {% endfor %}


                    {#
1.下一页信息判断逻辑
    1). 判断是否有下一页信息；
    2). 如果有， 创建链接;
    3). 如果没有， 该链接设为不可点击的链接

2. 使用的方法:
    1). dataObj.has_next:
        判断用户是否有下一页？
        如果有，返回True； 如果没有，返回False;
    2).dataObj.next_num: 获取下一页的页数编号;
#}
                    {% if userPageObj.has_next %}
                        <li>
                            <a href="{{ url_for('list', page=userPageObj.next_num) }}" aria-label="Next">
                                <span aria-hidden="true">&raquo;</span>
                            </a>
                        </li>
                    {% else %}
                        <li class="disabled">
                            <a href="#" aria-label="Next">
                                <span aria-hidden="true">&raquo;</span>
                            </a>
                        </li>
                    {% endif %}

                </ul>
            </nav>
        </div>

    </div>
{% endblock %}

案例效果：

python(flask-sqlalchemy)

代码结构化设计：

通常写代码时，所有的模块都是写在一个脚本中，这使得代码的可读性很差。所以为了使代码显得更加规范，方便阅读，我们可以设计代码的结构

.
├── app（包）
│   ├── forms.py（用来生成表单）
│   ├── __init__.py（实例化app及其他对象。导包时，默认从该文件导模块，可以解决包中模块之间的依赖性）
│   ├── models.py（用来创建数据库表）
│   ├── __pycache__
│   │   ├── __init__.cpython-36.pyc
│   │   ├── models.cpython-36.pyc
│   │   └── views.cpython-36.pyc
│   ├── static（静态文件存储目录）
│   ├── templates（页面逻辑存放目录）
│   │   └── list.html
│   └── views.py（视图函数）
├── app.py（主程序）
├── config.py(用于存放app的相关配置信息)