一 web框架介绍

# python 界的web框架
	-Django：大而全，快速开发，公司内部项目使用的多
    -Flask：小而精，不具备web开发好多功能，丰富的第三方插件
    -FastApi：异步框架，主要为了做前后端分离接口
    -Sanic：异步框架，只支持python3.6 及以上，性能比较高
    -Tornado：公司用的比较少...

1.2 fastapi

FastApi官网：https://fastapi.tiangolo.com/zh/
    
-FastAPI 是一个用于构建 API 的现代、快速（高性能）的 web 框架，使用 Python 3.6+ 并基于标准的 Python 类型提示。
-可与 NodeJS 和 Go 并肩的极高性能（归功于 Starlette 和 Pydantic）。最快的 Python web 框架之一。

# pip install fastapi
# pip install uvicorn
import time
from fastapi import FastAPI
app = FastAPI()

@app.get('/')  # 向根路径发送请求
async def index():  
    return {'code': 100, 'msg': '成功'}

# 运行服务器命令：uvicorn py文件名:app --reload
# 启动后，我们修改代码会自动重启，监听8000端口

import time
from fastapi import FastAPI
app = FastAPI()

@app.get('/') 
async def index():  # 加上async，就是协程函数
    await time.sleep(3)
    return {'code': 100, 'msg': '成功'}

@app.get('/home')
async def home():
    time.sleep(2)
    return {'code': 100, 'msg': 'home'}

@app.get('/order')
async def order():
    time.sleep(2)
    return {'code': 100, 'msg': 'order'}

# 如果是django，flask，这种同步框架，他会开启三个线程来处理这三个请求
# fastapi，sanic这种框架，就只用一个线程处理这三个请求(单线程下的并发)，开启第一个遇到IO操作，就会切换，去运行第二个函数。

二 flask

# Flask 框架
	-pip3.8 install flask

2.1 第一个flask项目

from flask import Flask

app = Flask(__name__)  # 传入import_name字符串


@app.route('/', methods=['GET'])
def index():
    return 'index字符串'


if __name__ == '__main__':
    app.run()  # 运行flask
    # 指定端口
    # app.run(port=8000)

2.2 pycharm创建flask框架（可以不用）

三 wsgiref

# 服务 wsgi协议的web服务器，django的web服务用的就是它
# 相当于个socket服务端，可以接收客户端发送过来的请求，处理，返回给客户端


from wsgiref.simple_server import make_server

def mya(environ, start_response):  # django自己写了个类，在里面自己写逻辑
    print(environ)
    # django在这个位置是中间件
    start_response('200 OK', [('Content-Type', 'text/html')])
    # 这里是路由分发
    if environ.get('PATH_INFO') == '/index':# 根据不同路由，匹配不同视图函数
        with open('index.html','rb') as f:
            data = f.read()

    elif environ.get('PATH_INFO') == '/login':
        with open('login.html', 'rb') as f:
            data = f.read()
    else:
        data = b'<h1>Hello, web!</h1>'
    return [data]
# 底层是socket服务端

if __name__ == '__main__':
    myserver = make_server('', 8011, mya)  # 监听本地的8011端口，当请求来了，就会执行 mya()，传入两个参数，一个是environ:http请求转成python的字典，一个是start_response：响应对象
    print('监听8010')
    myserver.serve_forever()


# Django和flask就是mya这个可调用对象，只是上面的代码写成个函数的形式

# environ 环绕；包围；围住

# Django的原理
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'beluga_api.settings.prod')
application = get_wsgi_application()
# 请求来了，就会执行application(environ, start_response)
# 是WSGIHandler()类的对象，对象加括号，触发类的__call__(environ, start_response)的执行


# 源码：
def get_wsgi_application():
    django.setup(set_prefix=False)
    return WSGIHandler()

class WSGIHandler(base.BaseHandler):
    def __call__(self, environ, start_response):
        return response  # 返回response对象
    
    
    
# flask原理
from flask import Flask
app = Flask(__name__)

@app.route('/', methods=['GET'])
def index():
    return 'index字符串'

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

# 请求来了，会执行 app(environ, start_response)--->
# Flask类的---__call__(environ, start_response)


# 源码
class Flask(Scaffold):
    def __call__(self, environ: dict, start_response: t.Callable) -> t.Any:
        return self.wsgi_app(environ, start_response)
    
    

四 Werkzeug

Werkzeug是一个WSGI工具包（在它基础上，继续封装），他可以作为一个Web框架的底层库。这里稍微说一下， werkzeug 不是一个web服务器，也不是一个web框架，而是一个工具包，官方的介绍说是一个 WSGI 工具包，它可以作为一个 Web 框架的底层库，因为它封装好了很多 Web 框架的东西，例如 Request，Response 等等

from werkzeug.wrappers import Request, Response

@Request.application
def hello(request):
    return Response('Hello World!')

if __name__ == '__main__':
    from werkzeug.serving import run_simple
    # run_simple('ip地址', port, 可调用对象)
    run_simple('localhost', 4000, hello)

# flask基于 Werkzeug封装的，更简单一些
# django是基于 wsgi封装的

五 Flask快速使用

5.1 登录显示用户信息的小案例

from flask import Flask, render_template, request, redirect, session

# template_folder页面文件夹
app = Flask(__name__, template_folder='templates')
# 配置文件的配置
app.debug = True  # 设置后可以自动重启
app.secret_key = 'sdfsdfsdfsdf'  # 等同于django的 配置文件有个很长的秘钥


USERS = {
    1:{'name':'张三','age':18,'gender':'男','text':"道路千万条"},
    2:{'name':'李四','age':28,'gender':'男','text':"安全第一条"},
    3:{'name':'王五','age':18,'gender':'女','text':"行车不规范"},
}



@app.route('/login', methods=['GET', 'POST'])
def login():
    # 只要在这个函数中，全局的request 就是当次请求的request对象，等同于django的request
    if request.method == 'GET':  # get请求返回模板
        return render_template('login.html')  # 新手四件套之一，返回模板
    else:
        username = request.form.get('username')  # 取值
        password = request.form.get('password')
        if username == 'lqz' and password == '123':
            # 登录成功，把登录信息，写入到session中
            session['username'] = username
            # return redirect('http://www.baidu.com')   #重定向到百度，新手四件套之一，返回重定向
            return redirect('/index')  # 重定向到我的地址，新手四件套之一，返回重定向
        else:
            return render_template('login.html', error='用户名或密码错误') 


@app.route('/index')  # methods不写，默认是GET请求
def index():
    # 判断它是否登录，如果登录，显示用户信息
    if session.get('username'):
        return render_template('index.html',users=USERS)
    else:
        return redirect('/login')

# Django的有名或者无名分组、转换器
@app.route('/detail/<int:pk>') # flask只有转换器
def detail(pk):
    if session.get('username'):
        user=USERS.get(pk)  # 拿取到单个user
        return render_template('detail.html',user=user)
    else:
        return redirect('/login')

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

login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="" method="post">
    <p>用户名：<input type="text" name="username"></p>
    <p>密码：<input type="password" name="password"></p>
    <p><input type="submit" value="提交">{{error}}</p><!-- 模板语法的插值语法 -->

</form>
</body>
</html>

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

</head>
<body>
<h1>用户列表</h1>
<table>
    <!--Django不能加括号，也只能使用点语法取值-->
    {% for k,v in users.items() %}
    <tr>
        <!--Jinja2可以使用函数加括号的返回值，可以使用点语法、中括号、get取值-->
        <td>{{k}}</td>
        <td>{{v.name}}</td>
        <td>{{v['name']}}</td>
        <td>{{v.get('name')}}</td>
        <td><a href="/detail/{{k}}">查看详细</a></td>
    </tr>
    {% endfor %}
</table>
</body>
</html>

detail.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

</head>
<body>
<h1>详细信息 {{user.name}}</h1>
    <div>
        {{user.text}}
    </div>

</body>
</html>

总结

1 新手三件套： 1) 直接返回字符串  2) 模板页面render_template  3) 重定向redirect
2 flask的路由写法，是基于装饰器的  @app.route('/detail/<int:pk>' , methods=['GET'])
3 路由转换器跟django一样
4 取出前端post请求提交的数据：request.form
5 取出请求方式：request.method
6 使用session设置值和取值   
    -session[key]=value
    -session.get('key')
7 flask的模板语法完全兼容dtl，并且它更强大，可以加括号执行

5.2 登录认证加装饰器

# 1 装饰器使用位置，顺序
# 2 flask路由下加装饰器，一定要加endpoint，每个的视图函数的值都不一样
	-如果不指定endpoint，反向解析的名字都是函数名，不加装饰器没有问题，就是正常函数index，detail
    -如果加了装饰器--->index，detail都变成了inner--->反向解析的名字都是函数名inner，就会报错
# 3 使用auth这个装饰器，是把index当成参数传入，把auth的执行结果返回后，赋值给index
	@auth  
    def index():
    # 本质：index=auth(index)

    
    
执行顺序是由外到内的
先执行路由匹配，匹配成功后，再执行判断是否登录，再执行本身的视图函数

# 装饰器
def auth(func):  
    def inner(*args, **kwargs):
        if session.get('username'):
        	res = func(*args, **kwargs)  # 真正的执行视图函数，执行视图函数之前，判断是否登录
        	return res
        else:
            # 重定向到login页面
            return redirect('/login')
    return inner


@app.route('/login', methods=['GET', 'POST'],endpoint='login')
def login():
    if request.method == 'GET': 
        return render_template('login.html')  
    else:
        username = request.form.get('username') 
        password = request.form.get('password')
        if username == 'lqz' and password == '123':
            session['username'] = username
            return redirect('/index') 
        else:
            return render_template('login.html', error='用户名或密码错误') 


@app.route('/index', endpoint='index') 
@auth  # 路由匹配成功，再执行校验是否登录
def index():
    return render_template('index.html',users=USERS)



@app.route('/detail/<int:pk>',endpoint='detail')
@auth
def detail(pk):
    user=USERS.get(pk)  
    return render_template('detail.html',user=user)

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

语法糖

@符号后面放什么都可以，不一定非要是装饰器
# 拓展1：语法糖后放个函数
def add(func):
    print(func)
    
    
@add  # test=add(test) ---> test变成了None
def test():
    print("test")	

print(test)  # None
    

# 拓展2：@后放个对象
class Person:
	def __call__(self, func):
        print(func)
        return 123
p = Person()

@p  # test=p(test)  # p() 会触发__call__
def test():
    print("test")
    
print(test)  # 123
    
    
    
# __call__写成装饰器
class Person:
    def __call__(self, func):
        def inner(*args, **kwargs):
            res = func(*args, **kwargs)
            return res
        return inner
p = Person()

@p  # test=p(test)  # p() 会触发__call__--->Person的 __call__(func)--->返回inner，以后test就是inner---> test(参数)--> 执行的是inner
def test():
    print("test")
    
print(test)  # 函数inner
 
    
    
# 拓展3：类装饰器：
	1 装饰类的装饰器   2 类作为装饰器

# 装饰类的装饰器
def auth(func):
    def inner(*args, **kwargs):
        res = func(*args, **kwargs)  # 此时的res就是Foo的对象f
        res.name='lqz'
        return res
    return inner


@auth     # Foo=auth(Foo)
class Foo():
    pass

f=Foo()  # Foo()  实际调用 --->inner(Foo)--->类实例化得到对象，返回，以后f就是Foo的对象，但是可以里面多了属性或方法
print(f)
print(f.name)


# 拓展4：有参装饰器--->额外为被装饰的函数传参数
	这样Foo中也可以使用到传入进去的这个参数10
@auth(10)     # Foo=auth(10)(Foo)
class Foo():
    pass

六 配置文件

#  django 有settings配置文件---->所有web框架都会有配置文件--->配置文件的形式可能不太一样

6.1 方式一

app = Flask(__name__)
# 配置文件方式一：只能配置debug和秘钥
app.debug = True  # 设置后可以自动重启
app.secret_key = 'sdfsdfsdfsdf'  # 等同于django的 配置文件有个很长的秘钥


@app.route('/index', methods=['GET']) 
def index():
    print(app.debug)  # True
    print(app.secret_key)  # sdfsdfsdfsdf
    return 'hello world'

6.2 方式二：app.config

# 配置文件方式二：使用app.config  等同于django中的settings的 from django.conf import settings

# 更改
app.config['DEBUG'] = True
# PS： 由于Config对象本质上是字典，所以还可以使用app.config.update(...)

app = Flask(__name__)
@app.route('/index', methods=['GET']) 
def index():
    print(app.config)  # 是个字典 
    return 'hello world'

6.3 方式三

# 通过py文件配置，类似于django
# app.config.from_pyfile("python文件名称")
app.config.from_pyfile("settings.py")
app.config.from_pyfile("dev.py")  # 类似于django的开发环境
app.config.from_pyfile("pro.py")  # 类似于django的上线环境


app = Flask(__name__)
@app.route('/index', methods=['GET']) 
def index():
    print(app.config)  # 是个字典 
    return 'hello world'

settings.py

DEBUG=True
SECRET_KEY="asdfasdfasdfasd333"

6.4 方式四：使用类的方式

# app.config.from_object("python类或类的路径")

app.config.from_object('settings.DevelopmentConfig')  # 开发环境的配置
app.config.from_object('settings.ProductionConfig')  # 上线环境的配置

app = Flask(__name__)
@app.route('/index', methods=['GET']) 
def index():
    print(app.config.get('DEBUG'))  # True 
    print(app.config.get('DATABASE_URI'))  # 'sqlite://:memory:'
    return 'hello world'

settings.py

class Config(object):  # 基类
    DEBUG = False
    DATABASE_URI = 'sqlite://:memory:'  # 数据库配置


class ProductionConfig(Config):  # 上线、生产环境
    DATABASE_URI = 'mysql://user@localhost/foo'


class DevelopmentConfig(Config):
    DEBUG = True  # 开发环境，debug 是true的，连数据库连的是sqlite

其他方式

# 通过环境变量配置的方式
# app.config.from_envvar("环境变量名称")
app.config.from_envvar(os.environ['xxx'])


# JSON方式
# app.config.from_json("json文件名称")  # JSON文件名称，必须是json格式，因为内部会执行json.loads
app.config.from_json("settings.json")


# map方式
app.config.from_mapping({'DEBUG': True})  # 字典格式

配置中心

集群化部署

本栏目推荐文章
• Flask开放的端口不能访问的解决方案
• flask 中使用 wtforms 验证请求数据的方式
• Python Flask 特殊装饰器，执行路由前和执行路由后执行的装饰器
• Python Flask 返回函数 、带值的函数
• Python Flask html 模板的继承
• Python Flask Config 配置文件
• flask中设置日志
• Flask-apscheduler获取或修改上下文中config数据
• windows 部署flask+tornado+nginx
• flask有关 flask_wtf 中的CSRFProtect 保护

flaskflask-mail flask-sqlalchemy flask-script flask-session flask-caching flask_cors flask-restful flask-login flask日志 flask flask-sqlalchemy flask-migrate sqlalchemy