flask学习03

flask03

一、模板

1.变量的基本使用

• 它支持点语法
• 也支持自定义类型
• 支持方法和函数的调用
  代码如下：
  

2.过滤器

• 普通过滤器

  • 定义：过滤器本身就是函数，在模块里我们要进行对需要输出的变量值进行特殊显示如格式化、运算等等，在模块中不能直接使用python中的方法，所以过滤器就诞生了
  • 命名格式：do_功能（iterable, attribute=None）
  • 使用方式：变量名|过滤器

  {{variable | filter_name(*args)}}

  • 如果没有任何参数传给过滤器,则可以把括号省略掉：

  {{variable | filter_name}}

  • 支持链式调用：

  {{ “hello world” | reverse | upper }}

  • 内建过滤器

    • safe：禁用转义

    {{ 'hello' | safe }}

    • capitalize：把变量值的首字母转成大写，其余字母转小写

    {{ 'hello' | capitalize }}

    • lower：把值转成小写

    {{ 'HELLO' | lower }}

    • upper：把值转成大写

    {{ 'hello' | upper }}

    • title：把值中的每个单词的首字母都转成大写

    {{ 'hello' | title }}

    • reverse：字符串反转

    {{ 'olleh' | reverse }}

    • format：格式化输出

    {{ '%s is %d' | format('name',17) }}

    • striptags：渲染之前把值中所有的HTML标签都删掉

    {{ 'hello' | striptags }}

    • truncate: 字符串截断

    {{ 'hello every one' | truncate(9)}}

  • 列表操作

    • first：取第一个元素

    {{ [1,2,3,4,5,6] | first }}

    • last：取最后一个元素

    {{ [1,2,3,4,5,6] | last }}

    • length：获取列表长度

    {{ [1,2,3,4,5,6] | length }}

    • sum：列表求和

    {{ [1,2,3,4,5,6] | sum }}

    • sort：列表排序

    {{ [6,2,3,1,5,4] | sort }}

  • 语句块过滤

{% filter upper %}
    #一大堆文字#
{% endfilter %}

普通过滤器截图

• 自定义过滤器
  • 定义：当内置过滤器不能满足需求的之后，需要自己来定义
  • 实现方式：
    • 第一种是通过Flask应用对象的 add_template_filter 方法
    • 第二种通过装饰器来实现自定义过滤器
  • 注意：自定义的过滤器名字不能和内置的过滤器一样，会覆盖内置过滤器
  • 在这里只介绍第一种实现方式

# 1.定义过滤器 过滤器函数可以添加自定义的参数
def do_list(s, is_copy=False):  # s = height_list
    if is_copy:  # 生成新列表,新列表翻转
        news_ = s[::-1]
        print(s)
        return news_
    else:  # 元列表翻转
        s.reverse()
        return s


# 2.应用添加过滤器
app.add_template_filter(do_list, 'li_reverse')

过滤器参数版截图

3.控制代码块（重点）

控制语句包含两个：

• if语句

{# Jinja2 语法中的if语句跟 Python 中的 if 语句相似,后面的布尔值或返回布尔值的表达式将决定代码中的哪个流程会被执行: #}
{%if user.is_logged_in() %}
    <a href='/logout'>Logout</a>
{% else %}
    <a href='/login'>Login</a>
{% endif %}

过滤器也可被用在循环中如：

{% if comments | length > 0 %}
    There are {{ comments | length }} comments
{% else %}
    There are no comments
{% endif %}

for循环语句

• 使用for循环来迭代任何列表或者生成器函数

{% for post in posts %}
    <div>
        <h1>{{ post.title }}</h1>
        <p>{{ post.text | safe }}</p>
    </div>
{% endfor %}

• 循环和if语句可以组合使用

{% for post in posts if post.text %}
    <div>
        <h1>{{ post.title }}</h1>
        <p>{{ post.text | safe }}</p>
    </div>
{% endfor %}

• 在一个 for 循环块中你可以访问这些特殊的变量:

变量	描述
loop.index	当前循环的次数（从 1 开始）
loop.index0	当前循环的次数（从 0 开始）
loop.revindex	当前循环倒数的次数（从 1 开始）
loop.revindex0	当前循环倒数的次数（从 0 开始）
loop.first	如果是第一次迭代，为 True 。
loop.last	如果是最后一次迭代，为 True 。
loop.length	循环的总次数
loop.cycle	在一串序列间期取值的辅助函数。

示例程序：

• 准备数据
  
• 示例效果
  

4.前端渲染vs后端渲染（了解）

• 后端渲染：在服务端使用正则表达式负html直接进行内容替换
  • 优点：有利于SEO（搜索引擎优化）
  • 缺点：开发是前后端不分离，开发效率低
• 前端渲染：在前端使用js动态的修改html内容
  • 一般前端发起ajax请求，后端返回json数据，js动态修改标签
  • 优点：
    • 开发时前后端分离，开发效率高
    • 可以实现动态加载，完成局部刷新

5.模板继承（重点）

• 作用：对html中重复的内容进行抽取，减少代码的冗余
• 父类模板
  • 将共同的内容到父类文件中
  • 在出现差异的地方,定义代码块
• 子类模板
  • 继承父类文件中的内容
  • 重写代码块,实现自定义的效果
  • 重用父类的内容
    

6.可以直接在模块使用的变量和函数

• 作用：不用再设置关键字传入模块
• 变量：request session g
• 函数: url_for get_flashed_messages
  

二.CSRF

1.CSRF攻击过程

• CSRF：跨站请求伪造
• 攻击方式：利用状态保存机制，盗用用户身份，发起非法请求

2.CSRF保护（理解）

• 访问转账页面时，生成随机令牌，并保存到表单和cookie中
• 提交转账请求时，校验表单和cookie中令牌是否一致
  

3.Flask中的CSRF保护（重点）

• flask组件flask-wtf封装了CSRF保护机制
  

三.数据库基础准备知识

1.ORM

• flask-sqlalchemy：让flask框架可以集成sqlalchemy框架
• sqlalchemy：python中最著名的ORM框架
• ORM：对象关系映射，可以允许开发者使用原生代码的方式来操作数据库
• 优点：开发者不用写SQL语句，而且也不需要学习其他数据库的sql语法
• 缺点：存在一定的性能缺失

2.Flask-SQLAlchemy

• 简介：

  • SQLALchemy 实际上是对数据库的抽象，让开发者不用直接和 SQL 语句打交道，而是通过 Python 对象来操作数据库，在舍弃一些性能开销的同时，换来的是开发效率的较大提升
  • SQLAlchemy是一个关系型数据库框架，它提供了高层的 ORM 和底层的原生数据库的操作。flask-sqlalchemy 是一个简化了 SQLAlchemy 操作的flask扩展。

• 安装：

  • 安装 flask-sqlalchemy

  pip install flask-sqlalchemy

  • 如果连接的是 mysql 数据库，需要安装 mysqldb

  pip install flask-mysqldb

• 数据库连接设置:

  • 在 Flask-SQLAlchemy 中，数据库使用URL指定，而且程序使用的数据库必须保存到Flask配置对象的 SQLALCHEMY_DATABASE_URI 键中

  app.config[‘SQLALCHEMY_DATABASE_URI’] = ‘mysql://root:mysql@127.0.0.1:3306/test’

  • 其他设置：

    • 动态追踪修改设置，如未设置只会提示警告

      app.config[‘SQLALCHEMY_TRACK_MODIFICATIONS’] = False

    • 查询时会显示原始SQL语句

    app.config[‘SQLALCHEMY_ECHO’] = True

  • 配置完成需要去 MySQL 中创建项目所使用的数据库

$ mysql -uroot -pmysql
$ create database test charset utf8;

• 其他配置

名字	备注
SQLALCHEMY_DATABASE_URI	用于连接的数据库 URI 。例如:sqlite:tmp/test.dbmysql://username:password@server/db
SQLALCHEMY_BINDS	一个映射 binds 到连接 URI 的字典。更多 binds 的信息见用 Binds 操作多个数据库。
SQLALCHEMY_ECHO	如果设置为Ture， SQLAlchemy 会记录所有 发给 stderr 的语句，这对调试有用。(打印sql语句)
SQLALCHEMY_RECORD_QUERIES	可以用于显式地禁用或启用查询记录。查询记录 在调试或测试模式自动启用。更多信息见get_debug_queries()。
SQLALCHEMY_NATIVE_UNICODE	可以用于显式禁用原生 unicode 支持。当使用 不合适的指定无编码的数据库默认值时，这对于 一些数据库适配器是必须的（比如 Ubuntu 上 某些版本的 PostgreSQL ）。
SQLALCHEMY_POOL_SIZE	数据库连接池的大小。默认是引擎默认值（通常 是 5 ）
SQLALCHEMY_POOL_TIMEOUT	设定连接池的连接超时时间。默认是 10 。
SQLALCHEMY_POOL_RECYCLE	多少秒后自动回收连接。这对 MySQL 是必要的， 它默认移除闲置多于 8 小时的连接。注意如果 使用了 MySQL ， Flask-SQLALchemy 自动设定 这个值为 2 小时。

• 常用的SQLAlchemy字段类型

类型名	python中类型	说明
Integer	int	普通整数，一般是32位
SmallInteger	int	取值范围小的整数，一般是16位
BigInteger	int或long	不限制精度的整数
Float	float	浮点数
Numeric	decimal.Decimal	普通整数，一般是32位
String	str	变长字符串
Text	str	变长字符串，对较长或不限长度的字符串做了优化
Unicode	unicode	变长Unicode字符串
UnicodeText	unicode	变长Unicode字符串，对较长或不限长度的字符串做了优化
Boolean	bool	布尔值
Date	datetime.date	时间
Time	datetime.datetime	日期和时间
LargeBinary	str	二进制文件

• 常用的SQLAlchemy列选项

选项名	说明
primary_key	如果为True，代表表的主键
unique	如果为True，代表这列不允许出现重复的值
index	如果为True，为这列创建索引，提高查询效率
nullable	如果为True，允许有空值，如果为False，不允许有空值
default	为这列定义默认值

• 常用的SQLAlchemy关系选项

选项名	说明
backref	在关系的另一模型中添加反向引用
secondary	指定多对多关系中关系表的名字

四.数据库基本操作

• 在Flask-SQLAlchemy中，插入、修改、删除操作，均由数据库会话管理。
  • 会话用 db.session 表示。在准备把数据写入数据库前，要先将数据添加到会话中然后调用 commit() 方法提交会话。
• 在 Flask-SQLAlchemy 中，查询操作是通过 query 对象操作数据。
  • 最基本的查询是返回表中所有数据，可以通过过滤器进行更精确的数据库查询。

1.定义模型类 & 增删改

• 创建表：

db.create_all()

• 删除表：

db.drop_all()

• 插入一条数据：

user = User(name='zs')
db.session.add(user)
db.session.commit()

• 案例:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
# 设置数据库连接地址
app.config["SQLALCHEMY_DATABASE_URI"] = "mysql://root:mysql@127.0.0.1:3306/test15"
# 设置是否跟踪数据库改变
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
# 创建数据库连接
db = SQLAlchemy(app)


class User(db.Model):
    __tablename__ = "users"  # 默认使用类名的小写做表名
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64), unique=True)


app.route('/')
def index():
    # 删除所有表
    db.drop_all()
    # 创建所有继承自db.Model的表
    db.create_all()
    # 创建模型
    user = User(name="zs")

    # 添加数据 到会话中
    db.session.add(user)
    # 会话提交(提交后, 才会执行数据库操作)
    db.session.commit()

    # 修改数据
    user.name = "wangwu"
    db.session.commit()

    # 删除数据
    db.session.delete(user)
    db.session.commit()

    return 'index'


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

• 细节：
  • 主键不要手动设置，数据库会自动生成
  • 这里session代表数据库中的事务，而不是状态保存机制
  • 增删改必须要进行提交
  • 类->表 类属性->字段 实例对象->记录

2.数据查询

• 常用的SQLAlchemy查询过滤器

过滤器	说明
filter()	把过滤器添加到原查询上，返回一个新查询
filter_by()	把等值过滤器添加到原查询上，返回一个新查询
limit	使用指定的值限定原查询返回的结果
order_by()	根据指定条件对原查询结果进行排序，返回一个新查询

• 常用的SQLAlchemy查询执行器

  方法	说明
  all()	以列表形式返回查询的所有结果
  first()	返回查询的第一个结果，如果未查到，返回None
  first_or_404()	返回查询的第一个结果，如果未查到，返回404
  get()	返回指定主键对应的行，如不存在，返回None
  get_or_404()	返回指定主键对应的行，如不存在，返回404
  count()	返回查询结果的数量
  paginate()	返回一个Paginate对象，它包含指定范围内的结果

• 案例

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
# 设置数据库连接地址
app.config["SQLALCHEMY_DATABASE_URI"] = "mysql://root:mysql@127.0.0.1:3306/test15"
# 设置是否跟踪数据库改变
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
# 创建数据库连接
db = SQLAlchemy(app)

# 自定义类 继承db.Model  对应 表
class User(db.Model):
    __tablename__ = "users"  # 表名 默认使用类名的小写
    # 定义类属性 记录字段
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64))
    email = db.Column(db.String(64))
    age = db.Column(db.Integer)

    def __repr__(self):  # 自定义 交互模式 & print() 的对象打印
        return "(%s, %s, %s, %s)" % (self.id, self.name, self.email, self.age)

def select():
""
    # 查找所有的用户数据
    User.query.all()   # 返回列表

    # 查询有多少各用户
    User.query.count() # 返回数量

    # 查询第一个用户
    User.query.first() # 返回模型对象

    # 查询id为4的用户[3种方式]
    User.query.get(4)  # 根据主键查询
    User.query.filter_by(id=4).all()  # 简单查询器 以关键字实参的形式来匹配字段
    User.query.filter(User.id == 4).all()  # 复杂查询器 以恒等式等形式来匹配字段

    # 查询名字结尾字符为g的所有用户[开始/包含]
    User.query.filter(User.name.endswith('g')).all()
    User.query.filter(User.name.startswith('w')).all()
    User.query.filter(User.name.contains('n')).all()
    User.query.filter(User.name.like('w%n%g')).all() # 模糊查询

    # 查询名字和邮箱都以li开头的所有用户[2种形式]
    User.query.filter(User.name.startswith('li'), User.email.startswith('li')).all()

    from sqlalchemy import and_
    User.query.filter(and_(User.name.startswith('li'), User.email.startswith('li'))).all()

    # 查询age是25 或者 email以itheima.com结尾的所有用户
    from sqlalchemy import or_
    User.query.filter(or_(User.age == 25, User.email.endswith('itheima.com'))).all()

    # 查询名字不等于wang的所有用户[2种方式]
    from sqlalchemy import not_
    User.query.filter(not_(User.name == 'wang')).all()

    # 查询id为[1,3,5,7,9]的用户
    User.query.filter(User.id.in_([1, 3, 5, 7, 9])).all()

    # 所有用户按年龄从小到大,再按id从大到小排序,取前5个
    User.query.order_by(User.name,User.id.desc().limit(5).all())
    pn = User.query.paginate(2, 3)  # paginate(页码, 每页条数)
    # pn.page 总页数 pn.page 当前页码  pn.items 当前页的数据
    """
    pass


if __name__ == '__main__':
    # 删除所有表
    db.drop_all()
    # 创建所有表
    db.create_all()
    # 添加测试数据
    user1 = User(name='wang', email='wang@163.com', age=20)
    user2 = User(name='zhang', email='zhang@189.com', age=33)
    user3 = User(name='chen', email='chen@126.com', age=23)
    user4 = User(name='zhou', email='zhou@163.com', age=29)
    user5 = User(name='tang', email='tang@itheima.com', age=25)
    user6 = User(name='wu', email='wu@gmail.com', age=25)
    user7 = User(name='qian', email='qian@gmail.com', age=23)
    user8 = User(name='liu', email='liu@itheima.com', age=30)
    user9 = User(name='li', email='li@163.com', age=28)
    user10 = User(name='sun', email='sun@163.com', age=26)

    # 一次添加多条数据
    db.session.add_all([user1, user2, user3, user4, user5, user6, user7, user8, user9, user10])
    db.session.commit()

    app.run(debug=True)

3.一对多的关系（重点）

• 案例

class User(db.Model):  # 一个用户对应多个收货地址   一的一方
    __tablename__ = "users"
    # 定义类属性 记录字段
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(64))
    addresses = db.relationship("Address", backref="user")


class Address(db.Model):  # 多的一方
    __tablename__ = "addresses"
    id = db.Column(db.Integer, primary_key=True)
    detail = db.Column(db.String(64))
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"))  # 在多的一方设置外键


app.route('/')
def index():

    """仅使用外键进行查询"""

    # user1 = User(name="zs")
    # db.session.add(user1)
    # db.session.commit()   # 如果不设置关系, 只使用外键的话, 必须要先提交user, 否则user的id不会生成
    #
    # adr1 = Address(detail="上海市浦东新区陆家嘴汤臣一品001号", user_id=user1.id)
    # adr2 = Address(detail="北京海淀区钓鱼台七号院001号", user_id=user1.id)
    # db.session.add_all([adr1, adr2])
    # db.session.commit()
    #
    # # 根据人查地址
    # print(Address.query.filter(Address.user_id == user1.id).all())
    # # 根据地址查人
    # print(User.query.filter(User.id == adr1.user_id).all())

    """使用关系进行查询"""

    user1 = User(name="zs")
    adr1 = Address(detail="上海市浦东新区陆家嘴汤臣一品001号", user=user1) 
    adr2 = Address(detail="北京海淀区钓鱼台七号院001号", user=user1)
    db.session.add_all([user1, adr1, adr2])  # 不需要提前保存user
    db.session.commit()

    print(adr1.user)
    print(adr2.user)
    print(type(user1.addresses))  # 设置lazy为dynamic,不会直接返回结果,"懒查询"
    print(user1.addresses.all())

    return "index"


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

• 其中realtionship描述了Address和User的关系。在此文中，第一个参数为对应参照的类"User"
• 第二个参数backref为类User申明新属性的方法
• 第三个参数lazy决定了什么时候SQLALchemy从数据库中加载数据
  • 如果设置为默认方式(select)，则会在加载完User对象后，就立即加载与其关联的对象，这样会让总查询数量减少，但如果返回的条目数量很多，就会比较慢
  • 另外,也可以设置为动态方式(dynamic)，这样关联对象会在被使用的时候再进行加载，并且在返回前进行过滤，如果返回的对象数很多，或者未来会变得很多，那最好采用这种方式
    • 设置为 dynamic 的话，user.address 返回查询对象，并没有做真正的查询，可以利用查询对象做其他逻辑，比如：先排序再返回结果