flask框架----day01( Flask框架介绍、flask快速使用、登录小案例、配置文件方式、路由系统源码分析 add_url_rule函数的使用、转换器等 )

今日内容

1 Flask 和pythonweb框架介绍

# python web框架,本质都一样,都是有一个请求对象，有一个响应对象，有视图函数，有路由这些东西

--------------------------------------------------
# 同步框架

-django：大而全，内置的app多，第三方app也多
-Flask：小而精，没有过多的内置组件，
        只完成web框架最基本的功能(处理请求，匹配路由，执行视图函数，返回)
        需要借助于第三方，完成更丰富的功能

-web.py:是一个小巧灵活的Python框架，它简单而且功能强大（国内几乎没有用的）

---------------------------------------------------
# 异步web框架

# fastapi和flask操作百分之80的一样！！！   百分之二十写异步的地方不一样！！！
-fastapi：python的异步web框架，不少公司再用，很火！！ 官方文档 https://fastapi.tiangolo.com/zh/
-sanic: python的异步web框架，供支持异步高并发请求的 web 服务
-tornado:老牌的异步框架，现在用的比较少了

------------------------------------------------

# 同步框架和异步框架的区别
	-djagno是同步框架还是异步框架，djagno 3.x以后支持异步

	-同步框架的意思：一个线程只处理一个请求
	-异步框架的意思：一个线程可以处理多个请求，多个线程的情况下，并发量就上来了

	异步框架，会让耗时的任务让worker去执行，线程直接返回，处理另外的请求了
	所以异步框架可以很显著的提高项目的并发量
	用了异步框架后，框架前面用的web服务器就不是uwsgi这些了，有专门的，web服务器支持异步才行


# 一般计算密集型的项目推荐用同步框架
# io密集型的推荐使用异步框架

------------------------------------------------

.
.
.
.
.
.
.
.
.
django与flask的区别

.
.
flask 的执行原理
当我们不使用flask，只使用werkzeug，
运行werkzeug.serving里面的 run_simple方法后，
朝着ip加端口，发送请求，
就能触发 run_simple方法里面，对应的视图函数加括号运行

.
.
.
.
.
当使用Flask类创建出app对象后，
朝着ip加端口，发送请求，触发run_simple里面app对象加括号
从而触发Flask类里面的双下call方法

将run_simple方法封装到Flask类里面的run方法里面去 源码1185行
这样最后，我们运行Flask类的对象app点run方法，触发run_simple方法运行 run源码1188行
触发对象app（），触发类里面的双下call方法，在Flask类源码的2548行
return self.wsgi_app(environ, start_response)
在wsgi_app里面，通过路由匹配，最后执行对应的视图函数
并返回对应的响应对象

.
.
.
.
.
.
.
.
.

1.1 flask介绍

Flask是一个基于Python开发并且依赖jinja2模板语法和Werkzeug WSGI服务的一个微型框架
	jinja2 模板语法第三方的， 与django自带的的dtl非常像
	Werkzeug WSGI   符合wsgi协议的web服务器，
	# 对于Werkzeug本质是Socket服务端，用于接收http请求并对请求进行预处理，然后触发Flask框架


#  django使用的是wsgiref符合wsgi协议的web服务器
--------------------------------------------

#### 基于wsgiref写web框架  了解即可

from wsgiref.simple_server import make_server

# 就等同于django中的wsgi.py文件中的application的WSGIHandler类加括号生成的对象
# 对于django而言请求来了，会执行application对象加括号，触发双下call方法，并传两个参数
# mya函数或者叫可调用对象，实际上就是web框架，这个mya函数就是django框架的雏形！！！


def mya(environ, start_response):
    print(environ)    # http请求的所有东西，都在environ里面
    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]  # flask返回的是[data]        # django返回的是response


if __name__ == '__main__':
    myserver = make_server('127.0.0.1', 8008, mya)
    # 请求来了会执行mya加括号,并且还会传两个参数,http请求所有的东西、http响应的东西
    myserver.serve_forever()

--------------------------------------------------

.
.
.
.
.

# Werkzeug是一个WSGI工具包，他可以作为一个Web框架的底层库。
# werkzeug 不是一个web服务器，也不是一个web框架，而是一个WSGI工具包
# 它封装好了很多 Web 框架的东西，例如 Request，Response 等等

#### 基于werkzeug写web框架

# 这个hello函数或者说可调用对象，就是Flask框架的雏形！！！
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('localhost', 4000, hello)

# 访问任意路由，只要ip地址与端口对了，都会触发hello函数的执行！！！

--------------------------------------------------

# 所以我们使用的框架就是一堆封装好的代码，并使用了对应的web服务器

mya函数就是可调用对象，可以加括号运行
environ参数接收的，就是http请求所有的数据，start_response参数接收的是http响应所有的东西！！！
就等同于django中的wsgi.py文件中的application对象（ WSGIHandler类加括号生成的对象 ）

对于django而言请求来了，会执行application对象加括号，触发类里的双下call方法，并传两个参数

.

.
.
.
这这个双下call是整个django框架的入口及最后的出口，
从请求到结束，所有的代码都封在这里面了，最终返回了response对象！！！
djiango把environ包装成了request对象，源码132行
request = self.request_class(environ) # 将http请求数据environ包装成django的request对象

.
.
.
.
.
environ 是符合wsgi接口协议的web服务器,将http请求的数据切割整理成的原始的字典
（注意此处的web服务器不是nginx这类的web服务器！！！）



.
.
.
.
.

.
.
.
.

2 flask快速使用

# 安装：pip install flask   安装依赖： MarkupSafe, Werkzeug, Jinja2
	-1.x 没有本质区别
	-2.x 没有本质区别，源码上动了，用起来一样

----------------------------------------------

from flask import Flask

app = Flask(__name__)
# 因为双下init里面import_name参数没有默认值，所以类加括号的时候我们要主动传一个字符串进去
# app=Flask('test')       # 只是习惯括号里面写__name__，写其他的字符串都行


# 注册路由---->需要装饰器
@app.route('/index')
def index():
    return 'hello web'    # 现在访问/index路径  就可以直接返回字符串


@app.route('/')
def home():
    return 'hello home'


if __name__ == '__main__':
    # app.run('127.0.0.1',5000)
    app.run()

.
.
.
.
.
.
.
.
.

3 登录，显示用户信息小案例

3.1 login.html

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

<form method="post">
    <p>用户名：<input type="text" name="username"></p>
    <p>密码：<input type="password" name="password"></p>
    <input type="submit" value="登录"> {{error}}
</form>
</body>
</html>

.
.
.
.

3.2 home.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<h1>用户列表</h1>
<table>
    {% for k,v in user_dict.items() %}
    <tr>
        <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>

.
.
.
.

3.3 detail.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<p>名字是：{{user.name}}</p>
<p>年龄是：{{user['age']}}</p>
<p>性别是：{{user.get('gender')}}</p>
<p>{{user.text}}</p>


</body>
</html>

.
.
.
.

3.4 py文件

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

app = Flask(__name__)

# 要使用session，必须设置秘钥，秘钥是配置信息
app.secret_key = 'asdfasdfa33aef3aefads'

USERS = {
    1:{'name':'张三','age':18,'gender':'男','text':"道路千万条"},
    2:{'name':'李四','age':28,'gender':'男','text':"安全第一条"},
    3:{'name':'王五','age':18,'gender':'女','text':"行车不规范"},
}
# 1 创建templates文件夹，写login.html
@app.route('/login', methods=['GET', 'POST'])
def index():
    # 没有request对象，使用全局的request
    # get请求，返回模板
    if request.method == 'GET':
        return render_template('login.html')  # 新手四件套之一：返回模板
    else:
        # post请求，校验数据
        # 取出前端传入的用户名密码，校验
        username = request.form.get('username')  # 等同于django的的request.POST
        password = request.form.get('password')
        if username == 'lqz' and password == '123':
            # 登录成功,保存登录状态 重定向到跟路径   新手四件套之一：重定向
            # 保存到session中,session是全局的
            session['name'] = username
            return redirect('/')
        else:
            return render_template('login.html', error='用户名或密码错误')  # 注意跟django的render区分，要模板渲染的数据，直接key=value传即可


@app.route('/')
def home():
    # 校验，登录成功，才能过来，不登录，重定向到登录页面
    if session.get('name'):  # 有值说明登录了，没有值说明没有登录
        return render_template('home.html',user_dict=USERS)
    else:
        return redirect('/login')


@app.route('/detail/<int:pk>')
def detail(pk):
    if session.get('name'):  # 有值说明登录了，没有值说明没有登录
        user_detail = USERS.get(pk)
        return render_template('detail.html', user=user_detail)
    else:
        return redirect('/login')


@app.route('/test')
def test():
    return jsonify([{'name':'lqz','age':19}])   # 只能序列化字典与列表
    # 不能序列化对象

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

-------------------------------------------

'''
# 学到的
    1 注册路由  app.route(路径,methods=[请求方式get，post])
    2 新手四件套：
        -render_template   渲染模板 跟django有区别
        -redirect  重定向
        -return 字符串 返回字符串
        -jsonify 返回json格式


    3 请求的request对象，是全局的，直接导入使用即可，在不同视图函数中不会混乱
        request.method  请求方式
        request.form   post请求的body体的内容转成了字典


    4 session 全局的，直接导入使用即可,一定要指定秘钥app.secret_key = 'asdfasdfa33aef3aefads'
        放值：session['name']='lqz'
        取值：session.get('name')


    5 模板的渲染
        -兼容django的dtl
        -更强大，可以加括号，字典可以.get  .values()   .items()
        -{% for %}


    6 转换器@app.route('/detail/<int:pk>')

'''

.
.
.
.
.
.
.
.
.
.
.
.

4 配置文件方式

# django 有个settings

# flask的所有配置都放在app中了，以后直接使用app对象，获取配置信息即可

# flask包里面有一个config.py文件，该文件里有个Config类与configAttribute类
# Config类继承了字典
    Flask类里面     config_class = Config    # 255行
                   self.config = self.make_config(instance_relative_config)   # 590行
                   def make_config(self, instance_relative = False):    # 817行
                       return self.config_class(root_path, defaults)
                   # 所以最后 self.config 对应的就是Config类产生的对象！！！

# 所以这也是为什么可以用app对象中括号往里放值，以及点from_pyfile，点from_object这些方法
# 因为这些方法都是在Config类里面有的方法！！！！

----------------------------------------------------
----------------------------------------------------

# flask 也有配置文件，但是它的使用方式多种：
from flask import Flask, request, render_template, redirect, session, jsonify

app = Flask(__name__)


# 设置的方式一：（测试用,直接写在app对象上面，只能设置这两个参数）
app.debug=True  # 调试模式，提示信息更详细，修改代码不需要重启，自动重启
app.secret_key='dasdfasdfasd'  # 秘钥

----------------------------

# 设置方式二:直接使用app.config 进行设置  app.config对应的就是一个字典对象
app.config['DEBUG'] = True
app.config['SECRET_KEY'] = 'sdfasdfasd'
app.config['hhh'] = 'heihei'  # 添加不存在的属性
print(app.config)  # 查看配置
print(app.config.get('hhh'))   # 也能正常取config里面的配置信息

----------------------------

# 方式三：使用py文件,在文件里面写DEBUG = True  SECRET_KEY = '00sdfasf0asdf' （也不常用）
# 往配置文件里面加属性，必须要大写才行！！  HAHAHA = 'heiheihei'  不然会报错！！！
app.config.from_pyfile("settings.py")
print(app.config)

----------------------------

# 方式四:常用方案，一个settings配置文件可以有多套配置，一套配置写在一个类里面
# 这样用哪个配置，就把哪个配置打开，不用就把黑掉就行了
# app.config.from_object('settings.DevelopmentConfig')  # 开发环境配置
# app.config.from_object('settings.ProductionConfig')   # 上线环境配置
# 不推荐上面的这种用字符串的方式！！！ 后续项目打包的成.exe文件的时候，会出问题！！！
# 建议这样老老实实的导入，配置！！！！
from settings import DevelopmentConfig,ProductionConfig
app.config.from_object(DevelopmentConfig)  # 开发环境配置
app.config.from_object(ProductionConfig)   # 上线环境配置

print(app.config)




----------------------------

# 其他：
# 方式五
# 通过环境变量配置，用的不多
# app.config.from_envvar("环境变量名称")

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

# 方式七
# 通过字典格式来配置
app.config.from_mapping({'DEBUG': True, 'HAHA': 'heihei'})
print(app.config)

----------------------------

@app.route('/login', methods=['GET', 'POST'])
def index():
    return 'hello web'


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

.
.
.
.

# 内置的配置字段，其他可以写自己的，比如 redis的连接地址，mysql的连接地址

	DEBUG
	SECRET_KEY
	SESSION_COOKIE_NAME   # session 的键名
	PERMANENT_SESSION_LIFETIME  # session的过期时间

----------------------------------------------------

# settings.py 文件
# DEBUG = True
# SECRET_KEY = '00sdfasf0asdf'
# HAHAHA = 'heiheihei'


class BASE(object):
    DEBUG = False


# 上线环境
class ProductionConfig(BASE):
    DATABASE_URI = 'mysql://user@localhost/foo'


# 开发环境
class DevelopmentConfig(BASE):
    DEBUG = True
    DATABASE_URI = 'localhost'

--------------------------------------------------

.
.
.
.
.
.
.
.
.
.

5 路由系统

5.1 路由本质

# django中配置路由 在urls.py 中, 在urlpatterns列表中, 写path

# flask是基于装饰器的，大部分都用装饰器来做，少量可以抽取到一个urls.py中

-----------------------------------------------------
-----------------------------------------------------

# 装饰器的本质是什么？    本质是：闭包函数
装饰器的作用是什么？   在不改变函数代码和调用方式的前提下，给函数添加新的功能

装饰器语法糖 @               python的特殊语法

@符号的作用是：  把装饰器函数名自动加括号调用，并将下面的被装饰的函数，当成参数
                传入到装饰器函数中，并把装饰器函数的返回值赋值给被装饰的函数名
                这样后面用被装饰的函数名加括号，实际上就变成了装饰器函数的返回值加括号了！！！

---------------------------------------------------

# 源码423行   rule就是路由规则就是我们写在route括号里的路由，其他的关键字参数比如methods等
# 都会被**接收最后组织成字典，赋值给options变量
    @setupmethod
    def route(self, rule: str, **options: t.Any) -> t.Callable[[T_route], T_route]:
        def decorator(f: T_route) -> T_route:
            endpoint = options.pop("endpoint", None)
            self.add_url_rule(rule, endpoint, f, **options)
            return f

        return decorator

# route函数就是典型的装饰器函数，里面一个闭包函数，并且返回了闭包函数的函数名
# f 就是路由装饰器下面的函数名
-----------------------------------------------------
-----------------------------------------------------

# 把装饰器函数名自动加括号调用，并将下面的被装饰的函数，当成参数，传入到装饰器函数中
# 并把装饰器函数的返回值赋值给被装饰的函数名

@app.route('/login')
def index():
    pass
# 本质是     index = app.route('/login')(index)  = decorator（index）
#                    app.route('/login')的执行结果是： decorator 函数名
# 所以最后 index = f   函数名加括号运行，实际就是f函数加括号运行

------------------------------------------------------

.
.
.
.
.
.

路由的装饰器源码分析

# app.route('/login')的执行结果是： decorator 函数名
	rule是路径
	其他参数都给了options



# 所以只要路由装饰器语法糖往被装饰的函数上一加，就会运行decorator（被装饰函数名）
# 运行函数 decorator(被装饰函数名)  执行函数里面的代码
def decorator(f):
    endpoint = options.pop("endpoint", None)      # 目前没有endpoint，是None
    self.add_url_rule(rule, endpoint, f, **options)  # 核心代码---添加路由的函数
    return f

    #  f是被装饰的index函数的函数名
    #  self就是Flask类实例化得到的app对象
    #  app对象中有个方法add_url_rule，这是在添加路由，
    #  实际上加路由装饰器的本质就是在执行该行代码！！！
------------------------------------------------------

.
.
.
.
.
.
.
.

不使用装饰器，自己注册路由,如何实现？？？

# 重要！！！！！！
# 可以不使用装饰器的方式，注册路由

app.add_url_rule('/', endpoint=None, view_func=home, methods=['GET'])
def home():
    return 'home'

# view_func参数对应要触发的函数名，第一个参数要传对应的路由！！！

# flask路由的本质是： app对象的add_url_rule函数，完成路由的注册


# add_url_rule 函数对应的就是django中的path，都是将路由与对应的函数名写在括号里！！！注册路由

------------------------------------------------------

.
.
.
.
.
.
.

5.2 路由参数 add_url_rule函数的参数

# rule             路由地址
# view_func        视图函数名称


# defaults = None    给视图函数传的默认值, 当URL中无参数，函数又需要该参数时，
    使用defaults = {'k': 'v'}为函数提供参数

# add_url_rule函数括号里面传了defaults = {'k': 'v'}后，
    视图函数括号里面就必须要写一个 k 形参  来接收v值！！！


# endpoint = None,     给路由起的别名，用于反向解析URL
# methods = None,    允许的请求方式，如：["GET", "POST"]



# defaults字典里写了k，对应的视图函数就必须写一个形参k去接收
app.add_url_rule('/', endpoint=None, view_func=home, methods=['GET'],defaults={'name':'lqz'})
def home(name):
    print(name)  # 结果就是   lqz
    return 'home'


# 对URL最后的 / 符号是否严格要求
strict_slashes = False    # 不严格要求，url最后带不带/ 都行

strict_slashes = True   # 完全和路由一致才能匹配上

----------------------------------------------

#重定向到指定地址
redirect_to = None,

'''
    @app.route('/index/<int:nid>', redirect_to='/home/<nid>')

    只要一访问index路径，直接重定向到home路径上去
'''

----------------------------------------------

# 需要记住的
    # rule       # 路由
    # view_func  # 视图函数名
    # defaults   # 给视图函数传默认值
    # endpoint   # 别名
    # methods    # 允许的请求方式

----------------------------------------------

.
.
.
.
.
.

5.3 转换器

# 不写转换器名字，默认数字与字符串都接收
@app.route('/<pk>',endpoint=None, view_func=home, methods=['GET'])
def home(pk):
    print(pk)
    return 'home'


# 其他的转换器，用法都一样
@app.route('/<int:pk>',endpoint=None, view_func=home, methods=['GET'])

 'string':           UnicodeConverter,
 'path':             PathConverter,  # 接收多个斜杠的这种路由
 'int':              IntegerConverter,

 'float':            FloatConverter,
 'uuid':             UUIDConverter,
 'any':              AnyConverter,

.
.
.
.
.