Enrutamiento detallado del matraz

Introducción al enrutamiento

El uso de enrutamiento en el programa de matraz, que llamamos la ruta de registro, es registrar la ruta utilizando el decorador app.route () proporcionado por la instancia del programa.

@app.route('/student_list/')
def student_list():
    return 'students'

La esencia y los parámetros del enrutamiento

from flask import Flask, url_for, redirect
 
app = Flask(__name__)
 
 
def index(nid):
    print(nid, type(nid))
    return 'ojbk'
 
 
# 指定类型为int或者string类型
app.add_url_rule('/index/<int:nid>', view_func=index, endpoint='index1', methods=['post', 'get'])
# app.route的本质就在执行add_url_rule这个中的rule是路由，endpoint是路由别名，view_func是响应函数
# app.add_url_rule('/index/<int:nid>', view_func=index, methods=['post', 'get'])
 
 
@app.route('/login', methods=['get', 'post'])
def login():
    # 用endpoint取路由要用url_for 在flask中导入，也就是反向解析
    print(url_for("index1"))
    return redirect(url_for("index1"))  # url_for通过路由的别名反向解析出来路由的url
 
 
# 路由参数；methods，可以控制该方法能有哪些请求方式可以访问
app.add_url_rule("/index", endpoint="index1", view_func=index, methods=["POST", "GET"])
# 路由参数：有名分组,app.add_url_rule("/index/<int:nid>"响应函数必须用nid来接收
 
if __name__ == '__main__':
    app.run()
 
'''
总结：
1 @app.route("/login") 的本质是app.add_url_rule("/login",view_func=login)，所以我们就可以用这两个方式来添加路由
2 路由的参数，
    2.1 endpoint,做是反向解析，如果上面添加路由的时候，没有传递endpoint就是使用响应函数的函数名，反向解析用url_for（），做解析，这个url_for必须在flask里面导入
    2.2 methods=["POST","GET"],该参数控制路由允许哪些请求方法访问，如果不传，默认只能GET方法
    2.3 路由以及路由路由转化器。"/index/<int:nid>",<参数的类型：用哪个变量来接收>，响应函数中的形参的名字必须转化器中一致。
 
'''

Enrutamiento dinámico

http://127.0.0.1:5000/student_list/2/

Hay una parte variable en la ruta para lograr el propósito de pasar parámetros, lo llamamos enrutamiento dinámico

@app.route('/student_list/<student_id>/')
def student_list(student_id):
    return '学生{}号的信息'.format(student_id)

Filtrado de enrutamiento dinámico

Puede limitar el tipo de datos del parámetro, por ejemplo, student_id debe ser un tipo entero

http://127.0.0.1:5000/student_list/2/

@app.route('/student_list/<int:student_id>/')
def article_detail(student_id):
    print(student_id, type(student_id))
    return '学生{}号的信息'.format(student_id)

Existen principalmente varios tipos de filtrado:

　　string: El tipo de datos predeterminado, para recibir una cadena sin barra "/"

　　int: Entero

　　float: Punto flotante

　　path: Similar al tipo de cadena, pero acepta barras diagonales, como: puede aceptar parámetros / aa / bb / cc / multiple juntos

　　uuid: Solo acepta cadenas en formato uuid,

✔ Consejo: uuid es la única cadena en el universo

Las restricciones anteriores están en el siguiente formato , int en el ejemplo se puede reemplazar por string，float,path,uuid:

@app.route('/student_list/<int:student_id>/')
def article_detail(student_id):
    return '学生{}号的信息'.format(student_id)

any: Se pueden especificar varias rutas, como en el siguiente ejemplo

El nombre de la variable de url_path lo define usted mismo

@app.route('/<any(student,class):url_path>/<id>/')
def item(url_path, id):
    if url_path == 'student':
        return '学生{}详情'.format(id)
    else:
        return '班级{}详情'.format(id)

¿Cuáles son los escenarios aplicables de enrutamiento dinámico?

Si desea aumentar la exposición del sitio web, puede considerar el uso de enrutamiento dinámico, ya que la ruta se utiliza como parámetro, el algoritmo del motor de búsqueda lo definirá como una página estática, no cambiará con frecuencia, lo que es beneficioso para la optimización del motor de búsqueda. Pero si se trata del sistema de gestión interno de la empresa, no hay necesidad de utilizar enrutamiento dinámico, ya que el sistema interno no requiere exposición.

Palabras clave :

• Arriba aceptamos el parámetro utilizando el formulario de ruta (ruta), esta forma de transmisión de parámetros se denomina transmisión de parámetros de enrutamiento dinámico, que conduce a la optimización de los motores de búsqueda.

Uso de url_for ()

Utilice la función de que el nombre de la función de vista generalmente no cambia, de acuerdo con el nombre de la función de vista, para obtener la URL de forma dinámica y precisa, a fin de facilitar el desarrollo y el uso.

url_for('视图函数名字')   # 输出该视图函数url

Ejemplos específicos:

from flask import Flask,url_for
 
app = Flask(__name__)
app.config.update(DEBUG=True)
 
@app.route('/')
def demo1():
    print(url_for("book"))  # 注意这个引用的是视图函数的名字 字符串格式
    print(type(url_for("book")))
 
    return url_for("book")
 
 
@app.route('/book_list/')
def book():
 
    return 'flask_book'
 
if __name__ ==  "__main__":
    app.run()

¿Cómo maneja url_for las funciones de vista dinámica?

Si desea obtener una ruta dinámica, debe asignar un valor a la parte de ruta dinámica en forma de argumentos de palabras clave. Tenga en cuenta que a la parte de ruta dinámica se le debe asignar un valor.

Caso:

@app.route('/demo2/')
def demo2():
 
    student_url = url_for('student', id=5, name='mark') # id 就是动态path的key 必须赋值，                                                         # name 将作为查询字符串传入
    print(student_url)
 
    return student_url
 
 
@app.route('/student/<int:id>/')
def student(id):
    return 'student {}'.format(id)

Salida de consola:

Salida del navegador:

url_para saber cómo agregar una cadena de consulta para url

Si desea deletrear la cadena de consulta detrás de la ruta, póngala en url_for () como parámetro en forma de argumento de palabra clave, deletreará automáticamente la ruta

Caso:

@app.route('/demo3/')
def demo3():
    school_url = url_for('school', school_level='high', name='college')
    # 具体要拼接的查询参数 以关键字实参的形式写在url_for里
    print(school_url)
 
    return school_url
 
@app.route('/school/')
def school():
 
    return 'school message'

Salida de consola:

Salida del navegador:

Convertidor personalizado (sin foco)

# 非重点
#1 写类，继承BaseConverter
#2 注册：app.url_map.converters['regex'] = RegexConverter
# 3 使用：@app.route('/index/<regex("\d+"):nid>')  正则表达式会当作第二个参数传递到类中
 
from flask import Flask, url_for
from werkzeug.routing import BaseConverter
 
app = Flask(import_name=__name__)
 
class RegexConverter(BaseConverter):
    """
    自定义URL匹配正则表达式
    """
    def __init__(self, map, regex):
        super(RegexConverter, self).__init__(map)
        self.regex = regex
 
    def to_python(self, value):
        """
        路由匹配时，匹配成功后传递给视图函数中参数的值
        """
        print("to_python",value,type(value))
        return int(value)+1
 
    def to_url(self, value):
        """
        使用url_for反向生成URL时，传递的参数经过该方法处理，返回的值用于生成URL中的参数
        """
        val = super(RegexConverter, self).to_url(value)
        return val+"222"
 
# 添加到flask中
app.url_map.converters['regex'] = RegexConverter
# 正则匹配处理结果，要交给to_python，to_python函数可以对匹配处理结果做处理
@app.route('/index/<regex("\d+"):nid>')
def index(nid):
    print("index",nid,type(nid))
    print(url_for('index', nid='888'))
    return 'Index'
 
if __name__ == '__main__':
    app.run()

Resumen:

1 导入from werkzeug.routing import BaseConverter
2 我写个继承BaseConverter。实现3个方法，def __init__ , def to_python , def to_url
3 将上面的类注册到app.url_map.converters['regex'] = RegexConverter中
4 然后就可以在路由转化器中使用3中的regex（"传正则"）
5 当路由被访问以后。regex（"传正则"）会匹配结果，把结果传递to_python，我们可以进行再次处理，to_python处理好的结果，会传递给响应函数的形参
6 当用url做反向解析的时候，传递给路由转化器的参数，会经过to_url，进行处理。处理以后，在拼接到路由。