flask快速上手

1 flask 介绍
2 显示用户小案例
3.登录认证装饰器
4、配置文件
5 路由系统

1 flask 介绍

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

fastapi

 import time
from fastapi import FastAPI
app = FastAPI()
@app.get('/')
async def index():
    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 home():
    time.sleep(2)
    return {'code': 100, 'msg': 'order'}

flask

 from flask import Flask
app = Flask(__name__)
@app.route('/', methods=['GET'])
def index():
    return 'hello world'
if __name__ == '__main__':
    app.run()

wsgiref

 # 服务 wsgi协议的web服务器，django的web服务用的就是它
# 相当于个socket服务端，可以接收客户端发送过来的请求，处理，返回给客户端
 
 
from wsgiref.simple_server import make_server
 
def mya(environ, start_response):
    print(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]
 
if __name__ == '__main__':
    myserver = make_server('', 8011, mya)# 监听本地的8011端口，当请求来了，就会执行    mya(),传入两个参数，一个是environ:http请求转成python的字典，一个是start_response：响应对象
    print('监听8010')
    myserver.serve_forever()

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('localhost', 4000, hello)

2 显示用户小案例

 from flask import Flask, render_template, request, redirect, session
 
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')
def index():
    # 判断它是否登录，如果登录，显示用户信息
    if session.get('username'):
        return render_template('index.html',users=USERS)
    else:
        return redirect('/login')
 
 
 
@app.route('/detail/<int:pk>')
def detail(pk):
    user=USERS.get(pk)
    return render_template('detail.html',user=user)
 
if __name__ == '__main__':
    app.run()
 
 
 
'''
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，并且它更强大，可以加括号执行
 
'''

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>

index.html

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

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>

3.登录认证装饰器

 # 1 装饰器的本质原理
	-# 类装饰器：1 装饰类的装饰器   2 类作为装饰器
# 2 装饰器使用位置，顺序
# 3 flask路由下加装饰器，一定要加endpoint
	-如果不指定endpoint，反向解析的名字都是函数名，不加装饰器没有问题，就是正常函数index，detail
    -如果加了装饰器---》index，detail都变成了inner---》反向解析的名字都是函数名inner，报错了
    -wrapper装饰器----》把它包的更像---》函数名变成了原来函数的函数名
# 装饰器：是什么？ 装饰器的本质是闭包【函数】
# 装饰器：作用？ 在不改变程序源代码和调用方式的基础上，为程序增加新功能
# 装饰器:本质,被装饰以后，在执行被装饰的函数，其实执行不是之前的函数了，所有才加入了新功能
# 装饰器：语法糖  @    python的特殊语法，它有特殊作用----》把被装饰的函数(装饰器下面的函数)，当参数传入装饰器，并把装饰器的执行结果赋值给被装饰的函数

 def add(func):
    print(func)
 
 
# 类装饰器：1 装饰类的装饰器   2 类作为装饰器
 
# add 一定是个函数吗？
# 放个对象
class Person:
    def __call__(self, func):
        def inner(*args, **kwargs):
 
            res = func(*args, **kwargs)
            return res
        return inner
 
p = Person()
 
# @add  # test=add(test)--->test变成了None
@p  # test=p(test)  # p() 会触发__call__--->Person的 __call__(func)--->返回inner，以后test就是inner---》test(参数)--》执行的是inner
def test():
    print("test")
 
print(test)
 
def auth(func):
    def inner(*args, **kwargs):
        res = func(*args, **kwargs)  # 真正的执行视图函数，执行视图函数之，判断是否登录
        res.name='lqz'
        return res
    return inner
 
@auth     # Foo=auth(Foo)
class Foo():
    pass
 
f=Foo()  # Foo()  调用 ---》inner()--->类实例化得到对象，返回，以后f就是Foo的对象，但是可以里面多了属性或方法
print(f)
print(f.name)
 
 
 
### 有参装饰器--->额外为被装饰的函数传参数
@auth(10)     # Foo=auth(10)(Foo)
class Foo():
    pass

4、配置文件

 from flask import Flask, request, render_template, redirect, session,jsonify
 
app = Flask(__name__)
# flask的所有配置都放在app中了，以后直接使用app对象，获取配置信息即可
# 设置的方式一：（测试用）
# app.debug=True  # 调试模式，提示信息更详细，修改代码不需要重启，自动重启
# app.secret_key='dasdfasdfasd'  # 秘钥，只能 放debug和secret_key
## 设置方式二:直接使用app.config设置
# app.config['DEBUG']=True
# app.config['SECRET_KEY']='sdfasdfasd'
# print(app.config)
 
## 方式三：使用py文件（不常用）
# app.config.from_pyfile("settings.py")
# print(app.config)
## 方式四:常用的，使用类的方式
# app.config.from_object('settings.DevelopmentConfig')
# app.config.from_object('settings.ProductionConfig')
# print(app.config)
### 其他：
#通过环境变量配置
# app.config.from_envvar("环境变量名称")
# json
# app.config.from_json("json文件名称")
# JSON文件名称，必须是json格式，因为内部会执行json.loads
 
# 字典格式---》配置中心
# app.config.from_mapping({'DEBUG': True})
 
 
@app.route('/login', methods=['GET', 'POST'])
def index():
    return 'hello web'
 
if __name__ == '__main__':
    app.run()

5 路由系统

5.1 路由本质

 # django中配置路由 在urls.py 中，写path ，写在 列表中
# flask是基于装饰器的，大部分都用装饰器来做，少量可以抽取到一个urls.py种
 
 
 
 
# 路由的装饰器源码分析
	# 咱们这样写
    @app.route('/login')
    def index():
        pass
    
    #本质是---》index=app.route('/login')(index)
    
    # app.route('/login')的执行结果 decorator 函数
    	-rule是路径
        -其他参数都给了options
    # 然后 decorator(index)--->在执行
    		# f是index
    		endpoint = options.pop("endpoint", None) # 目前没有endpoint，是None
            # 核心，本质--》self就是实例化得到的app对象，flask对象
            # app对象中有个方法add_url_rule，这是在添加路由
            # 不使用装饰器，自己注册路由
            self.add_url_rule(rule, endpoint, f, **options)
            return f
        
        
    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
# 可以不使用装饰器的方式，注册路由
	app.add_url_rule('/', endpoint=None, view_func=home, methods=['GET'])
    
    
# flask路由的本质是app对象的add_url_rule完成路由的注册

5.2 路由参数add_url_rule

 # rule             URL规则
# view_func        视图函数名称
# defaults = None  默认值, 当URL中无参数，函数需要参数时，使用defaults = {'k': 'v'}为函数提供参数
# endpoint = None, 路径的别名，名称，用于反向解析URL，即： url_for('名称')
# methods = None, 允许的请求方式，如：["GET", "POST"]
 
 
#对URL最后的 / 符号是否严格要求
strict_slashes = None
    '''
        @app.route('/index', strict_slashes=False)
        #访问http://www.xx.com/index/ 或http://www.xx.com/index均可
        @app.route('/index', strict_slashes=True)
        #仅访问http://www.xx.com/index
    '''
 
#重定向到指定地址
redirect_to = None, 
    '''
        @app.route('/index/<int:nid>', redirect_to='/home/<nid>')
    '''
    
    
 # 需要记住的
    # rule  
    # view_func   
    # defaults
    # endpoint
    # methods

5.3 转换器

  'default':          UnicodeConverter,
 'string':           UnicodeConverter,
 'any':              AnyConverter,
 'path':             PathConverter,
 'int':              IntegerConverter,
 'float':            FloatConverter,
 'uuid':             UUIDConverter,
    
 # 了解：让路由支持正则（忽略掉）

上一篇selenium、xpath、打码平台

下一篇数据库三大范式是什么、mysql有哪些索引类型，分别有什么作用、事务的特性和隔离级别

本文作者：岳宗柯

本文链接：https://www.cnblogs.com/yuezongke/p/17594351.html

posted @ 2023-07-31 19:51 岳宗柯阅读(41) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· flask入门

· flask之cbv源码分析，模板，请求与响应，session和源码分析，闪现，请求扩展

· flask介绍

· flask简介，flask快速使用，登录，显示用户信息小案例，配置文件方式，路由系统

· flask基本使用

阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 别再用vector＜bool＞了！Google高级工程师：这可能是STL最大的设计失误
· 单元测试从入门到精通
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）

Python学习之旅

别让世界左右你的情绪，别让情绪影响你的理性！

flask快速上手

1 flask 介绍

fastapi

flask

wsgiref

Werkzeug

2 显示用户小案例

3.登录认证装饰器

4、配置文件

5 路由系统

5.1 路由本质

5.2 路由参数add_url_rule

5.3 转换器

公告

常用链接

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论

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

	# Flask 框架
	-pip3 install flask

	import time
	from fastapi import FastAPI
	app = FastAPI()
	@app.get('/')
	async def index():
	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 home():
	time.sleep(2)
	return {'code': 100, 'msg': 'order'}

	from flask import Flask
	app = Flask(__name__)
	@app.route('/', methods=['GET'])
	def index():
	return 'hello world'
	if __name__ == '__main__':
	app.run()

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


	from wsgiref.simple_server import make_server

	def mya(environ, start_response):
	print(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]

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

	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('localhost', 4000, hello)

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

	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')
	def index():
	# 判断它是否登录，如果登录，显示用户信息
	if session.get('username'):
	return render_template('index.html',users=USERS)
	else:
	return redirect('/login')



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

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



	'''
	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，并且它更强大，可以加括号执行

	'''

	<!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 类作为装饰器
	# 2 装饰器使用位置，顺序
	# 3 flask路由下加装饰器，一定要加endpoint
	-如果不指定endpoint，反向解析的名字都是函数名，不加装饰器没有问题，就是正常函数index，detail
	-如果加了装饰器---》index，detail都变成了inner---》反向解析的名字都是函数名inner，报错了
	-wrapper装饰器----》把它包的更像---》函数名变成了原来函数的函数名
	# 装饰器：是什么？装饰器的本质是闭包【函数】
	# 装饰器：作用？在不改变程序源代码和调用方式的基础上，为程序增加新功能
	# 装饰器:本质,被装饰以后，在执行被装饰的函数，其实执行不是之前的函数了，所有才加入了新功能
	# 装饰器：语法糖 @ python的特殊语法，它有特殊作用----》把被装饰的函数(装饰器下面的函数)，当参数传入装饰器，并把装饰器的执行结果赋值给被装饰的函数

	def add(func):
	print(func)


	# 类装饰器：1 装饰类的装饰器 2 类作为装饰器

	# add 一定是个函数吗？
	# 放个对象
	class Person:
	def __call__(self, func):
	def inner(args, *kwargs):

	res = func(args, *kwargs)
	return res
	return inner

	p = Person()

	# @add # test=add(test)--->test变成了None
	@p # test=p(test) # p() 会触发__call__--->Person的 __call__(func)--->返回inner，以后test就是inner---》test(参数)--》执行的是inner
	def test():
	print("test")

	print(test)

	def auth(func):
	def inner(args, *kwargs):
	res = func(args, *kwargs) # 真正的执行视图函数，执行视图函数之，判断是否登录
	res.name='lqz'
	return res
	return inner

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

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



	### 有参装饰器--->额外为被装饰的函数传参数
	@auth(10) # Foo=auth(10)(Foo)
	class Foo():
	pass

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

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

	# 设置的方式一：（测试用）
	# app.debug=True # 调试模式，提示信息更详细，修改代码不需要重启，自动重启
	# app.secret_key='dasdfasdfasd' # 秘钥，只能放debug和secret_key

	## 设置方式二:直接使用app.config设置
	# app.config['DEBUG']=True
	# app.config['SECRET_KEY']='sdfasdfasd'
	# print(app.config)


	## 方式三：使用py文件（不常用）
	# app.config.from_pyfile("settings.py")
	# print(app.config)

	## 方式四:常用的，使用类的方式
	# app.config.from_object('settings.DevelopmentConfig')
	# app.config.from_object('settings.ProductionConfig')
	# print(app.config)

	### 其他：
	#通过环境变量配置
	# app.config.from_envvar("环境变量名称")

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


	# 字典格式---》配置中心
	# app.config.from_mapping({'DEBUG': True})


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

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

	# django中配置路由在urls.py 中，写path ，写在列表中
	# flask是基于装饰器的，大部分都用装饰器来做，少量可以抽取到一个urls.py种




	# 路由的装饰器源码分析
	# 咱们这样写
	@app.route('/login')
	def index():
	pass

	#本质是---》index=app.route('/login')(index)

	# app.route('/login')的执行结果 decorator 函数
	-rule是路径
	-其他参数都给了options
	# 然后 decorator(index)--->在执行
	# f是index
	endpoint = options.pop("endpoint", None) # 目前没有endpoint，是None
	# 核心，本质--》self就是实例化得到的app对象，flask对象
	# app对象中有个方法add_url_rule，这是在添加路由
	# 不使用装饰器，自己注册路由
	self.add_url_rule(rule, endpoint, f, **options)
	return f


	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
	# 可以不使用装饰器的方式，注册路由
	app.add_url_rule('/', endpoint=None, view_func=home, methods=['GET'])


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

	# rule URL规则
	# view_func 视图函数名称
	# defaults = None 默认值, 当URL中无参数，函数需要参数时，使用defaults = {'k': 'v'}为函数提供参数
	# endpoint = None, 路径的别名，名称，用于反向解析URL，即： url_for('名称')
	# methods = None, 允许的请求方式，如：["GET", "POST"]


	#对URL最后的 / 符号是否严格要求
	strict_slashes = None
	'''
	@app.route('/index', strict_slashes=False)
	#访问http://www.xx.com/index/ 或http://www.xx.com/index均可
	@app.route('/index', strict_slashes=True)
	#仅访问http://www.xx.com/index
	'''

	#重定向到指定地址
	redirect_to = None,
	'''
	@app.route('/index/<int:nid>', redirect_to='/home/<nid>')
	'''


	# 需要记住的
	# rule
	# view_func
	# defaults
	# endpoint
	# methods

	'default': UnicodeConverter,
	'string': UnicodeConverter,
	'any': AnyConverter,
	'path': PathConverter,
	'int': IntegerConverter,
	'float': FloatConverter,
	'uuid': UUIDConverter,

	# 了解：让路由支持正则（忽略掉）