[Python] framework de matraz para aprender el uso básico del marco de matraz

¿Qué es el marco del matraz?

Flask es un marco web ligero para crear aplicaciones web. Basado en el lenguaje de programación Python y el kit de herramientas Werkzeug, proporciona una API fácil de usar que facilita la creación de aplicaciones web y API RESTful.

Características del matraz

• Ligero: el marco Flask es muy liviano, la base de código es pequeña y es fácil de aprender y usar.
• Flexible: Flask proporciona muchos complementos y extensiones para crear aplicaciones web de manera flexible según sea necesario.
• Fácil de ampliar: el marco Flask es fácilmente ampliable y se pueden agregar muchas características personalizadas.
• Motor de plantillas: Flask proporciona el motor de plantillas Jinja2, que puede crear fácilmente páginas dinámicas.
• ORM: Flask proporciona SQLAlchemy ORM para interactuar fácilmente con las bases de datos.
• API RESTful: el marco Flask proporciona la extensión Flask-RESTful para crear fácilmente API RESTful.
• Mecanismo de complemento: Flask proporciona un mecanismo de complemento enriquecido, que puede agregar funciones personalizadas según sea necesario.

Ventajas del marco del matraz

• Facilidad de uso: el marco Flask es fácil de usar y tiene bajos costos de aprendizaje, lo que lo hace adecuado para crear rápidamente aplicaciones web.
• Gran flexibilidad: Flask proporciona muchas extensiones y complementos, que pueden crear aplicaciones web de manera flexible según las necesidades.
• Facilidad de extensibilidad: el marco Flask es fácilmente extensible y se pueden agregar muchas funciones personalizadas.
• Potente motor de plantillas: Flask proporciona el motor de plantillas Jinja2, que puede crear fácilmente páginas dinámicas.
• Potente ORM: Flask proporciona SQLAlchemy ORM para interactuar fácilmente con las bases de datos.
• Compatibilidad con API RESTful: el marco Flask proporciona la extensión Flask-RESTful para crear fácilmente API RESTful.
• Complementos enriquecidos: Flask proporciona un mecanismo de complemento enriquecido, que puede agregar funciones personalizadas según sea necesario.

En resumen, el marco Flask es un marco web que es liviano, flexible, fácil de expandir, un potente motor de plantillas, ORM, compatible con API RESTful y un mecanismo de complemento enriquecido, y puede ayudar a los desarrolladores a crear rápidamente aplicaciones web de alta calidad.

Uso básico del marco del matraz

El marco de trabajo del matraz puede construir fácilmente el programa de servidor más básico, simplemente ejecute el siguiente código:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return "hello world"

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

Esta pieza de código primero importa la clase Flask en la biblioteca de matraces. La instancia de esta clase se convertirá en nuestra aplicación WSGI. app es la aplicación instanciada, y luego usa la clase de decoración para hacer que la aplicación web procese la solicitud cuya información de solicitud es " /". .

Resultado de ejecución:

abra el enlace dado:

encontrará que la página devuelve la cadena de hola mundo debajo de la URL, lo que indica que se ha creado la aplicación web del marco de trabajo de matraz más simple.

Nota: 127.0.0.1 y 0.0.0.0 son direcciones locales y 5000 es el número de puerto

Enrutamiento, variables y reglas de URL

enrutamiento

Una ruta es una página o URL a la que saltar en una aplicación web. En Flask, las rutas se definen mediante la función route().

Por ejemplo, el siguiente código:

from flask import Flask
app = Flask(__name__)
# 路由

@app.route('/')
def index():
    return "hello world!"

@app.route('/hello/<name>')
def home(name):
    return "hello " + name

@app.route('/blg/<int:postID>')
def postid(postID):
    return postID

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

Si accede al directorio raíz en el puerto 5000:

Si visitas hola/xiaoming:

variable

Las variables son un tipo especial de datos que se utilizan en el enrutamiento. Se pueden pasar para ver funciones en parámetros de ruta. Hay varios tipos de variables en el marco Flask, que incluyen:

• solicitud: el objeto utilizado para manejar las solicitudes de los clientes.
• sesión: un objeto utilizado para almacenar datos de sesión.
• ruta: Una variable utilizada para identificar una ruta específica.

Para usar variables en las rutas de Flask, simplemente colóquelas en cadenas de variables y consúltelas en las funciones de vista. Por ejemplo, para definir una variable llamada /usuarios/ en la URL, podría usar el siguiente código:

from flask import Flask, render_template  
  
app = Flask(__name__)  
  
@app.route('/users/<name>')  
def users(name):  
    return render_template('users.html', users=[name])

El código anterior primero importa la biblioteca Flask, crea una instancia de aplicación y define una variable llamada /usuarios/ en la función app.route(). Esta variable tiene un nombre de variable llamado. En la plantilla users.html, puede usar { { nombre }} para hacer referencia a esta variable.

reglas de URL

Las reglas de URL se refieren a algunos caracteres especiales que se utilizan en las URL. Se pueden usar para especificar cómo se manejan las solicitudes, por ejemplo:

• /usuarios: maneja todas las solicitudes cuya URL comienza con /usuarios.
• /usuarios/: Maneja todas las solicitudes cuya URL comienza con /usuarios/.
• /usuarios//: Maneja todas las solicitudes cuya URL comienza con /usuarios//.

Para usar reglas de URL en una ruta de Flask, simplemente use el prefijo y el sufijo correspondientes en los parámetros de la ruta. Por ejemplo, para definir una variable llamada /usuarios// en la URL, podría usar el siguiente código:

from flask import Flask, render_template  
  
app = Flask(__name__)  
  
@app.route('/users/<name>/<sub-path>')  
def users(name, sub_path):  
    return render_template('users.html', users=[name], sub_path=sub_path)

El código anterior primero importa la biblioteca Flask, crea una instancia de la aplicación y define una variable llamada /users/<name>/<sub-path> en la función app.route(). Esta variable tiene una variable llamada nombre y una variable llamada sub_ruta. En la plantilla users.html, puede usar { { sub_path }} para hacer referencia a esta variable. Tenga en cuenta que se utilizan diferentes tipos de variables y parámetros de enrutamiento para distinguir diferentes solicitudes.

plantilla para matraz

from flask import Flask,render_template

app = Flask(__name__)

@app.route('/')
def index():
    return render_template('index.html')

if __name__ == '__main__':
    app.run(debug=True,threaded=True)

Después de ejecutar este código, el servidor buscará el archivo index.html del directorio de plantillas del archivo y lo mostrará en la página.

<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport"
          content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <h1>Nihao</h1>
</body>
</html>

Este es index.html

resultado de la operación:

Flask.render_template es la función principal de Flask para representar plantillas. Esta función toma una cadena de plantilla como argumento y la representa como HTML.

El siguiente es el uso básico de Flask.render_template:

from flask import Flask, render_template  
  
app = Flask(__name__)  
  
@app.route('/')  
def index():  
    return render_template('index.html', name='World')  
  
@app.route('/hello')  
def hello():  
    name = 'John'  
    return render_template('hello.html', name=name)

Definimos dos funciones de enrutamiento índice y hola, que reciben una cadena de plantilla como parámetro. En la función de índice, establecemos la variable de nombre en 'Mundo' y la pasamos como argumento a la función render_template para representar la plantilla. En la función hola, establecemos la variable de nombre en 'John' y la pasamos como argumento a la función render_template para representar la plantilla.

Cuando ejecutamos la aplicación Flask, cargará las plantillas index.html y hello.html y las representará en el HTML correspondiente.

Al renderizar una plantilla, Flask interpolará la variable en la cadena de la plantilla y la pasará como argumento a la función render_template. Cuando se procesa la plantilla, Flask insertará estas variables como parámetros en el HTML y devolverá la cadena HTML resultante.

Archivos estáticos, redirecciones y errores

En Flask, los archivos estáticos, las redirecciones y el manejo de errores son conceptos muy importantes que juegan un papel vital en el correcto funcionamiento de una aplicación. Sus escenarios de implementación y aplicación en Flask se discutirán en detalle a continuación.

• Archivos estáticos
  Los archivos estáticos son archivos almacenados en el servidor, generalmente utilizados para almacenar datos y recursos. En Flask, los archivos estáticos generalmente se usan para almacenar información de configuración de aplicaciones, registros, hojas de estilo, etc.

Para usar archivos estáticos, debe crear una carpeta en su aplicación Flask para almacenar los archivos estáticos. Luego, en el archivo principal de la aplicación, use la función url_for() para hacer referencia al archivo estático. Por ejemplo:

from flask import Flask, render_template  
  
app = Flask(__name__)  
  
@app.route('/')  
def index():  
    return render_template('index.html', name='World')  
  
if __name__ == '__main__':  
    # 创建静态文件夹  
    app.config['UPLOAD_FOLDER'] = 'static'  
  
    # 引用静态文件  
    static_folder = '../static'  
    app.url_for('static', filename=static_folder)

En este código, creamos una carpeta llamada estática en la carpeta principal de la aplicación y luego usamos la función url_for() en la función de índice de la aplicación para hacer referencia al archivo estático. De esta forma, cuando la aplicación se está ejecutando, los archivos estáticos se cargan automáticamente y se muestran en el navegador.

• Redirección La
  redirección es el proceso de redirigir a un usuario a otra ubicación. En Flask, la redirección se divide principalmente en dos tipos: ① redirección estática (redirección de URL): redirige al usuario a otra carpeta estática; ② redirección dinámica (redirección de URL): redirige al usuario a otra página.

Para redireccionamientos estáticos, simplemente cree los archivos correspondientes en la carpeta estática. Para la redirección dinámica, debe usar el enrutador Flask para lograrlo. Aquí hay un ejemplo de una redirección dinámica:

from flask import Flask, render_template, redirect, url_for, request, send_from_directory  
  
app = Flask(__name__)  
app.config['UPLOAD_FOLDER'] = 'static'  
  
@app.route('/users', methods=['GET', 'POST'])  
def users():  
    if request.method == 'POST':  
        # 获取新用户信息并进行处理  
        new_user = request.form['new_user']  
        # 进行重定向操作  
        url = url_for('user', username=new_user)  
        return redirect(url)  
    else:  
        # 显示列表页面  
        return render_template('users.html')

cookies y sesiones

En el marco Flask, las cookies y las sesiones se utilizan para almacenar y administrar los datos del usuario.

Las cookies son una forma común de almacenar datos del usuario y, por lo general, se utilizan para almacenar algunos datos simples en las sesiones del usuario, como las preferencias del usuario, el estado de inicio de sesión, etc. Flask usa SessionCookieJar de forma predeterminada para administrar las cookies.

Cuando un usuario visita una aplicación Flask en un navegador, el navegador almacena cookies en la computadora local. Cuando el usuario cierra el navegador y lo vuelve a abrir, el navegador vuelve a cargar las cookies en la computadora del usuario para que el usuario pueda acceder a los datos guardados previamente.

Para usar cookies en Flask, debe agregar el parámetro secret_key al controlador de ruta, que especifica la clave de seguridad de la cookie.

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

app = Flask(__name__)
app.secret_key = 'my_secret_key'


@app.route('/')
def index():
    return render_template('index.html')


@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        # 获取用户输入的用户名和密码  
        username = request.form['username']
        password = request.form['password']

        # 在数据库中添加登录记录  
        if username == 'my_username' and password == 'my_password':
            session['username'] = username
            return redirect('/')
        else:
            return render_template('login.html', error='Invalid username or password')

    return render_template('index.html')

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

Usamos el parámetro secret_key en el controlador de ruta /login para especificar la clave de seguridad de la cookie. Por lo tanto, cuando el usuario vuelve a visitar la aplicación, el navegador vuelve a cargar la cookie en la computadora del usuario para que el usuario pueda acceder a los datos guardados anteriormente.

Además, Flask también proporciona el concepto de session (sesión), que se utiliza para almacenar datos más complejos en las sesiones de los usuarios, como las preferencias del usuario, el estado de inicio de sesión, etc. Las sesiones generalmente se implementan almacenando datos en el lado del servidor en lugar de en el lado del cliente.

conversación

En Flask, las sesiones se implementan mediante el módulo Flask-Session. Para usar sesiones en Flask, debe agregar un parámetro secret_key a su controlador de ruta, que especifica la clave secreta de la sesión.

from flask import Flask, render_template, request, redirect, url_for  
from flask_session import Session  
  
app = Flask(__name__)  
app.secret_key = 'my_secret_key'  
  
@app.route('/')  
def index():  
    return render_template('index.html')  
  
@app.route('/login', methods=['GET', 'POST'])  
def login():  
    if request.method == 'POST':  
        # 获取用户输入的用户名和密码  
        username = request.form['username']  
        password = request.form['password']  
  
        # 在数据库中添加登录记录  
        if username == 'my_username' and password

noticia de última hora

Flash in the Flask framework es una técnica para mostrar recordatorios cortos en aplicaciones web. Flash se puede usar cuando hay información muy importante que debe comunicarse al usuario inmediatamente cuando el usuario interactúa con la aplicación.

Para usar Flask Flash, debe usar el parámetro flash en la función de vista para almacenar la información de solicitud que se mostrará. Luego, use el método flash.get() para verificar si el aviso ya se ha mostrado antes de que se muestre el aviso. Si la sugerencia ya existe, reemplácela con la nueva sugerencia; de lo contrario, agregue la sugerencia al objeto Flash.

from flask import Flask, flash  
  
app = Flask(__name__)  
  
@app.route('/')  
def index():  
    flash('This is a flash message!')  
    return 'Hello, World!'

Este es el código para un flash de mensaje. Cuando el usuario interactúa con la aplicación, se mostrará la información del aviso almacenada en el objeto flash. En este caso, el mensaje de aviso es "¡Este es un mensaje flash!". Después de que el usuario interactúe con la aplicación, la información de sugerencia en el objeto flash se eliminará automáticamente.

Subir archivo

Manejar la carga de archivos en Flask es muy simple. Toma un formulario HTML con el atributo enctype establecido en "multipart/form-data" y publica el archivo en una URL.

El controlador de URL extrae los archivos del objeto request.files[] y los guarda en la ubicación deseada. Cada archivo cargado se guarda primero en una ubicación temporal en el servidor antes de guardarlo en su ubicación final. El nombre del archivo de destino puede estar codificado u obtenerse de la propiedad de nombre de archivo del objeto request.files[file].

from flask import Flask, request, jsonify  
  
app = Flask(__name__)  
  
@app.route('/upload', methods=['POST'])  
def upload_file():  
    # 检查是否有文件被上传  
    if 'file' not in request.files:  
        return jsonify({
    
    'error': 'No file uploaded.'}), 400  
  
    file = request.files['file']  
  
    # 安全保存文件到磁盘  
    file.save(os.path.join(app.config['UPLOAD_FOLDER'], file.filename))  
  
    return jsonify({
    
    'success': True}), 200

Cuando un usuario sube un archivo, se creará un objeto request.files['file'] y se guardará en la ruta de archivo especificada. El archivo se guardará de forma segura en la ubicación especificada en el servidor. Finalmente, la respuesta contendrá un mensaje de éxito con un valor clave de "éxito" que indica que la carga se realizó correctamente.