Python Language
Matraz

Introducción

Sintaxis

• @ app.route ("/ urlpath", métodos = ["GET", "POST", "DELETE", "PUTS", "HEAD", "OPTIONS"])
• @ app.route ("/ urlpath / <param>", methods = ["GET", "POST", "DELETE", "PUTS", "HEAD", "OPTIONS"])

Los basicos

El siguiente ejemplo es un ejemplo de un servidor básico:

# Imports the Flask class
from flask import Flask
# Creates an app and checks if its the main or imported
app = Flask(__name__)

# Specifies what URL triggers hello_world()
@app.route('/')
# The function run on the index route
def hello_world():
    # Returns the text to be displayed
    return "Hello World!"

# If this script isn't an import
if __name__ == "__main__":
    # Run the app until stopped
    app.run()

La ejecución de este script (con todas las dependencias correctas instaladas) debe iniciar un servidor local. El host es 127.0.0.1 comúnmente conocido como localhost . Este servidor se ejecuta por defecto en el puerto 5000 . Para acceder a su servidor web, abra un navegador web e ingrese la URL localhost:5000 o 127.0.0.1:5000 (no hay diferencia). Actualmente, solo su computadora puede acceder al servidor web.

app.run() tiene tres parámetros, host , puerto y depuración . El host es 127.0.0.1 forma predeterminada, pero si lo establece en 0.0.0.0 podrá acceder a su servidor web desde cualquier dispositivo de su red usando su dirección IP privada en la URL. el puerto es por defecto 5000, pero si el parámetro se establece en el puerto 80 , los usuarios no necesitarán especificar un número de puerto ya que los navegadores usan el puerto 80 de manera predeterminada. En cuanto a la opción de depuración, durante el proceso de desarrollo (nunca en producción), ayuda a establecer este parámetro en Verdadero, ya que su servidor se reiniciará cuando se realicen cambios en su proyecto de Flask.

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=80, debug=True)

URL de enrutamiento

Con Flask, el enrutamiento de URL se realiza tradicionalmente con decoradores. Estos decoradores se pueden usar para enrutamiento estático, así como enrutamiento de URL con parámetros. Para el siguiente ejemplo, imagine que este script de Flask está ejecutando el sitio web www.example.com .

@app.route("/")
def index():
    return "You went to www.example.com"

@app.route("/about")
def about():
    return "You went to www.example.com/about"

@app.route("/users/guido-van-rossum")
    return "You went to www.example.com/guido-van-rossum"

Con esa última ruta, puede ver que dada una URL con / users / y el nombre del perfil, podríamos devolver un perfil. Como sería horriblemente ineficiente y desordenado incluir una @app.route() para cada usuario, Flask ofrece tomar parámetros de la URL:

@app.route("/users/<username>")
def profile(username):
    return "Welcome to the profile of " + username

cities = ["OMAHA", "MELBOURNE", "NEPAL", "STUTTGART", "LIMA", "CAIRO", "SHANGHAI"]

@app.route("/stores/locations/<city>")
def storefronts(city):
    if city in cities:
        return "Yes! We are located in " + city
    else:
        return "No. We are not located in " + city

Métodos HTTP

Los dos métodos HTTP más comunes son GET y POST . Flask puede ejecutar un código diferente de la misma URL dependiendo del método HTTP utilizado. Por ejemplo, en un servicio web con cuentas, es más conveniente enrutar la página de inicio de sesión y el proceso de inicio de sesión a través de la misma URL. Una solicitud GET, la misma que se realiza al abrir una URL en su navegador, debe mostrar el formulario de inicio de sesión, mientras que una solicitud POST (que lleva datos de inicio de sesión) debe procesarse por separado. También se crea una ruta para manejar el método DELETE y PUT HTTP.

@app.route("/login", methods=["GET"])
def login_form():
    return "This is the login form"
@app.route("/login", methods=["POST"])
def login_auth():
    return "Processing your data"
@app.route("/login", methods=["DELETE", "PUT"])
def deny():
    return "This method is not allowed"

Para simplificar un poco el código, podemos importar el paquete de request desde el matraz.

from flask import request

@app.route("/login", methods=["GET", "POST", "DELETE", "PUT"])
def login():
    if request.method == "DELETE" or request.method == "PUT":
        return "This method is not allowed"
    elif request.method == "GET":
        return "This is the login forum"
    elif request.method == "POST":
        return "Processing your data"

Para recuperar datos de la solicitud POST, debemos usar el paquete de request :

from flask import request
@app.route("/login", methods=["GET", "POST", "DELETE", "PUT"])
def login():
    if request.method == "DELETE" or request.method == "PUT":
        return "This method is not allowed"
    elif request.method == "GET":
        return "This is the login forum"
    elif request.method == "POST":
        return "Username was " + request.form["username"] + " and password was " + request.form["password"]

Archivos y plantillas

En lugar de escribir nuestro marcado HTML en las declaraciones de devolución, podemos usar la función render_template() :

from flask import Flask
from flask import render_template
app = Flask(__name__)

@app.route("/about")
def about():
    return render_template("about-us.html")

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=80, debug=True)

Esto utilizará nuestro archivo de plantilla about-us.html . Para garantizar que nuestra aplicación pueda encontrar este archivo, debemos organizar nuestro directorio en el siguiente formato:

- application.py
/templates
    - about-us.html
    - login-form.html
/static
    /styles
        - about-style.css
        - login-style.css
    /scripts
        - about-script.js
        - login-script.js

Lo más importante, las referencias a estos archivos en el HTML deben tener este aspecto:

<link rel="stylesheet" type="text/css", href="{{url_for('static', filename='styles/about-style.css')}}">

que dirigirá la aplicación para buscar about-style.css en la carpeta de estilos debajo de la carpeta estática. El mismo formato de ruta se aplica a todas las referencias a imágenes, estilos, scripts o archivos.

Jinja Templando

Al igual que Meteor.js, Flask se integra bien con los servicios de plantillas front-end. Frasco utiliza por defecto la plantilla de jinja. Las plantillas permiten que se utilicen pequeños fragmentos de código en el archivo HTML, como condicionales o bucles.

Cuando representamos una plantilla, todos los parámetros más allá del nombre del archivo de la plantilla se pasan al servicio de plantillas HTML. La siguiente ruta pasará el nombre de usuario y la fecha de ingreso (desde una función en otro lugar) al HTML.

@app.route("/users/<username>)
def profile(username):
    joinedDate = get_joined_date(username) # This function's code is irrelevant
    awards = get_awards(username) # This function's code is irrelevant
    # The joinDate is a string and awards is an array of strings
    return render_template("profile.html", username=username, joinDate=joinDate, awards=awards)

Cuando esta plantilla se representa, puede usar las variables que se le pasan desde la función render_template() . Aquí están los contenidos de profile.html :

<!DOCTYPE html>
<html>
    <head>
        # if username
            <title>Profile of {{ username }}</title>
        # else
            <title>No User Found</title>
        # endif
    <head>
    <body>
        {% if username %}
            <h1>{{ username }} joined on the date {{ date }}</h1>
            {% if len(awards) > 0 %}
                <h3>{{ username }} has the following awards:</h3>
                <ul>
                {% for award in awards %}
                    <li>{{award}}</li>
                {% endfor %}
                </ul>
            {% else %}
                <h3>{{ username }} has no awards</h3>
            {% endif %}
        {% else %}
            <h1>No user was found under that username</h1>
        {% endif %}
        {# This is a comment and doesn't affect the output #}
    </body>
</html>

Los siguientes delimitadores se utilizan para diferentes interpretaciones:

• {% ... %} denota una declaración
• {{ ... }} denota una expresión donde se emite una plantilla
• {# ... #} denota un comentario (no incluido en la salida de la plantilla)
• {# ... ## implica que el resto de la línea debe interpretarse como una declaración

El objeto de solicitud

El objeto de request proporciona información sobre la solicitud que se realizó a la ruta. Para utilizar este objeto, debe importarse desde el módulo del matraz:

from flask import request

Parámetros de URL

En ejemplos anteriores se utilizaron request.method y request.form , sin embargo, también podemos usar la propiedad request.args para recuperar un diccionario de las claves / valores en los parámetros de la URL.

@app.route("/api/users/<username>")
def user_api(username):
    try:
        token = request.args.get("key")
        if key == "pA55w0Rd":
            if isUser(username): # The code of this method is irrelevant
                joined = joinDate(username) # The code of this method is irrelevant
                return "User " + username + " joined on " + joined
            else:
                return "User not found"
        else:
            return "Incorrect key"
    # If there is no key parameter
    except KeyError:
        return "No key provided"

Para autenticarse correctamente en este contexto, se necesitaría la siguiente URL (reemplazando el nombre de usuario con cualquier nombre de usuario):

www.example.com/api/users/guido-van-rossum?key=pa55w0Rd

Cargas de archivos

Si la carga de un archivo era parte del formulario enviado en una solicitud POST, los archivos se pueden manejar usando el objeto de request :

@app.route("/upload", methods=["POST"])
def upload_file():
    f = request.files["wordlist-upload"]
    f.save("/var/www/uploads/" + f.filename) # Store with the original filename

Galletas

La solicitud también puede incluir cookies en un diccionario similar a los parámetros de URL.

@app.route("/home")
def home():
    try:
        username = request.cookies.get("username")
        return "Your stored username is " + username
    except KeyError:
        return "No username cookies was found")