Flask基础入门学习笔记-1

# Linux / Windows
# 创建虚拟目录
mkdir project && cd ./project && python3 -m venv venv
# 激活虚拟环境
$ . venv/bin/activate     # Linux
> venvScriptsactivate   # Windows

# Tips:激活后终端提示符会显示虚拟环境的名称。

# pip 与 virtualenv 安装
apt install python-pip && pip install virtualenv 

# 虚拟环境配置
apt install virtualenvwrapper 
export WORKON_HOME=~/.virtualenvs
source /usr/local/bin/virtualenvwrapper.sh

# 创建虚拟环境名称
mkvirtualenv
# 删除虚拟环境名称
rmvirtualenv
# 进入虚拟环境名称
workon
# 退出
deactivate

# 环境变量从dotenv中读取
pip install python-dotenv

.env
.flaskenv

# 环境变量从virtualenv中
.flaskenv

# 依赖安装
cat requirement.txt
flask
flask-script
Flask-RESTful

# 在已激活的虚拟环境中可以使用如下命令安装 Flask：
pip install -r requirement.txt

debug    # 调试模式默认为True
threaded # 是否开启多线程
port     # 指定服务器的端口 (5000)
host     # 绑定的主机地址(127.0.0.1 / 0.0.0.0)

# 简单示例
app.run(debug=Ture,host='0.0.0.0',port=8000)

# 应用发现
FLASK_APP=hello
# 环境变量
FLASK_ENV=development 
# 看附加文件与Reloader
FLASK_RUN_EXTRA_FILES=file1:dirA/file2:dirB/
# 调试模式(在开发者模式自动开启)
FLASK_DEBUG=1
# 启动端口设置
FLASK_RUN_PORT=8000
# 禁用dotenv
FLASK_SKIP_DOTENV=1

# 运行开发服务器(启动参数指定)
flask run --port 8000 --extra-files file1:dirA/file2:dirB/

# 运行开发服务器(从环境变量中读取启动端口)
flask shell

#!/usr/bin/python3
from flask import Flask
from datetime import datetime

app = Flask(__name__)

@app.route('/')
def hello_world():
  a = "Flask"
  b = " - Hello world"
  time =  datetime.now()
  return "<h4 style='text-algin:center'>Project %s %s %s</h4>" % (a,b,time)

if __name__ == '__main__':
  app.run(debug=Ture,host='0.0.0.0',port=8000)

# 方式1
# bat
set FLASK_ENV=development
# powershell
$env:FLASK_ENV="development" 
# linux
FLASK_ENV=production
python Flask-hello_world.py

# 方式2
env FLASK_APP=.Flask-hello_world.py flask run
$env:FLASK_APP=.Flask-hello_world.py flask run

 * Serving Flask app "Flask-hello_world" (lazy loading)
 * Environment: production
WARNING: This is a development server. Do not use it in a production deployment.Use a production WSGI server instead.
 * Debug mode: on
 * Restarting with stat        # 修改自动重启
 * Debugger is active!         # debuger
 * Debugger PIN: 113-873-865   # 唯一身份标识
 * Running on http://0.0.0.0:8000/ (Press CTRL+C to quit)

from flask import Flask
from flask_script import Manager
# 初始化操作
app = Flask(__name__)
# 使用app构建Manager对象
manager = Manager(app)

@app.route('/')
def param():
   return f'Flask - script,host port param'

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

$python .Day1flask-scritp.py     
usage: flask-scritp.py [-?] {shell,runserver} ...
positional arguments:
  {shell,runserver}
    shell            Runs a Python shell inside Flask application context.
    runserver        Runs the Flask development server i.e. app.run()

usage: flask-scritp.py runserver [-?] [-h HOST] [-p PORT] [--threaded]
  [--processes PROCESSES]
  [--passthrough-errors] [-d] [-D] [-r] [-R]
  [--ssl-crt SSL_CRT] [--ssl-key SSL_KEY]

# Linux
python3 http.py runserver -p 8000 - h 0.0.0.0 -d -r --threaded

# windows
python .Day1flask-scritp.py runserver -h 0.0.0.0 -p 8000 -r -d --threaded
 * Serving Flask app "flask-scritp" (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment. 
   Use a production WSGI server instead.
 * Debug mode: on
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 113-873-865
 * Running on http://0.0.0.0:8000/ (Press CTRL+C to quit)

# Powershell（Linux 不多说了）
$env:FLASK_ENV="development"
$env:FLASK_APP="./Flask-param.py"
$env:FLASK_RUN_PORT="8080";
flask run
# * Serving Flask app "./Flask-param.py" (lazy loading)
# * Environment: development
# * Debug mode: on
# * Restarting with stat
# * Debugger is active!
# * Debugger PIN: 292-194-254
# * Running on http://127.0.0.1:8080/ (Press CTRL+C to quit)

# 也可以在运行flask run指定host-port参数注意其优先级高于环境变量
$env:FLASK_APP="./Flask-param.py"
flask run --port 8000 --host 0.0.0.0 
* Debugger is active!
* Debugger PIN: 292-194-254
* Running on http://0.0.0.0:8000/ (Press CTRL+C to quit)

# Flask 请求与响应返回
浏览器 -> Route -> Views            -> Views -> Templates -> 浏览器
                         -> modesl /

# (1)路由参数获取
<converter:variable_name>
# converter 类型
  * String: 接收任何没有斜杠('/')的文件(默认);
  * Int: 接收整型;
  * Float: 接收浮点型;
  * Path: 接收路径可接收斜线('/')不以其作为分割阶段,即其从`aa/bb/cc`;
  * Uuid: 只接受uuid字符串,唯一码一种生成规则;
  * Any: 可以同时指定多种路径进行限定;
# Example
@app.route('/default/<string:id/')
@app.route('/<int:id>/')
@app.route('/<uuid:id>/')


# (2) 请求方法
methods=[GET,POST,HEAD,PUT,DELETE,OPTION]
# Example
@app.route('/api-Rsetful/',methods=['GET','POST'])

# (3) 反向解析：根据函数名字获取反向路径
url_for('函数名称',参数名=value)

@app.route('/')
def index():
  return '<b> Hello World! This is Flask Index </b>'

@app.route('/getstring/<id>/')
def get_str(id):
  print(id,":",type(id))  # str
  return '字符串: Hello {} Username!'.format(id)

@app.route('/getint/<int:id>/')
def get_int(id):
  print(id,":",type(id))  # int
  return '数值: {} '.format(id)

@app.route('/getpath/<path:id>/')
def get_path(id):
  print(id,":",type(id))  # str 注意与 string 的不同
  return '路径: {} '.format(id)

@app.route('/getuuid/<uuid:uuid>/')
def get_uuid(uuid):
  print(uuid,":",type(uuid))  # 277cd8ed-041d-42f7-980c-a0f305288255 : <class 'uuid.UUID'>
  return 'uuid: {} '.format(uuid)

@app.route('/getany/<any(a,b):id>/')
def get_any(id):
  print(id,":",type(id)) # a : <class 'str'>
  return 'id: {} '.format(id)

# 请求类型限制
@app.route('/method/',methods=['GET','POST','DELETE'])
def get_method():
  return '该请求类型成功!'

# 重定向与反向解析
@app.route('/redirect/')
def get_redirect():
  # 硬编码方式
  #return redirect('/')
  # 软编码方式(动态获取) 蓝图名称.函数
  #return redirect(url_for('app.index'))
  return redirect(url_for('app.get_any',id='a'))

# http://127.0.0.1:8000/getpath/weiyigeek/api/
weiyigeek/api : <class 'str'>
路径: weiyigeek/api 

# http://127.0.0.1:8000/getany/a/
a : <class 'str'>
id: a 

# http://127.0.0.1:8000/getuuid/277cd8ed-041d-42f7-980c-a0f305288255/
277cd8ed-041d-42f7-980c-a0f305288255 : <class 'uuid.UUID'>
uuid: 277cd8ed-041d-42f7-980c-a0f305288255 、

# 重定向与反向解析
127.0.0.1:8000/redirect/ ==> http://127.0.0.1:8000/getany/a/

$tree ./
./App/
  ├── __init__.py
  ├── __pycache__  # Flask 运行时候缓存
  │   ├── __init__.cpython-37.pyc
  │   └── views.cpython-37.pyc
  ├── moudels.py
  ├── static
  ├── templates
  └── views.py
setup.py

#!/usr/bin/python3
# 导入 App 类中模块方法
from App import create_app
# 调用App类__init__模块中的方法
app = create_app();

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

from flask import Flask
# 导入App类View模块中的init_route方法
from App.views import init_route

# 生成app对象并将其传递给init_route方法
def create_app():
  app = Flask(__name__)
  init_route(app)
  return app

def init_route(app):
  @app.route('/')
  def hello_world():
    return f'Request / <br> Hello World'

  @app.route('/hello')
  def hello():
    return f'Request /hello <br> Hello Flask, WeiyiGeek'

#  / 
Request / <br> Hello World

# /hello
Request /hello <br> Hello Flask, WeiyiGeek

$tree Buleroute/
Buleroute/
  ├── __init__.py
  ├── templates
  │   └── index.html
  └── view
      ├── __init__.py
      ├── index.py
      └── user.py
setup.py  #与上面差不多只是调用的是Buleroute包__init__模块中的create_app()方法下面就不重复展示

from flask import Flask
from Buleroute.view import init_view #view模块下init_view方法
def create_app():
  app = Flask(__name__)
  init_view(app=app)
  return app

from .index import index  
from .user import user

def init_view(app):
  # app 蓝图注册
  app.register_blueprint(index) #传入一个名称为index的蓝图
  app.register_blueprint(user)

# index.py
from flask import Blueprint,render_template
# 蓝图对象  = 蓝图名称
index = Blueprint('index',__name__)  # 建立一个名称为index的蓝图

@index.route('/')
@index.route('/index')
def index_bule():
  #return f'request / <b>这是蓝图的首页</b>'
  return render_template('index.html',msg="基础入门(模板参数传递)")  # 将jiani模板渲染成为HTML并向其传递参数

<h1>Flask 入门学习 - Demo  </h1>
<ul>
  <!-- 接收来自render_template()方法的参数-->
  <li>First : {{msg}}</li>
  <li>Second</li>
  <li>There</li>
</ul>

- Setup.py 项目管理及入口文件
  - App 应用项目目录(MVC)
    - __init__ 初始化文件
    - ext      extension扩展库除了和路由相关
    - setting  config以及全局项目配置
    - view     apis和路由视图函数
    - models   定制模型与数据库相关
    - static   静态资源文件
    - template 网页模板文件

#!/usr/bin/python3
# from App import create_app
# from Buleroute import create_app
import os
from SQLAlchemy import create_app
from flask_script import Manager
from flask_migrate import MigrateCommand


# 系统获取环境变量来进行切换数据库
env = os.environ.get("FLASK_ENV","develop")

app = create_app(env)
manager = Manager(app=app)
manager.add_command('db',MigrateCommand)

if __name__ == "__main__":
  manager.run()

# MVC
from flask import Flask
from SQLAlchemy.view import init_view
from .ext import init_ext
from .setting import envs
from .models import User

def create_app(env):
  app = Flask(__name__)
  # 未采用环境切换时候
  # init_param(app)

  # 采用环境变量进行开发和生产环境切换
  app.config.from_object(envs.get(env))
  # 初始化扩展
  init_ext(app)
  # 初始化路由
  init_view(app=app)
  return app

# 第三方扩展包初始化加载
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate

db = SQLAlchemy()
migrate = Migrate()

# 后初始化化懒加载
def init_ext(app):
  db.init_app(app)
  migrate.init_app(app, db)

# 第三方库所需参数设置
# def init_param(app):
# # 数据库连接字符串通用: 数据库+驱动://用户名:密码@主机:端口/具体库?参数
#   app.config['SQLALCHEMY_DATABASE_URI'] = "sqlite:///sqlite.db"
#   app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

def get_db_uri(dbinfo):
  engine = dbinfo.get("ENGINE") or "sqlite"
  driver = dbinfo.get("DRIVER") or "sqlite"
  user = dbinfo.get("USER") or ""
  password = dbinfo.get("PASSWORD") or ""
  host = dbinfo.get("HOST") or ""
  port = dbinfo.get("PORT") or ""
  name = dbinfo.get("NAME") or ""

  if engine == "sqlite":
    return "{}:///{}".format(engine,name)
  else:
    return "{}+{}://{}:{}@{}:{}/{}".format(engine,driver,user,password,host,port,name)
    
    
class DevelopConfig:
  # SQLALCHEMY 设置环境变量
  DEBUG = Ture
  SQLALCHEMY_TRACK_MODIFICATIONS = False
  DBINFO = {
    "ENGINE": "sqlite",
    "NAME": "sqlite.db"
  }
  SQLALCHEMY_DATABASE_URI = get_db_uri(DBINFO)


class ProductConfig:
  DEBUG = False
  SQLALCHEMY_TRACK_MODIFICATIONS = False
  DBINFO = {
    "ENGINE": "mysql",
    "DRIVER": "pymysql",
    "USER": "root",
    "PASSWORD": "Pass#2020",
    "HOST": "127.0.0.1",
    "PORT": "3306",
    "NAME": "FlaskTest"
  }
  SQLALCHEMY_DATABASE_URI = get_db_uri(DBINFO)


# 可以直接向app.config传递类对象达到切换测试环境与生产环境
envs = {
  "develop": DevelopConfig,
  "product": ProductConfig
}

#!/usr/bin/python3
# 第三方模块自定类声明
from SQLAlchemy.ext import db

def save(obj):
  db.session.add(obj)
  db.session.commit()

# User 类
class User(db.Model):
  __tablename__ = 'user'   #表名
  id = db.Column(db.Integer, primary_key=Ture)
  username = db.Column(db.String(16))

  def commit(self):
    save(self)

class Member(db.Model):
  id = db.Column(db.Integer, primary_key=Ture)
  subname = db.Column(db.String(16))
  def commit(self,db):
    save(delf,db)

from flask import Blueprint
from SQLAlchemy.models import db,User
database = Blueprint('database',__name__)

@database.route('/createdb/')
def create_db():
  db.create_all();
  return '创建成功'

@database.route('/adduser/')
def user_add():
  user = User()
  user.username = "WeiyiGeek"

  # # 官方
  # db.session.add(user)
  # db.session.commit()

  # 在类中自定义方法(实际是对上面的两个方法的调用)
  user.commit()
  return "username %s Insert Successful!" %(user.username)

@database.route('/dropdb/')
def drop_db():
  db.drop_all()
  return '删除成功'

                             |-----------------------> Ext
Control Manager ---> __init__                         /
                             |----> Views ---> Models

- url: 完整请求地址
- url_root: 主机与端口号的URL
- path: 路由中的路径
- host_url: 主机与端口号的URL
- base_url: 去掉GET参数的URL
- method: 请求方法
- remote_addr: 请求的客户端地址
- args: GET请求参数
- form: POST请求参数
- values：返回请求中的参数和form
- date: 请求的数据
- files: 请求上传的文件
- headers: 请求头
- cookies: 请求中的cookie
- session: 请求中的session

# 语法说明
return request.method                  #POST
return json.dumps(request.form)        #{"username": "123", "password": "1234"}
return json.dumps(request.args)        #url：http://192.168.1.183:5000/login?a=1&b=2 返回值：{"a": "1", "b": "2"}
return str(request.values)             #CombinedMultiDict([ImmutableMultiDict([('a', '1'), ('b', '2')]), ImmutableMultiDict([('username', '123'), ('password', '1234')])])
return json.dumps(request.cookies)     #cookies信息
return str(request.headers)            #headers信息
return request.headers.get('User-Agent')      #获取User-Agent信息
return 'url: %s , script_root: %s , path: %s , base_url: %s , url_root : %s' % (request.url,request.script_root, request.path,request.base_url,request.url_root)
# url: http://192.168.1.183:5000/testrequest?a&b , 
# script_root: , 
# path: /testrequest ,
# base_url: http://192.168.1.183:5000/testrequest , 
# url_root : http://192.168.1.183:5000/

# 常用获取方式
dict = ImmutableMutiltiDict
# 获取单个key的值
dict.get('key')
# 获取指定key对应的所有值
dict.getlist('key')

@demo2.route('/request/<path:url>',methods=['GET','POST'])
def req(url):
  req_method = ''
  if request.method.upper() == 'GET':
    req_method = 'GET Successful!'
  elif request.method.upper() == 'POST':
    req_method = 'POST Successful!'
  else:
    req_method = request.method.upper()+'Not Support!'

  # request 属性演示
  return " Current Time: {}<br>Header:<pre>{}</pre><br> HOST: {} <br>URL: {} <br>Method: {} <br>Client IP: {} <br>".format(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),request.headers, request.host_url, request.base_url, req_method, request.remote_addr)

# 执行结果:http://127.0.0.1:8000/request/user/weiyigeek
# Current Time: 2020-09-07 17:52:50

# Header:
# Host: 127.0.0.1:8000
# User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:80.0) Gecko/20100101 Firefox/80.0
# Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
# Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
# Accept-Encoding: gzip, deflate
# Connection: keep-alive
# Upgrade-Insecure-Requests: 1

# HOST: http://127.0.0.1:8000/
# URL: http://127.0.0.1:8000/request/user/weiyigeek
# Method: GET Successful!
# Client IP: 127.0.0.1

@demo2.route('/login/',methods=['GET','POST'])
def send_rep():
  # GET
  print(request.args,"n",type(request.args));
  print(request.args.getlist('a'))

  # POST
  print(request.form,"n",type(request.form))

  # 登录示例
  if request.method.upper() == 'POST':
    if request.form['username'] == 'weiyigeek' and request.form['password'] == 'pass':
      return 'Ture'
    else:
      #当form中的两个字段内容不一致时，返回我们所需要的测试信息需要替换的部分
      return str(request.headers)       
  else:
      return render_template('login.html')

  return 'successful!'

# 执行结果
# GET
ImmutableMultiDict([]) 
 <class 'werkzeug.datastructures.ImmutableMultiDict'>
[]
# POST
ImmutableMultiDict([('username', 'weiyigeek'), ('password', 'pass')])
 <class 'werkzeug.datastructures.ImmutableMultiDict'

from werkzeug.utils import secure_filename
from flask import Blueprint,request,render_template
# date是请求的数据，files随请求上传的文件
@demo2.route('/upload',methods=['GET','POST'])
def upload():
  if request.method == 'POST':
      print(request.date," : ", type(request.date))
      print(request.files," : ", type(request.files))
      f = request.files['file']
      filename = secure_filename(f.filename)
      #f.save(os.path.join('app/static',filename))
      f.save('App/static/'+str(filename))
      return 'ok'
  else:
      return render_template('upload.html')

# html
<!DOCTYPE html>
<html>
    <body>
        <form action="upload" method="post" enctype="multipart/form-data">
            <input type="text" name="flag" value="weiyigeek">
            <input type="file" name="file" /><br />
            <input type="submit" value="Upload" />
        </form>
    </body>
</html>     

# 注意:上传文件需求管理员权限
# powershell start-process cmd -verb runas
# cd /d E:githubProjectStudy-PromgramPython3FlaskDay3
# python .Setup.py runserver -h 0.0.0.0 -p 8000 -r -d --threaded

# 执行结果
None  :  <class 'NoneType'>
ImmutableMultiDict([('file', <FileStorage: 'QQ截图20200907112813.jpg' ('image/jpeg')>)])  :  <class 'werkzeug.datastructures.ImmutableMultiDict'>
127.0.0.1 - - [07/Sep/2020 18:23:23] "POST /upload HTTP/1.1" 200 -

1.通过直接返回字符串与状态、也可采用Reponse对象或者通过make_response(data,code)函数使传递进来的资源创建一个response,前者返回的数据内容后者返回的状态码;
2.返回的文本内容和状态码
3.利用render_template将模板渲染成为HTML
4.返回模板(实质与2一样)
5.重定向 redirect() 或者 url_for('函数名',参数=value)
6.终止信号 abort
7.钩子函数: 异常捕获或者errorhandler(app作用于全局、蓝图只能捕获本身蓝图)
8.

# 方式1.return 与 render_template() 方式
@app.route('/reponse/')
def get_reponse():
  # return "Reponse Test", 201 
  # return render_template('hello.html'), 201 # 相差不大都是返回的字符串
  return Response('我是直接返回的Reponse对象!')   # 直接构建Response对象返回返回客户端状态码为201


# 方式2.make_response 方式
@app.route('/reponse/')
def get_reponse():
  response = make_response(render_template('error.html'), 404)
  return response

# 中止处理: 直接返回异常码响应的描述
abort(异常码)
abort(404)  # 可直接向客户端抛404响应码,其数值在mapping对应的错误码否则异常抛出(其本质就是一个exception)即HttpExeception
abort(Response('404 Not Found!'))

# 捕获异常：实现页面友好化但是需要注册errorhandler;
@app.errorhandler(404):
def not_found():
  return '404 , Not Found!', 404

from flask import render_template 
....
@app.errorhandler(404)
def not_found(error):
  print(error)
  print(type(error))
  return render_template('404.html',title="404 Not Found",msg=error)  # 注意导包

#Day3Apptemplates404.html
<body>
  <h1>{{title}}</h1>
  <br>
  <pre>{{msg}}</pre>
</body>

# 设置Cookies
# 方式1
response = make_response("响应的字符串此处是参数 %s" % username)
# 方式2
response =  Response("响应的字符串此处是参数{}".format(username))
response.set_cookie(key, value="", max_age=None, expires=None, path="/", domain=None, secure=False, httponly=False, samesite=None)
response.delete_cookie(key)
# 获取Cookies中指定的key的值
request.cookies.get('key')

from flask import Blueprint,request,render_template,url_for,redirect,make_response,Response

# 设置
@demo2.route('/userlogin/',methods=['GET','POST'])
def login():
  if request.method.upper() == 'GET':
    return render_template('login.html')
  elif request.method.upper() == 'POST':
    username = request.form.get('username')
    password = request.form.get('password')
    if username == password :
      # 方式1
      # response = make_response("欢迎 %s 登陆,你已经成功登陆! <a href='/userperson/'>个人主页</a>" % username )
      # 方式2
      response =  Response("<script>alert('欢迎 %s 登陆,你已经成功登陆!,正在跳转个人主页!');window.location.href='/userperson/'</script>" % (username))
      response.set_cookie('username', username)
      response.set_cookie('name', '唯一极客')
      #redirect(url_for('demo2.person'),302)
      return response
    else:
      return '账号或者密码错误!'
  else:
    return 'ERROR! Request Method Not Allow!'

# 获取
@demo2.route('/userperson/',methods=['GET','POST'])
def person():
  print(request.cookies)
  if request.cookies.get('username') != None:
    name = request.cookies.get('name')
    username = request.cookies.get('username')
    return '欢迎 <u> %s </u> 您回来, 你的登陆 <u> %s </u>用户!' % (name,username)  # 易错点注意有括号
  else:
    return "<script>alert('用户未登录请登陆');window.location.href='/userlogin';</script>"

# 响应结果:
# Cookie
# username=weiyigeek; name="345224257344270200346236201345256242";

# 在app对象中进行配置或者直接在setting进行配置然后通过类加载到app配置中
app.config['SECRET_KEY'] = 'WeiyiGeek'

# 1.创建 session 键值对
session['key'] = value;

# 2.值获取 
session.get('key')

# Day3Appviewsdemodemo2.py
from flask import Blueprint,request,render_template,url_for,redirect,make_response,Response,session
@demo2.route('/session-test/<string:name>',methods=['GET','POST'])
def sessiontest(name):
  if name != None:
    session['name'] = name;
    session['username'] = "唯一极客";
    return 'Session 创建 进入查看 session <a href="/getsession/">show</a>'
  else:
    return '<p style="color:red">Parameter Error!</p>'


@demo2.route('/getsession/',methods=['GET'])
def getsession():
  if session.get('name') != None:
    print(session)
    print(type(session))
    return 'session value %s , %s' % (session.get('name'),session.get('username'))
  else:
    return '<b>session 未设置请在 /session-test/<string:name> 页面上复制 </b><script language="javascript">setTimeout("location='/'",3000);</script>'

# 结果1.默认的session将所有的键值通过序列化存储在网页的cookie中
<SecureCookieSession {'name': 'weiyigeek', 'username': '唯一极客'}>
<class 'werkzeug.local.LocalProxy'>
session=eyJuYW1lIjoid2VpeWlnZWVrIiwidXNlcm5hbWUiOiJcdTU1MmZcdTRlMDBcdTY3ODFcdTViYTIifQ.X2GdGA.MgBLw9iCDlFBMaSXmtruHjdzkGs

# flask-session环境安装配置
pip install flask-session
pip install redis

# 方式1
app.config['SECRET_KEY']  = "WeiyiGeek"
app.config['SESSION_COOKIE_SECURE'] = Ture
app.config['SESSION_USER_SIGNER'] = Ture
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = Redis(host='192.168.100.10', password='weyigeek',db=3)
app.config['SESSION_KEY_PREFIX'] = "product:"

# 方式2 Day3Appsetting.py
SECRET_KEY = "WeiyiGeek"
SESSION_COOKIE_SECURE = Ture
SESSION_KEY_PREFIX = "product:"
SESSION_TYPE = 'redis'
SESSION_REDIS = Redis(host='192.168.100.10', password='weyigeek',db=3)
SESSION_USER_SIGNER = Ture

# Day3Appext.py
from flask_session import Session

# 初始化扩展
def init_ext(app):
Session(app)       # Flask session 第三方插件

<RedisSession {'_permanent': True, 'name': 'WeiyiGeek-Redis', 'username': '唯一极客'}>
<class 'werkzeug.local.LocalProxy'>
Set-Cookie:session=4a461782-840d-4a2d-8352-3622ea9102fe; Expires=Sat, 17-Oct-2020 08:11:32 GMT; Secure; HttpOnly; Path=/

{# ``base.html`` 
   这是注释的行
#}

{% block xxx %}
  <p>我是等待被填充或者继承的元素</p>
{% endblock xxx %}  <!-- 推荐结束时候也加上块名称 -->

{% extends 'xxx.html' %}
{% block xxx %}
{{ super() }}   // 继承
  <span>我是添加的子元素</span>  // 扩充
{% endblock xxx %}

{% include 'xxx' %}

{% marco hello(name) %}
  {{ name }}
{% endmarco %}

# 宏调用
{{ hello("weiyigeek") }}

# 重其它模板中导入宏定义
{% from 'xxxx' import hello,func1,func2 %}

{% for item in cols %}

{% else %}

{% endfor %}

# syntax:
{{ 变量|过滤器|过滤器 }}

# 可用过滤器函数
capitalize # 驼峰命名法
default
last
first
length
sum
sort
lower
upper
title
trim
reverse
format
safe
striptags  # 渲染前将值中标签去掉

<!DOCTYPE html>
<html lang="en">
{% block header%}
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>{% block title%} {{ title }} {% endblock %}</title>
</head>
{% endblock header%}
<body>
{% block content %}
  <p style="color: red;"> Python Flask Deveploment Study!</p>
  <h5>Name: {{ student }}</h5>
{% endblock content %}

<br/>
{% block footer %}
  <p>&copy; WeiyiGeek  &copysr; Python-Flask <br><a href="https://weiyigeek.top">个人主页</a></p>
{% endblock footer %}
<br/>
</body>
</html>

<div id="firends">
  <ul>
    <li>https://weiyigeek.top</li>
    <li>https://weiyigeek.top</li>
  </ul>
</div>

{% macro Start(name) %}
<span> 你好, {{ name }} </span>
{% endmacro %}

{% macro Product(a,b,c) %}
<p>产品列表：</p>
<span> {{ a }} </span>
<span> {{ b }} </span>
<span> {{ c }} </span>
{% endmacro %}

{% extends 'Tag/default.html' %}

<!DOCTYPE html>
<html lang="en">

<!-- 示例1.块引用 -->
{% block header %}
  {{ super() }}
{% endblock header %}
<body>
  {% block content %}
    <b>块引用嵌入</b>
    {{ super() }}
    {% block firends %}
      <!-- 示例2.文件包含(需要包含在父块中) -->
      <p>友情连接: </p>
      {% include 'Tag/friends.html' %}
    {% endblock firends %}

    <hr>
    <!-- 实例3.模板中定义函数含(需要包含在父块中)使用时候一般会在一个专门的文件中 -->

    <b> 标签中自定义函数: </b> <br>
    {% macro hello_tag() %}
      <u> 我是标签模板生成的函数 </u> <br>
    {% endmacro %}

    <!-- 调用几次就生成几次 -->
    {{ hello_tag() }}
    {{ hello_tag() }}

    {% from 'Tag/function.html' import Start,Product %}
    <br>
    {{ Start("WeiyiGeek") }}
    {{ Product("Python3 入门到精通","Python 可视化编程","Python - Flask Web Development") }}

  {% endblock content %}


  {% block footer %}
  <hr>
  <b>条件循环</b>
  {% for user in users %}
    {% if loop.first %}
    <li style="color:red"> {{ loop.index }} : {{ loop.index0 }} : {{ user }}</li>
    {% elif loop.last %}
    <li style="color:green"> {{ loop.index }} : {{ loop.index0 }} : {{ user }}</li>
    {% else %}
    <li style="color:blue"> {{ loop.index }} : {{ loop.index0 }} : {{ user }}</li>
    {% endif %}
  {% else %}
    <p>循环结束</p>
  {% endfor %}

  <hr>
  <b>过滤器</b>
  <p>原始字符:{{ student }}</p>
  <p>字符|capitalize:{{ student|capitalize }}</p>
  <p>字符|upper:{{ student|upper }}</p>
  <p>字符|reverse:{{ student|reverse }}</p>
  <hr>
    {{ super() }}
  {% endblock footer %}
</body>
</html>

# 视图函数演示
from flask import Blueprint,render_template

d3 = Blueprint("demo3",__name__)

@d3.route("/demo3_1/")
def demo3_1():
  users = ["C++","C","Python","Go","R","JAVA","JavaScript","PHP"]
  return render_template("Tag/demo3_1.html",title="结构标签测试",student="weiyigeek",users=users）

# C:UsersWeiyiGeekAppDataRoamingCodeUsersettings.json
"python.linting.flake8Enabled": Ture,
"python.linting.pylintEnabled": false,
"python.linting.flake8Args": [
    "--disable=E1101",
    "--max-line-length=120"
]