flask路由规则及正则转换器converter

版权声明：FatPuffer https://blog.csdn.net/qq_42517220/article/details/88693576

（1）查看所有路由

         我们可以通过app.url_map来查看当前项目下的所有 路由信息列表。

# coding:utf-8                                                              
                                                                             
from flask import Flask                                                     
                                                                            
# 创建flask应用                                                             
app = Flask(__name__)                                                       
                                                                             
@app.route('/')                                                             
def index():                                                                
    return 'hello Flask'                                                    
                                                                            
if __name__ == '__main__':                                                  
    # 通过url_map可以查看整个flask中的路由信息                              
    print(app.url_map)                                                      
    # 启动flask程序                                                         
    app.run() 

信息说明：

Map([<Rule '/' (HEAD, OPTIONS, GET) -> index>,
 	 <Rule '/static/<filename>' (HEAD, OPTIONS, GET) -> static>
   ])

我们可以看到目前有两个路由
第一个：是 /，即我们定义的跟路由，后面是他支持的请求方式（HEAD, OPTIONS, GET）对应视图函数为index。
第二个：是/static/filename，这是系统自定义的静态文件访问路由，支持的请求方式有（HEAD, OPTIONS, GET），对应static文件夹

（2）自定义请求方式POST

@app.route('/post', methods=['POST'])

# coding:utf-8                                                              
                                                                             
from flask import Flask                                                     
                                                                            
# 创建flask应用                                                             
app = Flask(__name__, static_url_path='/python')                                                       
                                                                             
@app.route('/')                                                             
def index():                                                                
    return 'hello Flask'                                                    

@app.route('/post', methods=['POST'])
def post_request():
	return 'post method'
                                                                           
if __name__ == '__main__':                                                  
    # 通过url_map可以查看整个flask中的路由信息                              
    print(app.url_map)                                                      
    # 启动flask程序                                                         
    app.run() 

可以看到我们增加了一个POST请求后，在路由列表中打印了出来，请求路由为/post，请求方式（POST, OPTIONS）对应视图函数为post_request，同时我们修改了静态文件访问前缀为python，在路由列表中也体现了出来，但其实际文件存放路径依然为ststic目录。

（3）验证我们定义的请求方式是生效


我们发现，当我们在浏览器中访问：127.0.0.1:5000/post，回车后提示我们请求方式不允许，因为直接通过浏览器请求，请求方式为GET，所以会被拒绝。当我们通过终端使用curl -X POST -i命令以POST请求方式访问该路由时，返回了post method信息，说明我们定义的POST请求方式没有问题。

（4）同一路由装饰多个视图函数

@app.route('/hello', methods=['GET'])
def hello():
	return 'hello 1'

@app.route('/hello', methods=['POST'])
def hello2():
	return 'hello 2'

说明：如果两个视图请求路径一致，且请求方式也一致，那么上面的视图将会把下面的视图覆盖。

（5）同一视图多个路由装饰器

@app.route('/hi')
@app.route('/hi2')
def hi():
	return 'hi flask'

（6）反向解析

使用redirect函数，找到要跳转视图的url路由，进行跳转。

from flask import Flask, redirect                                                     
                                                                            
# 创建flask应用                                                             
app = Flask(__name__)                                                       
                                                                             
@app.route('/')                                                             
def index():                                                                
    return 'hello Flask' 

@app.route('/login')
def login():
	url = '/'
	return redirect(url)

使用url_for，找到要跳转视图的视图函数，进行跳转（推荐使用）。

from flask import Flask, url_for                                                     
                                                                            
# 创建flask应用                                                             
app = Flask(__name__)                                                       
                                                                             
@app.route('/')                                                             
def index():                                                                
    return 'hello Flask' 

@app.route('/login')
def login():
	url = url_for('index')
	return redirect(url)

（7）提取路由参数

@app.route('/goods/<int:id>')
def goods_detail(id):
	return 'goods id is %d' % id

转化器
int	接收整形
float	同int，但是可以接受浮点型
path	和默认的相似，但也接受斜线

@app.route('/goods/<id>')
def goods_detail(id):
	return 'goods id is %d' % id

不加转换器，默认是普通字符串规则（除了/的字符）

（8）定义自己的转换器

（1）定义装换器

from werkzeug.routing import BaseConverter
 
class MobelConverter(BaseConverter):
	""""""
	def __init__(self, url_map):
		# 调用父类的初始化方法(python2中super()必须写参数)
		super(RegexConverter, self).__init__(url_map)
		# 将正则表达式的参数保存到对象属性中，flask会去使用这个属性来进行路由的正则匹配
		self.regex = r'1[34578]\d{9}'

（2）将自定义转换器添加到flask应用中

app.url_map.converters['mobile'] = MobelConverter

（3）在url中使用

@app.route('/send/<mobile:mobile>')
def send_msg(mobile):
	return 'send msg to %s' % mobile

（9）实现自己的万能转换器

（1）定义装换器

from werkzeug.routing import BaseConverter
 
class RegexConverter(BaseConverter):
	""""""
	def __init__(self, url_map, regex):
		# 调用父类的初始化方法(python2中super()必须写参数)
		super(RegexConverter, self).__init__(url_map)
		# 将正则表达式的参数保存到对象属性中，flask会去使用这个属性来进行路由的正则匹配
		self.regex = regex

（2）将自定义转换器添加到flask应用中

app.url_map.converters['re'] = RegexConverter

（3）在url中使用

@app.route("/send/<re(r'1[34578]\d{9}'):mobile>")
def send_msg(mobile):
	return 'send msg to %s' % mobile

（10）BaseConverter对象解析

from werkzeug.routing import BaseConverter
from flask import Flask                                                 
                                                                            
# 创建flask应用                                                             
app = Flask(__name__) 

class RegexConverter(BaseConverter):
	""""""
	def __init__(self, url_map, regex):
		# 调用父类的初始化方法(python2中super()必须写参数)
		super(RegexConverter, self).__init__(url_map)
		# 将正则表达式的参数保存到对象属性中，flask会去使用这个属性来进行路由的正则匹配
		self.regex = regex

		def to_python(self, value):
			print('to_python方法被调用 ')
			return value

		def to_url(self, value):
			pass

app.url_map.converters['re'] = RegexConverter

# 127.0.0.1:5000/send/18612345678
@app.route("/send/<re(r'1[34578]\d{9}'):mobile>")
def send_msg(mobile):
	return 'send msg to %s' % mobile

if __name__ == '__main__':                                                                                                       
    # 启动flask程序                                                         
    app.run() 

• to_python函数说明：

当我们访问路径127.0.0.1:5000/send/18612345678时，re(r'1[34578]\d{9}')匹配到的参数会先传递给函数to_python中的value参数，那么我们可以在to_python函数中对拿到的数据进行进一步处理，例如：类型转换，过滤等操作。

from werkzeug.routing import BaseConverter
from flask import Flask                                                 
                                                                            
# 创建flask应用                                                             
app = Flask(__name__) 

class RegexConverter(BaseConverter):
	"""自定义转换器"""
	def __init__(self, url_map, regex):
		# 调用父类的初始化方法(python2中super()必须写参数)
		super(RegexConverter, self).__init__(url_map)
		# 将正则表达式的参数保存到对象属性中，flask会去使用这个属性来进行路由的正则匹配
		self.regex = regex

		def to_python(self, value):
			"""使用自定义转换器时会被调用"""
			value = 'abcdefg'
			return value

		def to_url(self, value):
			pass

app.url_map.converters['re'] = RegexConverter

# 127.0.0.1:5000/send/18612345678
@app.route("/send/<re(r'1[34578]\d{9}'):mobile>")
def send_msg(mobile):
	return 'send msg to %s' % mobile

if __name__ == '__main__':                                                                                                       
    # 启动flask程序                                                         
    app.run() 

• to_value函数说明：

该函数主要用于url_for反向解析

from werkzeug.routing import BaseConverter
from flask import Flask, redirect, url_for                                                 
                                                                            
# 创建flask应用                                                             
app = Flask(__name__) 

class RegexConverter(BaseConverter):
	def __init__(self, url_map, regex):
		# 调用父类的初始化方法(python2中super()必须写参数)
		super(RegexConverter, self).__init__(url_map)
		# 将正则表达式的参数保存到对象属性中，flask会去使用这个属性来进行路由的正则匹配
		self.regex = regex

		def to_python(self, value):
			"""使用自定义转换器时会被调用"""
			return value

		def to_url(self, value):
			"""使用url_for时会被调用"""
			return value

app.url_map.converters['re'] = RegexConverter

# 127.0.0.1:5000/send/18612345678
@app.route("/send/<re(r'1[34578]\d{9}'):mobile>")
def send_msg(mobile):
	return 'send msg to %s' % mobile

@app.route('/login')
def login():
	# /send/13673483485
	url = url_for('send_msg', mobile='13673483485')
	return redirect(url)

if __name__ == '__main__':                                                                                                       
    # 启动flask程序                                                         
    app.run() 

说明： 当用户访问127.0.0.1::5000/login时，会重定向到send_msg视图对应的url，而该路由需要接参数（手机号码），那么我们在进行反向解析时就需要传递该参数，而我们传递的参数首先会被传递给to_url函数中的value参数。

from werkzeug.routing import BaseConverter
from flask import Flask, redirect, url_for                                                 
                                                                            
# 创建flask应用                                                             
app = Flask(__name__) 

class RegexConverter(BaseConverter):
	def __init__(self, url_map, regex):
		# 调用父类的初始化方法(python2中super()必须写参数)
		super(RegexConverter, self).__init__(url_map)
		# 将正则表达式的参数保存到对象属性中，flask会去使用这个属性来进行路由的正则匹配
		self.regex = regex

		def to_python(self, value):
			"""使用自定义转换器时会被调用"""
			return value

		def to_url(self, value):
			"""使用url_for时会被调用"""
			print('url_for方法被调用')
			return '15811111111'

app.url_map.converters['re'] = RegexConverter

# 127.0.0.1:5000/send/18612345678
@app.route("/send/<re(r'1[34578]\d{9}'):mobile>")
def send_msg(mobile):
	return 'send msg to %s' % mobile

@app.route('/login')
def login():
	# /send/13673483485
	url = url_for('send_msg', mobile='13673483485')
	return redirect(url)

if __name__ == '__main__':                                                                                                       
    # 启动flask程序                                                         
    app.run()