Python | Introducción al desarrollo web usando Flask

¿Qué es Flask?
Flask es una API de Python que nos permite crear aplicaciones web. Fue desarrollado por Armin Ronacher. El marco de Flask es más explícito que el marco de Django y también es más fácil de aprender porque tiene menos código base para implementar una aplicación web simple. Un marco de aplicación web o marco web es la colección de módulos y bibliotecas que ayuda al desarrollador a escribir aplicaciones sin escribir códigos de bajo nivel, como protocolos, gestión de subprocesos, etc. Flask se basa en el kit de herramientas WSGI (Interfaz de puerta de enlace del servidor web) y el motor de plantillas Jinja2.

Primeros pasos con Flask:
se requiere Python 2.6 o superior para la instalación de Flask. Puede comenzar importando Flask desde el paquete Flask en cualquier IDE de Python. Para la instalación en cualquier entorno, puede hacer clic en el enlace de instalación que figura a continuación.
Para probar si la instalación está funcionando, consulte este código que se proporciona a continuación.

# an object of WSGI application
from flask import Flask    
app = Flask(__name__)   # Flask constructor
  
# A decorator used to tell the application
# which URL is associated function
@app.route('/')      
def hello():
    return 'HELLO'
  
if __name__=='__main__':
   app.run()

La URL ‘/’ está vinculada con hello()la función. Cuando la página de inicio del servidor web se abre en el navegador, la salida de esta función se representará en consecuencia.

La aplicación Flask se inicia llamando a la run()función. El método debe reiniciarse manualmente para cualquier cambio en el código. Para superar esto, el soporte de depuración está habilitado para rastrear cualquier error.

app.debug = True
app.run()
app.run(debug = True)

 
Enrutamiento:
hoy en día, los marcos web proporcionan una técnica de enrutamiento para que el usuario pueda recordar las URL. Es útil para acceder a la página web directamente sin navegar desde la página de Inicio. Se hace a través del siguiente route()decorador, para vincular la URL a una función.

# decorator to route URL
@app.route(‘/hello’)  
  
# binding to the function of route 
def hello_world():     
   return ‘hello world’

Si un usuario visita http://localhost:5000/hello URL, la salida de la función hello_world() se representará en el navegador. La add_url_rule()función de un objeto de aplicación también se puede usar para vincular la URL con la función como en el ejemplo anterior.

def hello_world():
   return ‘hello world’
app.add_url_rule(‘/’, ‘hello’, hello_world)

 
Uso de variables en el matraz:
las variables en el matraz se utilizan para crear una URL dinámicamente al agregar las partes variables al parámetro de la regla. Esta parte variable está marcada como. Se pasa como argumento de palabra clave. Vea el ejemplo a continuación

from flask import Flask
app = Flask(__name__)
  
# routing the decorator function hello_name
@app.route('/hello/<name>')  
def hello_name(name):
   return 'Hello %s!' % name
  
if __name__ == '__main__':
   app.run(debug = True)

Guarde el ejemplo anterior como hello.py y ejecútelo desde power shell. A continuación, abra el navegador e ingrese la URL http://localhost:5000/hello/GeeksforGeeks.

Producción:

Hello GeeksforGeeks!

En el ejemplo anterior, el parámetro del decorador route() contiene la parte variable adjunta a la URL ‘/hello’ como argumento. Por lo tanto, si se ingresa una URL como http://localhost:5000/hello/GeeksforGeeks, se pasará ‘GeeksforGeeks’ a la función hello() como argumento.

Además de la parte variable de string predeterminada, también se utilizan otros tipos de datos como int, float y path (para el canal separador de directorios que puede tomar una barra). Las reglas de URL de Flask se basan en el módulo de enrutamiento de Werkzeug. Esto garantiza que las URL formadas sean únicas y se basen en los precedentes establecidos por Apache.

Ejemplos:

from flask import Flask
app = Flask(__name__)
  
@app.route('/blog/<postID>')
def show_blog(postID):
   return 'Blog Number %d' % postID
  
@app.route('/rev/<revNo>')
def revision(revNo):
   return 'Revision Number %f' % revNo
  
if __name__ == '__main__':
   app.run()
  
# say the URL is http://localhost:5000/blog/555

Producción :

Blog Number 555

# Enter this URL in the browser ? http://localhost:5000/rev/1.1
Revision Number: 1.100000

 
Creación de URL en Flask:
la creación dinámica de la URL para una función específica se realiza mediante url_for()la función. La función acepta el nombre de la función como primer argumento y uno o más argumentos de palabra clave. Ver este ejemplo

from flask import Flask, redirect, url_for
app = Flask(__name__)
  
@app.route('/admin')  #decorator for route(argument) function
def hello_admin():     #binding to hello_admin call
   return 'Hello Admin'    
  
@app.route('/guest/<guest>')
def hello_guest(guest):    #binding to hello_guest call
   return 'Hello %s as Guest' % guest
  
@app.route('/user/<name>')
def hello_user(name):    
   if name =='admin':  #dynamic binding of URL to function
      return redirect(url_for('hello_admin'))  
   else:
      return redirect(url_for('hello_guest', guest = name))
  
if __name__ == '__main__':
   app.run(debug = True)

Para probar esto, guarde el código anterior y ejecútelo a través de Python Shell y luego abra el navegador e ingrese la siguiente URL:

Input: http://localhost:5000/user/admin
Output: Hello Admin 

Input: http://localhost:5000/user/ABC
Output: Hello ABC as Guest

El código anterior tiene una función llamada usuario (nombre), acepta el valor a través de la URL de entrada. Comprueba que el argumento recibido coincida o no con el argumento ‘admin’. Si coincide, se llama a la función hello_admin(); de lo contrario, se llama a hello_guest().

Flask admite varios protocolos HTTP para la recuperación de datos de la URL especificada, estos se pueden definir como: –

 
Manejo de archivos estáticos:
una aplicación web a menudo requiere un archivo estático como javascript o un archivo CSS para mostrar la página web en el navegador. Por lo general, el servidor web está configurado para configurarlos, pero durante el desarrollo, estos archivos se sirven como carpeta estática en su paquete o al lado del módulo. Vea el ejemplo en JavaScript dado a continuación:

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)

El siguiente código HTML:
estará dentro de la carpeta de plantillas , que será hermano del archivo python que escribimos anteriormente

<html>
  
   <head>
      <script type = "text/javascript" 
         src = "{{ url_for('static', filename = 'hello.js') }}" ></script>
   </head>
     
   <body>
      <input type = "button" onclick = "sayHello()" value = "Say Hello" />
   </body>
     
</html>

El archivo JavaScript para hello.jses:
Este código estará dentro de una carpeta estática que será hermana de la carpeta de plantillas

function sayHello() {
   alert("Hello World")
}

El archivo hello.js anterior se procesará de acuerdo con el archivo HTML.

Objeto La solicitud de datos de la página web de un cliente se envía al servidor como un objeto de solicitud global. Luego se procesa importando el módulo Flask. Estos consisten en atributos como Formulario (que contiene un par clave-valor), Args (URL analizada después del signo de interrogación (?)), Cookies (contienen nombres y valores de cookies), Archivos (datos relacionados con el archivo cargado) y Método (solicitud actual).
 
Cookies:
una cookie es una forma de archivo de texto que se almacena en la computadora de un cliente, cuyo propósito es recordar y rastrear datos relacionados con el uso del cliente para mejorar el sitio web de acuerdo con la experiencia del usuario y las estadísticas de la página web.
El objeto Solicitud contiene el atributo de la cookie. Es el objeto del diccionario de todas las variables de la cookie y sus valores correspondientes. También contiene el tiempo de caducidad de sí mismo. En Flask, las cookies se configuran en el objeto de respuesta. Vea el ejemplo a continuación:

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

Código HTML para index.html

<html>
   <body>
     
      <form action = "/setcookie" method = "POST">
         <p><h3>Enter userID</h3></p>
         <p><input type = 'text' name = 'nm'/></p>
         <p><input type = 'submit' value = 'Login'/></p>
      </form>
        
   </body>
</html>

Agregue este código al archivo python definido anteriormente

@app.route('/setcookie', methods = ['POST', 'GET'])
def setcookie():
   if request.method == 'POST':
      user = request.form['nm']
     
   resp = make_response(render_template('cookie.html'))
   resp.set_cookie('userID', user)
     
   return resp
  
@app.route('/getcookie')
def getcookie():
   name = request.cookies.get('userID')
   return '<h1>welcome '+name+'</h1>'

Código HTML para cookie.html

<html>
    <body>
        <a href="/getcookie">Click me to get Cookie</a>   
   </body>
</html>

Ejecute la aplicación anterior y visite el enlace en el navegador http://localhost:5000/
El formulario está configurado en ‘/setcookie’ y el conjunto de funciones contiene un ID de usuario de nombre de cookie que se representará en otra página web. El ‘cookie.html’ contiene un hipervínculo a otra función de vista getcookie(), que muestra el valor en el navegador.
 
Sesiones en Flask:
en la sesión, los datos se almacenan en el servidor. Se puede definir como un intervalo de tiempo en el que el cliente inicia sesión en un servidor hasta que el usuario cierra la sesión. Los datos entre ellos se guardan en una carpeta temporal en el servidor. A cada usuario se le asigna un ID de sesión específico . El objeto Session es un diccionario que contiene el par clave-valor de las variables asociadas con la sesión. Se utiliza una SECRET_KEY para almacenar los datos cifrados en la cookie.

Por ejemplo:

Session[key] = value   // stores the session value
Session.pop(key, None)  // releases a session variable

Otras funciones importantes de Flask:
redirect() se utiliza para devolver la respuesta de un objeto y redirige al usuario a otra ubicación de destino con un código de estado específico.

Syntax: Flask.redirect(location, statuscode, response)

//la ubicación se usa para redirigir a la URL deseada
//el código de estado envía el valor del encabezado, por defecto 302
//la respuesta se usa para iniciar la respuesta.

abortar : se utiliza para manejar el error en el código.

Syntax:  Flask.abort(code)

El parámetro de código puede tomar los siguientes valores para manejar el error en consecuencia:

• 400 – Por solicitud incorrecta
• 401 – Para no autenticado
• 403 – Para solicitud prohibida
• 404 – Para no encontrado
• 406 – Para No aceptable
• 425 – Para medios no admitidos
• 429 – Demasiadas requests

 
Carga de archivos en Flask:
La carga de archivos en Flask es muy fácil. Necesita un formulario HTML con atributo enctype y controlador de URL, que recupera el archivo y guarda el objeto en la ubicación deseada. Los archivos se almacenan temporalmente en el servidor y luego en la ubicación deseada.
La sintaxis HTML que maneja la URL de carga es:

form action="http://localhost:5000/uploader" method="POST" enctype="multipart/form-data"

y el siguiente código Python de Flask es:

from flask import Flask, render_template, request
from werkzeug import secure_filename
app = Flask(__name__)
  
@app.route('/upload')
def upload_file():
   return render_template('upload.html')
      
@app.route('/uploader', methods = ['GET', 'POST'])
def upload_file():
   if request.method == 'POST':
      f = request.files['file']
      f.save(secure_filename(f.filename))
      return 'file uploaded successfully'
          
if __name__ == '__main__':
   app.run(debug = True)

 
Envío de datos de formulario al archivo HTML del servidor:
se utiliza un formulario en HTML para recopilar la información de las entradas requeridas que luego se reenvían y almacenan en el servidor. Estos pueden ser solicitados para leer o modificar el formulario. El matraz proporciona esta función mediante el uso de la regla de URL. En el siguiente ejemplo, la URL ‘/’ representa una página web (estudiante.html) que tiene un formulario. Los datos rellenados se envían a la URL ‘/resultado’ que activa la función resultado(). La función results() recopila datos de formulario presentes en request.form en un objeto de diccionario y los envía para su representación en result.html.

from flask import Flask, render_template, request
app = Flask(__name__)
@app.route('/')
def student():
   return render_template('student.html')
  
@app.route('/result', methods = ['POST', 'GET'])
def result():
   if request.method == 'POST':
      result = request.form
      return render_template("result.html", result = result)
  
if __name__ == '__main__':
   app.run(debug = True)

<!doctype html>
<html>
   <body>
     
      <table border = 1>
         {% for key, value in result.items() %}
           
            <tr>
               <th> {{ key }} </th>
               <td> {{ value }} </td>
            </tr>
              
         {% endfor %}
      </table>
        
   </body>
</html>

<html>
   <body>
     
      <form action = "http://localhost:5000/result" method = "POST">
         <p>Name <input type = "text" name = "Name" /></p>
         <p>Physics <input type = "text" name = "Physics" /></p>
         <p>Chemistry <input type = "text" name = "chemistry" /></p>
         <p>Maths <input type ="text" name = "Maths" /></p>
         <p><input type = "submit" value = "submit" /></p>
      </form>
   </body>
</html>

 
Message Flashing:
It can be defined as a pop-up or a dialog box that appears on the web-page or like alert in JavaScript, which are used to inform the user. This in flask can be done by using the method flash() in Flask. It passes the message to the next template.

Syntax: flash(message, category)

el mensaje es el texto real que se mostrará y la categoría es opcional, que es para mostrar cualquier error o información.

Ejemplo :

from flask import Flask
app = Flask(__name__)
  
# /login display login form
@app.route('/login', methods = ['GET', 'POST']) 
  
# login function verify username and password
def login():     
   error = None
     
   if request.method == 'POST':
      if request.form['username'] != 'admin' or \
         request.form['password'] != 'admin':
         error = 'Invalid username or password. Please try again !'
      else:
  
         # flashes on successful login
         flash('You were successfully logged in') 
         return redirect(url_for('index'))
   return render_template('login.html', error = error)

Referencia: Documentación del matraz