Flask（三）

flag：卷王！

于 2022-09-11 14:17:25 发布

阅读量373

点赞数

文章标签：前端 flask

本文链接：https://blog.csdn.net/qq_60381063/article/details/126798760

版权

本文介绍了Flask框架中如何处理静态文件，使用蓝图进行模块化开发，以及集成SQLAlchemy进行数据库操作。通过url_for加载静态资源，使用蓝图注册不同功能模块，展示了ORM映射、数据的增删改查操作，以及外键和一对多、一对一关系的实现。同时，提供了数据库连接与测试的示例代码。

摘要由CSDN通过智能技术生成

一、静态文件的配置

Web应用中会出现大量的静态文件来使得网页更加生动美观，类似于css样式文本、Javascript脚本文件、图片文件、字体文件等静态资源，在Jinja中加载静态文件非常简单，只需要通过url_for全局函数就可以实现

url_for函数默认会在项目根目录下的static文件夹中寻找about.css文件，如果找到了，会生成一个相对于项目根目录下的/static/about.css路径，当然我们也可以把静态文件不放在static文件夹中。

二、蓝图

之前我们写url和视图函数都是在同一个文件，如果项目比较大，显然不是一个合理的结构，而蓝图可以优雅的帮助我们实现这种需求

from flask import Flask
from apps.book import bp as book_bp
from apps.course import bp as course_bp
from apps.user import bp as user_bp

app=Flask(__name__)
app.register_blueprint(book_bp)
app.register_blueprint(course_bp)
app.register_blueprint(user_bp)

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

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


book:
from flask import Blueprint,render_template

#url_prefix:127.0.0.1:5000/book
bp=Blueprint("book",__name__,url_prefix="/book")

@bp.route('/list1')
def book_list():
    return render_template("book_list.html")



course:
from flask import Blueprint

bp=Blueprint("course",__name__,url_prefix="/course")

@bp.route("/list")
def course_list():
    return "课程列表"


user:
from flask import Blueprint

bp=Blueprint("user",__name__,url_prefix="/user")

@bp.route("/list")
def user_list():
    return "用户列表"

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>图书列表</title>
</head>
<body>
    <h1>图书列表</h1>
</body>
</html>

结果：

三、SQLAlchemy

SQLAlchemy ：是一个独立的ORM框架，可以独立于Flask存在，也可以在其他项目中使用，比如Django中

Flask-SQLAlchemy：对SQLAlchemy的一个封装，能够更适合在Flask中使用

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app=Flask(__name__)
db=SQLAlchemy(app)

#数据库的配置变量
HOSTNAME ='127.0.0.1'
PORT ='3306'
DATABASE = 'zl_flask'
USERNAME='root'
PASSWORD='root'
DB_URI='mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)
app.config['SQLALCHEMY_DATABASE_URI']=DB_URI
app.config['SQLALCHEMY_TRACK_MODIFICATIONS']=True

@app.route('/')
def hello_world():
    #写一个测试代码来验证是否连接成功
    engine=db.get_engine()
    with engine.connect() as conn:
        result =conn.execute("select 1")
        print(result.fetchone())
    return 'Hello World!'

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

结果：

1，ORM映射与增删改查操作

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app=Flask(__name__)
db=SQLAlchemy(app)

#数据库的配置变量
HOSTNAME ='127.0.0.1'
PORT ='3306'
DATABASE = 'zl_flask'
USERNAME='root'
PASSWORD='root'
DB_URI='mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)
app.config['SQLALCHEMY_DATABASE_URI']=DB_URI
app.config['SQLALCHEMY_TRACK_MODIFICATIONS']=True


#定义ORM模型
class Article(db.Model):
    __tablename__="article"
    id =db.Column(db.Integer,primary_key=True,autoincrement=True)
    title=db.Column(db.String(200),nullable=False)
    content=db.Column(db.Text,nullable=False)

db.create_all()

@app.route("/article")
def article_view():
    #添加数据
    article=Article(title="钢铁是怎样炼成的",content="xxx")
    db.session.add(article)
    #做一个提交操作
    db.session.commit()
    return "数据操作成功"

    #查询数据
    #filter_by:返回一个类列表的对象
    article1=Article.query.filter_by(id=1)[0]
    print(article1.title)
    return "数据操作成功"

    #修改数据
    article1 = Article.query.filter_by(id=1)[0]
    article1.content="yyy"
    db.session.commit()
    return "数据操作成功"

    #删除数据
    Article.query.filter_by(id=1)[0].delete()
    db.session.commit()
    return "数据操作成功"

@app.route('/')
def hello_world():
    #写一个测试代码来验证是否连接成功
    engine=db.get_engine()
    with engine.connect() as conn:
        result =conn.execute("select 1")
        print(result.fetchone())
    return 'Hello World!'

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

2，外键

在MySQL中，外键可以让表之间的关系更加紧密，而SQLAlchemy同样也支持外键，通过ForeignKey类来实现，并且可以指定表的外键约束。

外键约束有以下几项：

RESTRICT：父表数据被删除，会阻止删除，默认就是这一项
NO ACTION：在MySQL中，同RESTRICT。
CASCADE：级联删除
SET NULL：父表数据被删除，子表数据会设置为NULL。

3，一对多

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app=Flask(__name__)
db=SQLAlchemy(app)

#数据库的配置变量
HOSTNAME ='127.0.0.1'
PORT ='3306'
DATABASE = 'zl_flask'
USERNAME='root'
PASSWORD='root'
DB_URI='mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)
app.config['SQLALCHEMY_DATABASE_URI']=DB_URI
app.config['SQLALCHEMY_TRACK_MODIFICATIONS']=True

class User(db.Model):
    __tablename__="user"
    id=db.Column(db.Integer,primary_key=True,autoincrement=True)
    username=db.Column(db.String(200),nullable=False)

#定义ORM模型
class Article(db.Model):
    __tablename__="article"
    id =db.Column(db.Integer,primary_key=True,autoincrement=True)
    title=db.Column(db.String(200),nullable=False)
    content=db.Column(db.Text,nullable=False)

    #外键：
    #1,外键的数据类型一定要看所引用的字段的类型
    #2，db.ForeignKey("表名.字段名")
    #3，外键是属于数据库层面的，不推荐直接在ORM中使用
    author_id=db.Column(db.Integer,db.ForeignKey("user.id"))

    #relationship:
    #1,第一个参数是模型的名字，必须要和模型的名字保持一致
    #2，backref(back reference):代表反向引用，代表对方访问我的时候的字段的名字
    author=db.relationship("User",backref="articles")

#暂时还没有学到ORM迁移数据库的版本管理，所以现在只能先删除所有表，在创建
db.drop_all()
db.create_all()


@app.route("/otm")
def one_to_many():
    article=Article(title="111",content="xxx")
    user=User(username="drx")
    article.author=user
    db.session.add(article)
    db.session.commit()
    return "one to many数据操作成功"

@app.route("/article")
def article_view():
    #添加数据
    article=Article(title="钢铁是怎样炼成的",content="xxx")
    db.session.add(article)
    #做一个提交操作
    db.session.commit()
    return "数据操作成功"

    #查询数据
    #filter_by:返回一个类列表的对象
    article1=Article.query.filter_by(id=1)[0]
    print(article1.title)
    return "数据操作成功"

    #修改数据
    article1 = Article.query.filter_by(id=1)[0]
    article1.content="yyy"
    db.session.commit()
    return "数据操作成功"

    #删除数据
    Article.query.filter_by(id=1)[0].delete()
    db.session.commit()
    return "数据操作成功"

@app.route('/')
def hello_world():
    #写一个测试代码来验证是否连接成功
    engine=db.get_engine()
    with engine.connect() as conn:
        result =conn.execute("select 1")
        print(result.fetchone())
    return 'Hello World!'

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

4，一对一

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app=Flask(__name__)
db=SQLAlchemy(app)

#数据库的配置变量
HOSTNAME ='127.0.0.1'
PORT ='3306'
DATABASE = 'zl_flask'
USERNAME='root'
PASSWORD='root'
DB_URI='mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(USERNAME,PASSWORD,HOSTNAME,PORT,DATABASE)
app.config['SQLALCHEMY_DATABASE_URI']=DB_URI
app.config['SQLALCHEMY_TRACK_MODIFICATIONS']=True

#一对多
class User(db.Model):
    __tablename__="user"
    id=db.Column(db.Integer,primary_key=True,autoincrement=True)
    username=db.Column(db.String(200),nullable=False)

#一对一
class UserExtension(db.Model):
    __tablename__ = "user_extension"
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    school=db.Column(db.String(100))
    user_id=db.Column(db.Integer,db.ForeignKey("user.id"))

    #db.backref
    #1,在反向引用的时候，如果需要传递一些其他的参数那么就需要用到这个函数，否则不需要使用，只要在relationship的backref参数上，设置反向引用的名称就可以了
    #2，uselist=false:代表反向引用的时候，不是一个列表，而是一个对象
    user =db.relationship("User",backref=db.backref("extension",uselist=False))
#定义ORM模型
class Article(db.Model):
    __tablename__="article"
    id =db.Column(db.Integer,primary_key=True,autoincrement=True)
    title=db.Column(db.String(200),nullable=False)
    content=db.Column(db.Text,nullable=False)

    #外键：
    #1,外键的数据类型一定要看所引用的字段的类型
    #2，db.ForeignKey("表名.字段名")
    #3，外键是属于数据库层面的，不推荐直接在ORM中使用
    author_id=db.Column(db.Integer,db.ForeignKey("user.id"))

    #relationship:
    #1,第一个参数是模型的名字，必须要和模型的名字保持一致
    #2，backref(back reference):代表反向引用，代表对方访问我的时候的字段的名字
    author=db.relationship("User",backref="articles")

#暂时还没有学到ORM迁移数据库的版本管理，所以现在只能先删除所有表，在创建
db.drop_all()
db.create_all()

#一对多
@app.route("/otm")
def one_to_many():
    article=Article(title="111",content="xxx")
    user=User(username="drx")
    article.author=user
    db.session.add(article)
    db.session.commit()
    return "one to many数据操作成功"

#一对一
@app.route("/oto")
def one_to_one:
    user=User(username="drx")
    extension=UserExtension(school="清华大学")
    user.extension=extension
    db.session.commit()
    return "oen to one"

@app.route("/article")
def article_view():
    #添加数据
    article=Article(title="钢铁是怎样炼成的",content="xxx")
    db.session.add(article)
    #做一个提交操作
    db.session.commit()
    return "数据操作成功"

    #查询数据
    #filter_by:返回一个类列表的对象
    article1=Article.query.filter_by(id=1)[0]
    print(article1.title)
    return "数据操作成功"

    #修改数据
    article1 = Article.query.filter_by(id=1)[0]
    article1.content="yyy"
    db.session.commit()
    return "数据操作成功"

    #删除数据
    Article.query.filter_by(id=1)[0].delete()
    db.session.commit()
    return "数据操作成功"

@app.route('/')
def hello_world():
    #写一个测试代码来验证是否连接成功
    engine=db.get_engine()
    with engine.connect() as conn:
        result =conn.execute("select 1")
        print(result.fetchone())
    return 'Hello World!'

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