Thursday 24 January 2019

File statici in Flask

Un'applicazione web richiede spesso un file statico come un file javascript o un file CSS che supporta la visualizzazione di una pagina web. Di solito, il server web è configurato per servirli per te, ma durante lo sviluppo, questi file vengono pubblicati dalla cartella statica nel tuo pacchetto o accanto al tuo modulo e saranno disponibili in / static sull'applicazione.
Un endpoint speciale 'statico' viene utilizzato per generare l'URL per i file statici.
Nell'esempio seguente, una funzione javascript definita in hello.js viene richiamata sull'evento OnClick del pulsante HTML in index.html , che viene visualizzato nell'URL "/" dell'applicazione Flask.
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)
Di seguito è riportato lo script HTML di index.html .
<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>
hello.js contiene la funzione sayHello () .
function sayHello() {
   alert("Hello World")
}

Templates in Flask

È possibile restituire l'output di una funzione associata a un determinato URL sotto forma di HTML. Ad esempio, nel seguente script, la funzione hello () renderizza 'Hello World' con il tag <h1> collegato ad esso.
from flask import Flask
app = Flask(__name__)

@app.route('/')
def index():
   return '<html><body><h1>'Hello World'</h1></body></html>'

if __name__ == '__main__':
   app.run(debug = True)
Tuttavia, la generazione di contenuti HTML dal codice Python è complicata, specialmente quando è necessario inserire dati variabili e elementi di linguaggio Python come condizionali o loop. Ciò richiederebbe frequenti fughe dall'HTML.
È qui che è possibile sfruttare il motore di template Jinja2 , su cui è basato Flask. Invece di restituire codice HTML hardcode dalla funzione, un file HTML può essere reso dalla funzione render_template () .
from flask import Flask
app = Flask(__name__)

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

if __name__ == '__main__':
   app.run(debug = True)
Flask proverà a trovare il file HTML nella cartella dei modelli, nella stessa cartella in cui è presente questo script.
  • Cartella dell'applicazione
    • Hello.py
    • modelli
      • hello.html
Il termine 'web templating system' si riferisce alla progettazione di uno script HTML in cui i dati variabili possono essere inseriti dinamicamente. Un sistema di modelli Web comprende un motore di template, una sorta di fonte di dati e un processore di template.
Flask utilizza il motore di template jinga2 . Un modello Web contiene segnaposto intervallati della sintassi HTML per variabili ed espressioni (in questo caso espressioni Python) che vengono sostituiti quando viene eseguito il rendering del modello.
Il seguente codice viene salvato come ciao.html nella cartella dei modelli.
<!doctype html>
<html>
   <body>
   
      <h1>Hello {{ name }}!</h1>
      
   </body>
</html>
Successivamente, esegui il seguente script dalla shell Python.
from flask import Flask, render_template
app = Flask(__name__)

@app.route('/hello/<user>')
def hello_name(user):
   return render_template('hello.html', name = user)

if __name__ == '__main__':
   app.run(debug = True)
All'avvio del server di sviluppo, aprire il browser e inserire l'URL come - http: // localhost: 5000 / hello / mvl
La parte variabile dell'URL è inserita in {{name}} segnaposto.
Esempio di sistema di web templating Il motore di template Jinga2 utilizza i seguenti delimitatori per l'escape dall'HTML.
  • {% ...%} per le dichiarazioni
  • {{...}} per le espressioni da stampare sull'output del modello
  • {# ... #} per i commenti non inclusi nell'output del modello
  • # ... ## per Line Statement
Nell'esempio seguente, viene illustrato l'uso dell'istruzione condizionale nel modello. La regola URL della funzione hello () accetta il parametro intero. Viene passato al modello hello.html . Al suo interno, il valore del numero ricevuto (segni) viene confrontato (maggiore o minore di 50) e, di conseguenza, HTML viene reso condizionalmente.
Lo script Python è il seguente -
from flask import Flask, render_template
app = Flask(__name__)

@app.route('/hello/<int:score>')
def hello_name(score):
   return render_template('hello.html', marks = score)

if __name__ == '__main__':
   app.run(debug = True)
Lo script del modello HTML di hello.html è il seguente:
<!doctype html>
<html>
   <body>
      {% if marks>50 %}
         <h1> Your result is pass!</h1>
      {% else %}
         <h1>Your result is fail</h1>
      {% endif %}
   </body>
</html>
Si noti che le istruzioni condizionali if-else e endif sono racchiuse nel delimitatore {% ..%} .
Esegui lo script Python e visita l'URL http: // localhost / hello / 60 e poi http: // localhost / hello / 30 per vedere l'output di HTML che cambia condizionatamente.
I costrutti di loop Python possono anche essere utilizzati all'interno del modello. Nel seguente script, la funzione result () invia un oggetto dizionario al modello results.html quando URL http: // localhost: 5000 / result viene aperto nel browser.
La parte Template di result.html utilizza un ciclo for per il rendering di coppie chiave e valore di oggetto dizionario risultato {} come celle di una tabella HTML.
Esegui il seguente codice dalla shell Python.
from flask import Flask, render_template
app = Flask(__name__)

@app.route('/result')
def result():
   dict = {'phy':50,'che':60,'maths':70}
   return render_template('result.html', result = dict)

if __name__ == '__main__':
   app.run(debug = True)
Salva il seguente script HTML come risultato.html nella cartella dei modelli.
<!doctype html>
<html>
   <body>
      <table border = 1>
         {% for key, value in result.iteritems() %}
            <tr>
               <th> {{ key }} </th>
               <td> {{ value }} </td>
            </tr>
         {% endfor %}
      </table>
   </body>
</html>
Qui, ancora una volta le istruzioni Python corrispondenti al ciclo For sono racchiuse in {% ..%} mentre la chiave e il valore delle espressioni sono inseriti in {{}} .
Dopo aver avviato lo sviluppo, apri http: // localhost: 5000 / risultato nel browser per ottenere il seguente output.
Esempio di modello di tabella

Servizi REST in Flask

Il protocollo Http è il fondamento della comunicazione dei dati nel world wide web. Diversi metodi di recupero dei dati dall'URL specificato sono definiti in questo protocollo.
La seguente tabella riepiloga diversi metodi http:
Sr.No. Metodi e descrizione
1 OTTENERE
Invia i dati in forma non crittografata al server. Metodo più comune
2 CAPO
Come GET, ma senza corpo di risposta
3 INVIARE
Utilizzato per inviare dati di moduli HTML al server. I dati ricevuti dal metodo POST non vengono memorizzati nella cache dal server.
4 METTERE
Sostituisce tutte le rappresentazioni correnti della risorsa di destinazione con il contenuto caricato.
5 ELIMINA
Rimuove tutte le rappresentazioni correnti della risorsa di destinazione fornite da un URL
Per impostazione predefinita, la rotta Flask risponde alle richieste GET . Tuttavia, questa preferenza può essere modificata fornendo argomenti dei metodi a route () decoratore.
Per dimostrare l'uso del metodo POST nell'instradamento degli URL, dobbiamo prima creare un modulo HTML e utilizzare il metodo POST per inviare i dati del modulo a un URL.
Salva il seguente script come login.html
 <Html>
    <Body>
       <form action = "http: // localhost: 5000 / login" method = "post">
          <p> Inserisci nome: </ p>
          <p> <input type = "text" name = "nm" /> </ p>
          <p> <input type = "submit" value = "submit" /> </ p>
       </ Form>
    </ Body>
 </ Html>
Ora inserisci il seguente script nella shell Python.
 da Flask import Flask, reindirizzare, url_for, request
 app = Flask (__ name__)

 @ App.route ( '/ successo / <nome>')
 def successo (nome):
    ritorna 'welcome% s'% name

 @ app.route ('/ login', methods = ['POST', 'GET']))
 def login ():
    if request.method == 'POST':
       utente = richiesta.form ['nm']
       return redirect (url_for ('success', name = user))
    altro:
       utente = request.args.get ('nm')
       return redirect (url_for ('success', name = user))

 se __name__ == '__main__':
    app.run (debug = True)
Dopo l'avvio del server di sviluppo, aprire login.html nel browser, immettere il nome nel campo di testo e fare clic su Invia .
Esempio di metodo post I dati del modulo vengono inviati all'URL nella clausola di azione del tag modulo.
http: // localhost / login è mappato alla funzione login () . Poiché il server ha ricevuto i dati con il metodo POST , il valore del parametro 'nm' ottenuto dai dati del modulo è ottenuto da -
 utente = richiesta.form ['nm']
Viene passato all'URL "/ success" come parte variabile. Il browser visualizza un messaggio di benvenuto nella finestra.
Messaggio di benvenuto Cambia il parametro del metodo in 'GET' in login.html e aprilo di nuovo nel browser. I dati ricevuti sul server sono dal metodo GET . Il valore del parametro 'nm' è ora ottenuto da -
 Utente = request.args.get ('nm')
Qui, args è un oggetto dizionario che contiene un elenco di coppie di parametri del modulo e il suo valore corrispondente. Il valore corrispondente al parametro 'nm' viene passato a '/ successo' URL come prima.

Gestione variabili in Flask

È possibile creare un URL in modo dinamico, aggiungendo parti variabili al parametro della regola. Questa parte variabile è contrassegnata come <nome-variabile> . Viene passato come argomento della parola chiave alla funzione a cui è associata la regola.
Nell'esempio seguente, il parametro rule del decoratore route () contiene la parte variabile <name> associata all'URL "/ hello" . Quindi, se http: // localhost: 5000 / hello / hithere è inserito come URL nel browser, "hithere" verrà fornito come funzione alla funzione hello () .
 
from flask import Flask
app = Flask(__name__)

@app.route('/hello/<name>')
def hello_name(name):
   return 'Hello %s!' % name

if __name__ == '__main__':
   app.run(debug = True)
 
Salva lo script precedente come hello.py ed eseguilo dalla shell Python. Quindi, aprire il browser e inserire l'URL http: // localhost: 5000 / hello / hithere 
Il seguente output verrà visualizzato nel browser.
Hello hithere!
Oltre alla parte variabile della stringa predefinita, le regole possono essere costruite usando i seguenti convertitori:
Sr.No. Convertitori e descrizione
1 int
accetta intero
2 galleggiante
Per il valore in virgola mobile
3 sentiero
accetta le barre usate come carattere separatore di directory
Nel seguente codice, vengono utilizzati tutti questi costruttori.
from flask import Flask
app = Flask(__name__)

@app.route('/blog/<int:postID>')
def show_blog(postID):
   return 'Blog Number %d' % postID

@app.route('/rev/<float:revNo>')
def revision(revNo):
   return 'Revision Number %f' % revNo

if __name__ == '__main__':
   app.run()
Esegui il codice sopra da Python Shell. Visita l'URL http: // localhost: 5000 / blog / 11 nel browser.
Il numero dato viene usato come argomento per la funzione show_blog () . Il browser mostra il seguente output:
Blog Number 11
Inserisci questo URL nel browser - http: // localhost: 5000 / rev / 1.1
La funzione revision () riprende il numero in virgola mobile come argomento. Il seguente risultato appare nella finestra del browser -
Revision Number 1.100000
Le regole URL di Flask sono basate sul modulo di routing di Werkzeug . Ciò garantisce che gli URL formati siano unici e basati su precedenti definiti da Apache.
Considera le regole definite nel seguente script:
from flask import Flask
app = Flask(__name__)

@app.route('/flask')
def hello_flask():
   return 'Hello Flask'

@app.route('/python/')
def hello_python():
   return 'Hello Python'

if __name__ == '__main__':
   app.run()
Entrambe le regole appaiono simili ma nella seconda regola viene utilizzata la barra finale (/) . Di conseguenza, diventa un URL canonico. Quindi, usando / python o / python / restituisce lo stesso output. Tuttavia, in caso di prima regola, / pallone / URL risulta nella pagina 404 non trovata .

Definizione di Route con Flask

I moderni framework web utilizzano la tecnica di routing per aiutare un utente a ricordare gli URL delle applicazioni. È utile accedere direttamente alla pagina desiderata senza dover navigare dalla home page.
Il decoratore route () in Flask viene utilizzato per associare l'URL a una funzione. Ad esempio :
 
@app.route(‘/hello’)
def hello_world():
   return hello world
 
Qui, la regola URL "/ hello" è associata alla funzione hello_world () . Di conseguenza, se un utente visita http: // localhost: 5000 / hello URL, l'output della funzione hello_world () verrà visualizzato nel browser.
La funzione add_url_rule () di un oggetto applicazione è anche disponibile per associare un URL con una funzione come nell'esempio precedente, viene utilizzato route () .
Lo scopo di un decoratore è anche servito dalla seguente rappresentazione:
 
def hello_world():
   return hello world
app.add_url_rule(‘/’, hello’, hello_world)

Cosa è Flask?

Flask è una struttura di applicazioni Web scritta in Python. È sviluppato da Armin Ronacher , che guida un gruppo internazionale di appassionati di Python di nome Pocco. Flask si basa sul toolkit WSGI Werkzeug e sul motore di template Jinja2. Entrambi sono progetti Pocco.

WSGI

Web Server Gateway Interface (WSGI) è stato adottato come standard per lo sviluppo di applicazioni Web Python. WSGI è una specifica per un'interfaccia universale tra il web server e le applicazioni web.

Werkzeug

È un toolkit WSGI che implementa richieste, oggetti di risposta e altre funzioni di utilità. Ciò consente di costruire un framework web su di esso. La struttura di Flask usa Werkzeug come una delle sue basi.

Jinga2

Jinga2 è un popolare motore di template per Python. Un sistema di web templating combina un template con una certa fonte di dati per rendere pagine web dinamiche.

Installazione di Flask


Python 2.6 o superiore è solitamente richiesto per l'installazione di Flask. Sebbene Flask e le sue dipendenze funzionino bene con Python 3 (Python 3.3 in poi), molte estensioni di Flask non lo supportano correttamente. Quindi, si consiglia di installare Flask su Python 2.7.

Installa virtualenv per l'ambiente di sviluppo

virtualenv è un costruttore di ambienti Python virtuale. Aiuta un utente a creare più ambienti Python fianco a fianco. In tal modo, può evitare problemi di compatibilità tra le diverse versioni delle librerie.
Il seguente comando installa virtualenv
 
pip install virtualenv
 
Questo comando richiede i privilegi di amministratore. Aggiungi sudo prima di pip su Linux / Mac OS. Se si è su Windows, accedere come amministratore. Su Ubuntu virtualenv può essere installato usando il suo gestore di pacchetti.
Sudo apt-get install virtualenv
Una volta installato, il nuovo ambiente virtuale viene creato in una cartella.
 
mkdir newproj
cd newproj
virtualenv venv
 
Per attivare l'ambiente corrispondente, su Linux / OS X , utilizzare quanto segue:
 
venv/bin/activate
 
Su Windows , può essere usato seguente
 
venv\scripts\activate
 
Ora siamo pronti per installare Flask in questo ambiente.
 
pip install Flask
 
Il comando precedente può essere eseguito direttamente, senza ambiente virtuale per l'installazione a livello di sistema.

Per testare l'installazione di Flask , digitare il seguente codice nell'editor come Hello.py
from flask import Flask
app = Flask(__name__)

@app.route('/')
def hello_world():
   return 'Hello World’

if __name__ == '__main__':
   app.run()
L'importazione del modulo flask nel progetto è obbligatoria. Un oggetto della classe Flask è la nostra applicazione WSGI .
Il costruttore di palloni prende come argomento il nome del modulo corrente (__name__) .
La funzione route () della classe Flask è un decoratore, che indica all'applicazione quale URL deve chiamare la funzione associata.
app.route(rule, options)
  • Il parametro rule rappresenta l'associazione URL con la funzione.
  • Le opzioni sono un elenco di parametri da inoltrare all'oggetto della regola sottostante.
Nell'esempio precedente, l' URL '/' è associato alla funzione hello_world () . Quindi, quando la pagina iniziale del server Web viene aperta nel browser, l'output di questa funzione verrà reso.
Infine, il metodo run () della classe Flask esegue l'applicazione sul server di sviluppo locale.
app.run(host, port, debug, options)
Tutti i parametri sono opzionali
 

Wednesday 16 January 2019

Hello World esempio di Flask

Installazione di Flask

Flask è scritto in Python, quindi per installarlo occorre appoggiarsi ad un repository ed usare lo script "pip" come in questo esempio.

$ pip install <package-name>

Un problema comune con l'installazione di packages Python e la manutenzione di diversi packages per diverse applicazioni.

Python utilizza il concetto di ambienti virtuali. Un ambiente virtuale è una copia completa dell'interprete Python. Quando si installano i pacchetti in un ambiente virtuale, l'interprete Python dell'intero sistema non è interessato, solo la copia lo è. Quindi la soluzione per avere la completa libertà di installare qualsiasi versione dei pacchetti per ogni applicazione consiste nell'utilizzare un diverso ambiente virtuale per ogni applicazione. Gli ambienti virtuali hanno l'ulteriore vantaggio di essere di proprietà dell'utente che li ha creati, quindi non richiedono un account amministratore.

Iniziamo creando una directory per il progetto che andremo ad usare:
$ mkdir microblog
$ cd microblog

Se state usando Python 3, il supporto per il  virtual environment support è built-in quindi sarà necessario soltanto:
$ python3 -m venv venv
 
 
Con questo comando, sto chiedendo a Python di eseguire il pacchetto venv, che crea un ambiente virtuale denominato venv. Il primo venv nel comando è il nome del pacchetto di ambiente virtuale Python, mentre il secondo è il nome dell'ambiente virtuale che userò per questo particolare ambiente.
Una volta completato il comando, verrà visualizzata una directory denominata venv in cui sono archiviati i file dell'ambiente virtuale.

Una volta installato virtualenv, possiamo creare un ambiente virtuale con il seguente comando:

$ virtualenv venv

Il passo successivo sarà di attivare l'ambiente virtuale, con il seguente comando:

$ source venv/bin/activate (venv) $ _

Avendo l'ambiente virtuale creato ed attivo, possiamo finalmente installare Flask!

(venv) $ pip install flask

Puoi verificare che l'installazione di Flask è funzionante aggiugendo il seguente import all'interprete Python:
>>> import flask
>>> _

Una applicatione "Hello, World" in Flask

Questa semplice applicazione che andremo a creare verra inserita in un  package. In Python, una sotto-directory che include il file __init__.py è considerata un package.
Creiamo quindi un package app, per la nostra applicazione con il seguente comando:
(venv) $ mkdir app
All'interno del file __init__.py del package app includeremo il seguente codice:

from flask import Flask

app = Flask(__name__)

from app import routes

Questo script crea semplicemente l'oggetto app  come un'istanza della classe Flask importata dal pacchetto flask. La variabile __name__ passata alla classe Flask è una variabile predefinita Python, che viene impostata sul nome del modulo in cui viene utilizzata.

L'applicazione quindi importa il modulo routes, che non abbiamo ancora aggiunto.

Quindi cosa metteremo nel modulo routes ? Semplicemente i percorsi REST implementati dall'applicazione. In Flask, i gestori per i percorsi dell'applicazione sono a loro volta funzioni Python, chiamate funzioni di visualizzazione. Le funzioni di visualizzazione sono mappate su uno o più URL di percorso in modo che Flask sappia quale logica eseguire quando un client richiede un determinato URL.

Ecco la tua prima funzione di visualizzazione, che devi scrivere nel nuovo modulo chiamato app / routes.py:

from app import app

@app.route('/')
@app.route('/index')
def index():
    return "Hello, World!"
 

Questa funzione di visualizzazione è in realtà piuttosto semplice, restituisce semplicemente un "Hello World" come una stringa. Le due strane linee @ app.route sopra la funzione sono chiamati decoratori: un decoratore modifica la funzione che lo segue. Un modello comune con i decoratori è di utilizzarli per registrare le funzioni come callback per determinati eventi. In questo caso, il decoratore @ app.route crea un'associazione tra l'URL fornito come argomento e la funzione.

In questo esempio ci sono due decoratori, che associano gli URL / e / index a questa funzione. Ciò significa che quando un browser Web richiede uno di questi due URL, Flask invocherà questa funzione e passerà il suo valore di ritorno al browser come risposta. Se questo non ha ancora senso, lo sarà tra un pò quando eseguirai questa applicazione.

Per completare l'applicazione, è necessario disporre di uno script Python al livello più alto che definisca l'istanza dell'applicazione Flask. Chiamiamo questo script microblog.py e definiamolo come una singola riga che importa l'istanza dell'applicazione:

from app import app




La prima applicazione è pronta! prima di eseguirla occorre impostare la FLASK_APP environment variable:
(venv) $ export FLASK_APP=microblog.py

Provata ad aprire il browser a questo indirizzo per verificare:
    http://localhost:5000/
 
Se avete completato tutti gli step indicati dovreste vedere quanto segue: