flask 之Flask-WTF表单、通过flask_SQLAlchemy对数据库的使用

安装

pip install flask-WTF

表单的简单应用

在此之前，先添加app.secret_key = 'arandomstring'。
通常是设置为一个表单类，然后在视图函数初始化为表单对象：

from flask_wtf import FlaskForm
from wtforms import StringField,SubmitField
from wtforms.validators import DataRequired  # 校验的是该字段是否有数据
from wtforms.validators import EqualTo # 判断是否相等
from wtforms.validators import Length

# 设置form表单
class MyForm(FlaskForm):
    name = StringField(label='用户名', validators=[DataRequired()], render_kw={'placeholder': '请输入用户名'})
    pwd = StringField(label='密码', validators=[DataRequired(), Length(6, 12),], render_kw={'type': 'password'})
    pwd_again = StringField(label='确认密码', validators=[DataRequired(), EqualTo('pwd', '俩次密码不一致'),], render_kw={'type': 'password'})
    submit = SubmitField(label='提交')

然后在视图函数初始化并返回:

@app.route('/index', methods=['POST', 'GET'])
def index():
    register_form = MyForm()
    # 进行判断提交的时候是否满足条件
    if register_form.validate_on_submit():
        print('用户名', register_form.name.data)
        print('密码', register_form.pwd.data)

        return '提交成功'
    else:
        if request.method == 'POST':
            return '验证未通过'

    return render_template('FlaskForm.html', form=register_form)

最后在html里面的内容显示：

<form method="post" action="/index">
    {{ form.csrf_token }}

    {{ form.name.label }}{{ form.name(size=20) }}<br>
    {{ form.pwd.label }}{{ form.pwd }}<br>
    {{ form.pwd_again.label }}{{ form.pwd_again }}<br>

    {{ form.submit }}
form>

通过flask_SQLAlchemy对数据库进行连接

pip install flask-sqlalchemy
pip install flask-mysqldb

创建一个连接对象

from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)

DIALCT = "mysql"
DRIVER = "pymysql"
USERNAME = "root"
PASSWORD = "123456"
HOST = "127.0.0.1"
PORT = "3306"
DATABASE = "flasktestdb"

DB_URI = "{}+{}://{}:{}@{}:{}/{}?charset=utf8".format(DIALCT,DRIVER,USERNAME,PASSWORD,HOST,PORT,DATABASE)
app.config["SQLALCHEMY_DATABASE_URI"] = DB_URI
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

# 创建一个管理数据库对象，注意参数需要和app产生联系
db = SQLAlchemy(app)

创建模型：

class Role(db.Model):
    __tablename__ =  'roles'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(20), unique=True)

    # 在主表加关系, 与用户表产生关系，代表的是这个下面的所以用户
    users = db.relationship('User', backref='role', lazy='dynamic') # 用到了才加载
    # users = db.relationship(User', backref='role', lazy='subquery')　＃　全部加载
    def __repr__(self):
        return '' % self.name


class User(db.Model):
    # 定义表名
    __tablename__ = 'newusers'

    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    name = db.Column(db.String(20), nullable=False)
    is_delete = db.Column(db.Boolean, default=False)
    email = db.Column(db.String(30), nullable=True)

    # 外键, 添加外键的时候要指定表名和字段
    role_id = db.Column(db.Integer, db.ForeignKey('roles.id'))

    def __repr__(self):
        return '' % self.name

if __name__ == '__main__':
    # # 删除自己所在表数据
    # db.drop_all()
    # # 数据库迁移
    # db.create_all()
    app.run(debug=True)

数据库表的创建

#删除自己所在表数据
db.drop_all()
#数据库迁移
db.create_all()

插入数据

	obj1 = User(name='马冬梅',email='[email protected]')
    obj2 = User(name='隔壁老王',email='[email protected]')
    obj3 = User(name='老宋',email='[email protected]')
    obj4 = User(name='张三',email='[email protected]')
    #添加到数据库
    # db.session.add(obj1)	#插入一条
 	db.session.add_all([obj1,obj2,obj3,obj4])  #插入多条
    #确认提交数据
    db.session.commit()

查询数据

精准查询 filter_by

User.query.filter_by(name='马冬梅').all() 
User.query.first()

模糊查询 filter

User.query.filter(User.name.startswith('张').all()   #查询姓'张'的用户

查询所有对象

User.query.all()

get 主键查询

User.query.get(1) # 查看id为1 的内容

not_ 取反操作

from sqlalchemy import not_
User.query.filter(not_(User.name=='张三')).all()

and_ 与操作

from sqlalchemy import and_
User.query.filter(and_(User.name.endswith('宋'),User.email=='[email protected]')).all()

or_ 或操作

from sqlalchemy import or_
User.query.filter(or_(User.name.startswith('张'),User.email=='[email protected]')).all()

一对多正向查询

>>> User.query.filter_by(role_id=2).all()
[<User 隔壁老王>]
>>> role = Role.query.get(2)
>>> role
<Role 校霸>

一对多反向引用

Role表：

class Role(db.Model):
    __tablename__ =  'roles'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(20), unique=True)

    # 在主表加关系, 与用户表产生关系，代表的是这个下面的所以用户
    users = db.relationship('User', backref='role', lazy='dynamic') # 用到了才加载
    # users = db.relationship(User', backref='role', lazy='subquery')　＃　全部加载
    def __repr__(self):
        return '' % self.name

user模型添加外键：

role = db.Column(db.Integer, db.ForeignKey('roles.id')) # 外键

Role.users = db.relationship(‘User’, backref=‘role’) : 代表 外键关系的
面向对象视角. 对于一个 Role 类的实例, 其 users 属性将返回与角色相关联的用户组成的列表.

db.relationship() 第一个参数表示这个关系的另一端是哪个模型

backref 参数, 向 User 模型添加了一个 role 数据属性, 从而定义反向关系. 这一属性可替代 role_id 访问

命令行调试例子：

obj = User.query.get(2)
obj.role.name
'校霸'

删除

查询id=2,并且删除

user = User.query.get(2)
db.session.delete(user)
db.session.commit()

更新

查询id=1,并修改email为 [email protected]

user = Users.query.get(1)
user.email = '[email protected]'
db.session.commit()