Java tiene un conjunto de resortes, pero es un poco engorroso y siempre es innecesario que las personas jueguen (si lo domina, el rendimiento sigue siendo bueno) Los marcos web de Python incluyen django y matraz, etc.
Instale el entorno primero
pip install flask
Puedes instalar la última versión
Siga el tutorial del sitio web oficial
aplicación mínima
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'Hello, World!'
- Primero importamos
Flaskla clase . Una instancia de esta clase será nuestra aplicación WSGI. - A continuación creamos una instancia de esta clase. El primer parámetro es el nombre del módulo o paquete de la aplicación. Si usa un solo módulo (como en este ejemplo), debe usar
__name__, ya que el nombre cambia dependiendo de si el módulo se usa por aplicación o se importa como un módulo (ya sea ' principal ' o el nombre de la importación real ). Este parámetro es obligatorio para que Flask sepa dónde encontrar cosas como plantillas y archivos estáticos. ConsulteFlaskla documentación . - Luego usamos
route()el decorador para decirle a Flask la URL para activar la función. - El nombre de la función se utiliza para generar la URL asociada. La función finalmente devuelve la información que debe mostrarse en el navegador del usuario.
Introducción a WSGI :
El nombre completo es Python Web Server Gateway Interface, que especifica una interfaz estándar entre servidores web y aplicaciones web Python o marcos web para mejorar la portabilidad de las aplicaciones web entre una serie de servidores web. Consulte la documentación oficial
De la introducción anterior podemos ver que:
- WSGI es un conjunto de protocolos/especificaciones estándar de interfaz;
- La sección de comunicación (rol) es entre el servidor web y la aplicación web de Python;
- El propósito es desarrollar estándares para garantizar que diferentes servidores web puedan comunicarse con diferentes programas de Python.
No lo use flask.pycomo el nombre de la aplicación, esto entrará en conflicto con Flask.
comando matraz o -minterruptor para ejecutar la aplicación. Antes de ejecutar la aplicación, debe exportar las variables FLASK_APPde entorno :
$ export FLASK_APP=hello.py
$ flask run
* Running on http://127.0.0.1:5000/
Especifique el host y el puerto por matraz run -h [host] -p [port]
export FLASK_ENV=development
Abrir la función del entorno de desarrollo.
- Activa el depurador.
- Activa la recarga automática.
- Active el modo de depuración para la aplicación Flask.
También puede controlar el cambio del modo de depuración FLASK_DEBUG=1por , y no debe usar el depurador en el entorno de producción.
enrutamiento
Todas las aplicaciones web modernas usan URL significativas, que ayudan a los usuarios a recordar, y las páginas web serán más favorecidas por los usuarios, lo que aumentará la tasa de devolución
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
return 'index page'
# print(__name__)
@app.route('/hello')
def hello():
return 'hello world'
Algunas partes de la URL se pueden cambiar dinámicamente y se pueden especificar varias reglas para una función
@app.route('/user/<username>')
def show_user_profile(username):
# 显示用户名
return 'User {}'.format(username)
@app.route('/post/<int:post_id>')
def show_post(post_id):
# 显示提交整型的用户"id"的结果，注意"int"是将输入的字符串形式转换为整型数据
return 'Post {}'.format(post_id)
@app.route('/path/<path:subpath>')
def show_subpath(subpath):
# 显示 /path/ 之后的路径名
return 'Subpath {}'.format(subpath)
Los principales tipos de convertidores son los siguientes:
| tipo | significado |
|---|---|
| cadena | El tipo de datos predeterminado, acepta cadenas sin barras "/" |
| En t | aceptar entero |
| flotar | Acepta tipos de punto flotante |
| camino | Como cadena, pero acepta barras "/" |
| uuid | Solo acepta cadenas uuid |
URL única/comportamiento de redirección
La diferencia entre las siguientes dos reglas es si se usa o no una barra diagonal. :
@app.route('/projects/')
def projects():
return 'The project page'
@app.route('/about')
def about():
return 'The about page'
projectsLa URL para tiene un buen comportamiento, con una barra inclinada al final y parece una carpeta. Al acceder a una URL sin una barra inclinada al final, Flask lo redirigirá automáticamente para agregar una barra inclinada al final.
aboutLa URL no tiene una barra diagonal final, por lo que se comporta como un archivo. Si visita esta URL con una barra inclinada al final, obtendrá un error 404. Esto mantiene la URL única y ayuda a los motores de búsqueda a evitar indexar la misma página dos veces.
Crear direcciones URL
Usa la función url_for()
url_for()La función se utiliza para construir la URL de la función especificada. Toma el nombre de la función como primer argumento. Puede aceptar cualquier cantidad de argumentos de palabras clave, cada uno correspondiente a una variable en la URL. Las variables desconocidas se agregarán a la URL como parámetros de consulta.
¿Por qué no codificar la URL en la plantilla, sino construirla url_for()dinámicamente ?
- Las inversas suelen ser más descriptivas que las URL codificadas.
- Puede cambiar la URL en un solo lugar en lugar de buscar.
- La creación de URL maneja el escape de caracteres especiales y datos Unicode por usted, lo cual es intuitivo.
- La ruta de producción es siempre una ruta absoluta, que puede evitar los efectos secundarios de las rutas relativas.
- Si su aplicación se coloca fuera de la ruta raíz de la URL (por ejemplo,
/myapplicationen , no/en ),url_for()se manejará correctamente para usted.
método HTTP
Las aplicaciones web manejan URL utilizando diferentes métodos HTTP. Cuando utilice Flask, debe estar familiarizado con los métodos HTTP. De forma predeterminada, un enrutador solo responde GETa las solicitudes . Se pueden route()manejar methodsdiferentes métodos HTTP utilizando el argumento del decorador:
from flask import request
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
return do_the_login()
else:
return show_the_login_form()
Si actualmente se usa el método GET, Flask agregará automáticamente compatibilidad HEADcon el método y también procesará la solicitud de acuerdo con HTTP RFC . HEADAsimismo, OPTIONSse hará de forma automática.
archivos estáticos
Las aplicaciones web dinámicas también requieren archivos estáticos, normalmente archivos CSS y JavaScript. Idealmente, su servidor ya está configurado para servir sus archivos estáticos. Pero durante el desarrollo, Flask también hace bien su trabajo. Simplemente cree una carpeta staticllamada . Los archivos estáticos se encuentran /staticen .
Use un 'static'punto final para generar la URL correspondiente
url_for('static', filename='style.css')
La ubicación de este archivo estático en el sistema de archivos debe ser static/style.css.
plantilla de procesamiento
Generar HTML dentro de Python no es divertido y es bastante torpe. Porque debe cuidar que HTML se escape para garantizar la seguridad de su aplicación. Por lo tanto, Flask configura automáticamente el motor de plantillas Jinja2 para usted.
Flask templatesbuscará plantillas en la carpeta. Entonces, si su aplicación es un módulo, esta carpeta está al lado del módulo, si es un paquete, esta carpeta está dentro de su paquete
<!DOCTYPE html>
<title>Hello From Flask</title>
{% if name %}
<!-- 如果 name 不为空则将 name 渲染出来 -->
<h1>Hello {
{ name }}!</h1>
{% else %}
<!-- 如果 name 为空则打印 Hello World! -->
<h1>Hello World!</h1>
{% endif %}
También puede usar los objetos request , session y g en la plantilla , y también usar la función get_flashed_messages() .
La herencia de plantillas es muy útil. Si desea saber cómo funciona la herencia de plantillas, lea la documentación Herencia de plantillas . La herencia básica de plantillas hace posible que ciertos elementos (como encabezados, navegación y pies de página) se muestren en cada página.
importar archivo css
<!DOCTYPE html>
<html lang="zh-CN">
<head>
<link
rel="stylesheet"
type="text/css"
href="{
{ url_for('static', filename='style.css') }}"
/>
</head>
<body>
<h1>Hello ShiYanLou {
{name}}</h1>
</body>
</html>
Recibir datos de solicitud
En Flask, esta información la requestproporciona . Si tiene algo de experiencia con Python, se preguntará cómo este objeto puede ser global y cómo Flask aún puede garantizar la seguridad de los subprocesos. La respuesta es el alcance del contexto.
objeto de solicitud
Primero necesita importar desde el módulo matraz request:
from flask import request
methodSe puede acceder al método de la solicitud actual mediante propiedades. Puede usar formatributos para acceder a los datos del formulario ( POSTlos datos PUTse pasan en o).
form¿Qué sucede si el valor clave anterior no existe en el atributo? En este caso se activa un especial KeyError. Puede capturarlo como uno estándar KeyError, y si no lo hace, HTTP 400 Bad Requestse mostrará una página de error. Entonces, en muchos casos, no necesita lidiar con esto.
Puede usar argsatributos para recibir URL ( ?key=value )parámetros enviados en:
searchword = request.args.get('key', '')
Recomendamos usar getparámetros de URL o capturas para acceder a KeyErrorlas URL, ya que los usuarios pueden modificar la URL y mostrarles una 400 bad requestpágina no es fácil de usar.
Subir archivo
Puede manejar fácilmente las cargas de archivos con Flask. Solo asegúrese de no olvidar establecer el atributo en su formulario HTML enctype="multipart/form-data", de lo contrario, el navegador no entregará el archivo.
Los archivos cargados se almacenan en la memoria o en una ubicación temporal en el sistema de archivos. Puede acceder a estos archivos a través de propiedades en el objeto de solicitud files. Cada archivo cargado se almacenará en este diccionario de atributos. Se comporta como un fileobjeto estándar de Python, pero también tiene save()métodos que le permiten almacenar archivos en el sistema de archivos del servidor.
Los archivos cargados se almacenan en la memoria o en una ubicación temporal en el sistema de archivos. Puede acceder al archivo cargado a través de la filespropiedad . Cada archivo cargado se almacena en esta propiedad de tipo diccionario. Este atributo es básicamente el mismo que el fileobjeto estándar de Python, y hay un save()método . El siguiente ejemplo muestra cómo funciona:
from flask import request
@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
if request.method == 'POST':
f = request.files['the_file']
f.save('/var/www/uploads/uploaded_file.txt')
Si desea saber el nombre del archivo en el lado del cliente antes de cargarlo en su aplicación, puede acceder filenamea la propiedad. Pero recuerde nunca confiar en este valor, ya que este valor puede ser falsificado. Si desea utilizar el nombre de archivo del cliente para almacenar el archivo en el servidor, páselo a Werkzeugla secure_filename()función proporcionada:
from flask import request
from werkzeug import secure_filename
@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
if request.method == 'POST':
f = request.files['the_file']
f.save('/var/www/uploads/' + secure_filename(f.filename))
...
esquema de carga de archivos
import os
from flask import Flask, flash, request, redirect, url_for
from werkzeug.utils import secure_filename
UPLOAD_FOLDER = '/path/to/the/uploads'
ALLOWED_EXTENSIONS = {
'txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif'}
app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
Primero importamos un montón de cosas, la mayoría de las cuales son fáciles de entender. werkzeug.secure_filename()Se explicará más tarde. UPLOAD_FOLDEREs el directorio para almacenar archivos cargados, y ALLOWED_EXTENSIONSes una colección de extensiones de archivo que pueden cargarse.
La siguiente función verifica si la extensión es válida, carga el archivo y redirige al usuario a la URL del archivo cargado:
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/', methods=['GET', 'POST'])
def upload_file():
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files['file']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
flash('No selected file')
return redirect(request.url)
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
return redirect(url_for('uploaded_file',
filename=filename))
return '''
<!doctype html>
<title>Upload new File</title>
<h1>Upload new File</h1>
<form method=post enctype=multipart/form-data>
<input type=file name=file>
<input type=submit value=Upload>
</form>
'''
Entonces, ¿para qué sirve secure_filename()la función ? Una regla es "nunca confíes en la entrada del usuario". El mismo principio se aplica a los nombres de archivo de los archivos cargados. Todos los datos del formulario enviado pueden ser falsos y los nombres de archivo pueden ser peligrosos. Recuerde en este punto: use siempre esta función para desinfectar los nombres de los archivos antes de guardarlos en el sistema de archivos.
galletas
Para acceder a las cookies, utilice cookiesel atributo . Las cookies se pueden configurar usando el set_cookiemétodo . La cookiespropiedad es un diccionario que contiene todas las cookies transmitidas por el cliente. En Flask, si usa sesiones , no use cookies directamente, porque las sesiones son más seguras.
Leer cookies:
from flask import request
@app.route('/')
def index():
username = request.cookies.get('username')
# use cookies.get(key) instead of cookies[key] to not get a
# KeyError if the cookie is missing.
redirigir
Utilice redirect()la función para redirigir. Use abort()para salir de la solicitud antes con un código de error:
from flask import abort, redirect, url_for
@app.route('/')
def index():
return redirect(url_for('login'))
@app.route('/login')
def login():
abort(401)
this_is_never_executed()
El ejemplo anterior en realidad no tiene sentido, redirige a un usuario de la página de índice a una página inaccesible (401 significa prohibido). Pero el ejemplo anterior puede ilustrar cómo funcionan las redirecciones y los rebotes.
De forma predeterminada, cada código de error mostrará una página de error en blanco y negro. Las páginas de error se pueden personalizar usando errorhandler()decoradores :
from flask import render_template
@app.errorhandler(404)
def page_not_found(error):
return render_template('page_not_found.html'), 404
Atento a render_template()lo siguiente 404, que quiere decir que el código de error de la página es 404, es decir la página no existe. Por defecto, 200 significa: todo es normal
respuesta
El valor de retorno de una función de vista se convierte automáticamente en un objeto de respuesta. Si el valor de retorno es una cadena, se convierte en un objeto de respuesta con el cuerpo de la respuesta siendo la cadena, 200 OKsiendo el código de error el tipo de medio text/html. La lógica para que Flask convierta el valor devuelto en un objeto de respuesta es la siguiente:
- Si se devuelve un objeto de respuesta válido, se devolverá directamente desde la vista.
- Si se devuelve una cadena, se creará un objeto de respuesta con los datos de la cadena y los parámetros predeterminados.
- Si se devuelve una tupla y los elementos de la tupla pueden proporcionar información adicional. Tal tupla debe tener
response, status, headersla forma ( ) y contener al menos un elemento.statusEl valor anulará el código de estado,headersque puede ser una lista o un diccionario de valores de encabezado adicionales. - Si no se cumple ninguna de las condiciones anteriores, Flask supondrá que el valor de retorno es una aplicación WSGI válida y lo convertirá en un objeto de solicitud.
conversación
Además del objeto de solicitud, existe otro objeto sessionllamado an que le permite almacenar información entre solicitudes. Este objeto es equivalente a una cookie cifrada con una firma de clave, es decir, los usuarios pueden ver su cookie, pero no pueden modificarla sin la clave.
Antes de usar una sesión, debe establecer una clave. Por ejemplo:
from flask import Flask, session, redirect, url_for, escape, request
app = Flask(__name__)
# Set the secret key to some random bytes. Keep this really secret!
app.secret_key = b'_5#y2L"F4Q8z\n\xec]/'
@app.route('/')
def index():
if 'username' in session:
return 'Logged in as %s' % escape(session['username'])
return 'You are not logged in'
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
session['username'] = request.form['username']
return redirect(url_for('index'))
return '''
<form method="post">
<p><input type=text name=username>
<p><input type=submit value=Login>
</form>
'''
@app.route('/logout')
def logout():
# remove the username from the session if it's there
session.pop('username', None)
return redirect(url_for('index'))
El usado aquí escape()se usa para escapar. Si no usa un motor de plantilla, puede usar esta función para escapar como el ejemplo anterior
mensaje intermitente
Las buenas aplicaciones e interfaces de usuario tienen que ver con la retroalimentación. Si los usuarios no reciben suficientes comentarios, es posible que lleguen a odiar la aplicación. Flask proporciona una manera realmente fácil de dar retroalimentación a los usuarios a través de un sistema flash de mensajes. El sistema flash de mensajes básicamente hace posible registrar información al final de una solicitud y acceder a ella en la siguiente (y solo la siguiente) solicitud. Por lo general, se combina con diseños de plantilla para mostrar mensajes.
Use flash()el método para mostrar un mensaje, use get_flashed_messages()para recibir el mensaje get_flashed_messages()y también se puede usar en plantillas.
Registro e integración con el middleware WSGI
registro
A veces te encontrarás con una situación: en teoría, los datos con los que estás tratando deberían ser correctos, pero en realidad no lo son. Por ejemplo, es posible que tenga algún código de cliente, el código envía una solicitud HTTP al servidor, pero obviamente está mal. Esto podría deberse a la manipulación de los datos por parte del usuario o a una falla en el código del cliente. 400 Bad RequestLa mayoría de las veces está bien regresar por esta situación , pero a veces no se puede hacer y el código debe seguir funcionando.
También es posible que desee registrar algunas cosas inusuales que suceden. Aquí es donde los registros son útiles. Dado que el registro de Flask 0.3 está preconfigurado
Integrar el software intermedio WSGI
Si desea agregar middleware WSGI a su aplicación, puede empaquetar la aplicación WSGI interna. Por ejemplo, si desea utilizar uno de los middleware del paquete Werkzeug para evitar errores en lighttpd, puede hacer esto:
from werkzeug.contrib.fixers import LighttpdCGIRootFix
app.wsgi_app = LighttpdCGIRootFix(app.wsgi_app)
práctica
Incluyendo la preparación de cuatro funciones de vista: vista de página de inicio, vista de nuevo blog, vista de inicio de sesión y otras imágenes iniciales, así como tres archivos de plantilla. Finalmente, se escribe el archivo style.css que embellece la página. Una vez completado, puede iniciar el proyecto y realizar acciones como iniciar sesión, bloguear, etc.