Tutorial Flask

TUTORIAL FLASK.
O APLICATIVO INICIAL.
from flask import Flask
app = Flask(__name__)
@app.route(’/’)
def hello_world():
return ’Hello World!’
if __name__ == ’__main__’:
app.run(debug=True)
ARQUIVOS ESTATICOS:
To generate URLs that part of the URL, use the special ’static’ URL name:
url_for(’static’, filename=’style.css’)
The file has to be stored on the filesystem as static/style.css.
Rendering Templates:
from flask import Flask, render_template
@app.route(’/hello/’)
def hello(name=None):
return render_template(’hello.html’, name=name)
Template:
e template: {% if name %}
Hello {{ name }}!
{% else %}
Hello World!
{% endif %}
UPLOAD DE ARQUIVOS:
from flask import Flask, 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’)
REDIRECT:
from flask import Flask, abort, redirect, url_for
@app.route(’/’)
def index():
return redirect(url_for(’login’))
@app.route(’/login’)
def login():
abort(401) this_is_never_executed()
LOGIN
from flask import Flask, session, redirect, url_for, escape, request

@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 action="" 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 its there
session.pop(’username’, None)
return redirect(url_for(’index’))
# set the secret key.
import os
app.secret_key = os.urandom(24)
FLASH:
Fornecer um arquivo estático do código (JSON)

Na pasta static, crie um arquivo de dados JSON estático chamado data.json
"01": {
"note" : "Data is very simple because we're demonstrating only the mechanism."
@app.route('/api/data')
def get_data():
return app.send_static_file('data.json')
Usar um arquivo estático em um modelo

Crie um arquivo chamado site.css
.message {
font-weight: 600;
color: blue;
<html>
<head>
<title>{{ title }}</title>
<link rel="stylesheet" type="text/css" href="/static/site.css" />
</head>
<body>
<span class="message">{{ message }}</span>{{ content }}
</body>
</html>
Usando datas
from datetime import datetime
from flask import render_template
from HelloFlask import app
@app.route('/')
@app.route('/home')
def home():
now = datetime.now()
formatted_now = now.strftime("%A, %d %B, %Y at %X")
html_content = "<html><head><title>Hello Flask</title></head><body>"
html_content += "<strong>Hello Flask!</strong> on " + formatted_now
html_content += "</body></html>"
return html_content
<html>
<head><title>Hello Flask</title></head>
<body>
{{ content }}
</body>
</html>
Usando o método render_template
def home():
return render_template(
"index.html",
content = "<strong>Hello, Flask!</strong> on " + formatted_now)
<html>
<head>
</head>
<body>
<strong>{{ message }}</strong>{{ content }}
</body>
</html>
def home():
return render_template(
"index.html",
title = "Hello Flask",
message = "Hello, Flask!",
content = " on " + formatted_now)
Jasonify
from flask import jsonify, Flask

appFlask = Flask(__name__)
@appFlask.route('/home')
def home():
return jsonify(username='eduCBA' ,
account='Premium' ,
validity='200 days')
if __name__ == "__main__":
appFlask.run(debug=True)
Dictionary ={'username':'eduCBA' ,
'account':'Premium' , 'validity':'2709 days'}
return jsonify(Dictionary)
Adicionar imagem:
from flask import Flask, render_template, redirect, url_for,
request# Route for handling the login page logic
@app.route('/', methods=['GET', 'POST'])
def home():
return render_template('home.html')#within app.route add
the html page we are doing changes to
@app.route('/register')
# def is normally how we define a function in python
def register():
return
render_template('register.html')@app.route('/registerV')
def registerV():
return render_template('registerV.html')
<!DOCTYPE html>
<html>
<head>
<title></title>
<meta charset="utf-8" />
</head><body>
<div class="bd-example" align="middle">
<img src="{{url_for('static',
filename='Hermes.png')}}align="middle" />
</div>
</body>
</html>
Formulário de login
<html>
<corpo>
<form action = método "http://localhost:5000/login" = "post">
<tabela>
<tr><td>Nome</td>
<td><input type ="text" name ="uname"></td></tr>
<tr><td>Senha</td>
<td><input type ="password" name ="pass"></td></tr>
<tr><td><input type = "submit"></td></tr>
</tabela>
</formulário>
</corpo>
</html>
a partir da importação do balão *
@app.route('/login',methods = ['POST'])
def login():
uname=request.form['uname']
passwrd=request.form['passar']
if uname=="ayush" e passwrd=="google":
return "Bem-vindo %s" %uname
se __name__ == '__main__':
app.run(debug = True)
Flask-SQLAlchemy é uma extensão Flask que fornece suporte para a biblioteca

SQLAlchemy, que é uma biblioteca Python popular para interagir com bancos
de dados. Ele simplifica o uso do SQLAlchemy no Flask, dando-lhe padrões úteis
e auxiliares extras que facilitam o uso do SQLAlchemy com o Flask.
Para usar o Flask-SQLAlchemy, você precisará instalar o Flask e o SQLAlchemy.

Você pode fazer isso executando o seguinte comando:
pip install flask sqlalchemy
Depois de ter essas bibliotecas instaladas, você pode usar o Flask-SQLAlchemy

criando um aplicativo Flask e, em seguida, inicializando a extensão Flask-
SQLAlchemy com o aplicativo.
Aqui está um exemplo de como criar um aplicativo Flask simples com um banco
de dados SQLite usando Flask-SQLAlchemy:
from flask_sqlalchemy import SQLAlchemy
app.config['SQLALCHEMY_DATABASE_URI'] =
'sqlite:///test.db'
db = SQLAlchemy(app)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True,
nullable=False)
email = db.Column(db.String(120), unique=True,
nullable=False)
db.create_all()
Este exemplo cria um modelo simples com três campos: , e . O campo é uma
chave primária inteira, enquanto os campos e são cadeias de caracteres com
restrições exclusivas e não anuláveis.Useridusernameemailidusernameemail
Depois de definir seus modelos, você pode usar o Flask-SQLAlchemy para criar,
ler, atualizar e excluir registros no banco de dados usando o objeto. Por
exemplo, você pode criar um novo usuário no banco de dados da seguinte
forma:db
new_user = User(username='john',
email='john@example.com')
db.session.add(new_user)
db.session.commit()
Você também pode consultar o banco de dados usando o método. Por exemplo, você
pode recuperar uma lista de todos os usuários no banco de dados da seguinte
forma:db.session.query()
users = User.query.all()
É possível usar o Matplotlib com Flask para criar gráficos dinâmicos que podem
ser atualizados em tempo real. Para fazer isso, você precisará usar Matplotlib e
classes para criar o gráfico e, em seguida, converter o gráfico para um formato
que pode ser exibido em um navegador da Web, como uma imagem ou um
documento HTML.FigureFigureCanvas
Aqui está um exemplo de como usar o Matplotlib com o Flask para criar um
gráfico de linhas simples:

import matplotlib.pyplot as plt
import io
import base64
@app.route('/')
def index():
# Generate the plot
plt.plot([1, 2, 3, 4])
plt.ylabel('some numbers')
# Convert plot to PNG image

buf = io.BytesIO()
plt.savefig(buf, format='png')
buf.seek(0)
image_data =
base64.b64encode(buf.getvalue()).decode('utf-8')
# Render the template

return render_template('index.html',
image_data=image_data)
if __name__ == '__main__':
app.run()
Neste exemplo, definimos uma rota que gera um gráfico de linhas simples
usando a função e a função de Matplotlib. Em seguida, convertemos o gráfico
em uma imagem PNG usando a função e a classe para criar um objeto
semelhante a um arquivo que pode ser usado para armazenar os dados da
imagem. Finalmente, codificamos os dados da imagem como uma cadeia de
caracteres base64 e os passamos para o modelo. plotylabelsavefigBytesIO
No modelo, podemos exibir a imagem usando uma tag: <img>
<html>
<body>
<img src="data:image/png;base64,
{{ image_data }}">
</body>
</html>
Neste exemplo, importamos as extensões Flask e Flask-Matplotlib e criamos um

aplicativo Flask. Em seguida, criamos uma instância da extensão e passamos a
ela o aplicativo Flask.Matplotlib
Em seguida, definimos uma rota que exibe um gráfico Matplotlib. Criamos um

gráfico de linhas simples usando a função de Matplotlib e, em seguida,
retornamos o gráfico como uma cadeia de caracteres HTML usando a
função.plotto_html
Para renderizar o gráfico em um navegador da Web, você pode usar a função

do Flask e passar a cadeia de caracteres HTML como uma variável de modelo.
Por exemplo:render_template
from flask_matplotlib import Matplotlib
Matplotlib(app)
@app.route('/plot')
def plot():
x = [1, 2, 3, 4]
y = [1, 4, 9, 16]
plt.plot(x, y)
return plt.to_html()
@app.route('/plot')
def plot():
x = [1, 2, 3, 4]
y = [1, 4, 9, 16]
plt.plot(x, y)
plot_html = plt.to_html()
return render_template('plot.html', plot=plot_html)
Neste exemplo, definimos uma rota que gera um gráfico usando Matplotlib e o
retorna como uma imagem PNG. A função cria um gráfico usando as funções e
do módulo e salva-o em um arquivo de imagem usando a função. Em seguida,
usamos a classe do módulo para criar um fluxo binário para armazenar os
dados da imagem e o método para definir o ponteiro do fluxo para o início do
arquivo. Finalmente, usamos a função do Flask para enviar o arquivo de imagem
para o cliente./plot.pngplotplotylabelpyplotsavefigBytesIOioseeksend_file
Em seguida, você pode exibir o gráfico em um modelo Flask usando uma tag
com o atributo definido para a URL da rota do gráfico: <img>src
import io
from flask import send_file
@app.route('/plot.png')
def plot():
plt.plot([1, 2, 3, 4])
plt.ylabel('some numbers')
img = io.BytesIO()
plt.savefig(img, format='png')
img.seek(0)
return send_file(img, mimetype='image/png')
<img src="/plot.png">
Para renderizar um modelo em um aplicativo Flask, você pode usar a função do

módulo Flask. Essa função usa o nome do arquivo de modelo e uma lista de
variáveis e retorna o modelo renderizado como um objeto de
resposta.render_templaterender_template
Aqui está um exemplo de como renderizar um modelo em um aplicativo Flask:
@app.route('/')
def index():
return render_template('index.html', title='Home')
if __name__ == '__main__':
app.run()
Neste exemplo, criamos um aplicativo Flask e definimos uma rota que retorna o
modelo. A função usa o nome do arquivo de modelo e uma variável e retorna o
modelo renderizado com a variável substituída por seu
valor./index.htmlrender_templatetitletitle
Os modelos são normalmente armazenados em uma pasta no diretório raiz do

aplicativo Flask. Os arquivos de modelo podem conter conteúdo HTML estático,
bem como variáveis e diretivas de modelo Jinja. Por exemplo, o modelo pode
ter esta aparência:templatesindex.html
<html>
<head>
</head>
<body>
<h1>Welcome to the {{ title }} page!</h1>
</body>
</html>
Neste exemplo, a variável é colocada entre chaves duplas e será substituída por seu
valor quando o modelo for renderizado.title
A função no Flask é uma forma de exibir mensagens temporárias para o usuário.

Ele normalmente é usado para exibir mensagens de sucesso ou erro após um
envio de formulário ou outra ação.flash
Para usar a função em um aplicativo Flask, você precisa configurar as

mensagens no aplicativo e exibi-las no modelo. flashflash
Aqui está um exemplo de como usar a função em um aplicativo Flask: flash
from flask import Flask, flash, render_template, request, redirect
app.secret_key = 'some secret key'
@app.route('/')
def index():
return render_template('index.html')
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
if request.form['username'] == 'admin' and request.form['password'] == 'secret':
flash('You were successfully logged in')
return redirect('/')
else:
flash('Invalid username or password')
return render_template('login.html')
if __name__ == '__main__':
app.run()
Neste exemplo, temos uma rota que lida com solicitações GET e POST. Se o
método de solicitação for POST, a função verificará o nome de usuário e a
senha enviados no formulário e exibirá uma mensagem de êxito ou erro usando
a função. A função usa uma mensagem como um argumento e a armazena em
uma sessão.loginflashflash
Para exibir as mensagens flash no modelo, você pode usar um bloco de modelo
Jinja para iterar sobre as mensagens flash e exibi-las:
{% for message in get_flashed_messages() %}
<div class="alert alert-danger">{{ message }}</div>
{% endfor %}
Neste exemplo, a função retorna uma lista de mensagens flash armazenadas na sessão
e o loop itera sobre as mensagens e as exibe em um elemento com as classes
and.get_flashed_messagesfordivalertalert-danger
A função no Flask é uma maneira de gerar URLs para rotas específicas no

aplicativo. Ele usa o nome da rota e quaisquer argumentos adicionais e retorna
a URL dessa rota.url_for
Aqui está um exemplo de como usar a função em um aplicativo Flask: url_for
from flask import Flask, render_template, url_for
@app.route('/')
def index():
return render_template('index.html')
@app.route('/login')
def login():
return 'Login page'
@app.route('/user/<username>')
def profile(username):
return 'Profile page for user {}'.format(username)
if __name__ == '__main__':
app.run()
Neste exemplo, temos três rotas: , , e . Para gerar as URLs para essas rotas, você pode
usar a função em um modelo ou função de exibição: //login/user/<username>url_for
# In a template
<a href="{{ url_for('index') }}">Home</a>
<a href="{{ url_for('login') }}">Login</a>
<a href="{{ url_for('profile', username='john') }}">John's profile</a>
# In a view function
return redirect(url_for('index'))
No exemplo de modelo, a função gera as URLs para o , e roteia e passa o

argumento para a rota. No exemplo da função de exibição, a função gera a URL
da rota e redireciona o cliente para essa
URL.url_forindexloginprofileusernameprofileurl_forindex
Espero ter ajudado! Deixe-me saber se você tiver alguma dúvida.
Flask-SQLAlchemy é uma extensão Flask que adiciona suporte para a biblioteca

SQLAlchemy ao seu aplicativo Flask. Ele permite que você use a poderosa
biblioteca principal SQLAlchemy para se conectar a bancos de dados, definir
modelos e consultar dados, tudo de dentro de um aplicativo Flask.
Aqui está um exemplo de como usar o Flask-SQLAlchemy em um aplicativo

Flask:
from flask_sqlalchemy import SQLAlchemy
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://localhost/mydatabase'
db = SQLAlchemy(app)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
db.create_all()
Neste exemplo, importamos as extensões Flask e Flask-SQLAlchemy e criamos

um aplicativo Flask. Em seguida, configuramos a configuração para apontar
para nosso banco de dados e criar uma instância passando-a pelo aplicativo
Flask.SQLALCHEMY_DATABASE_URISQLAlchemy
Em seguida, definimos um modelo que representa um usuário em nosso banco

de dados. O modelo tem três campos: , , e . Definimos esses campos como
objetos e especificamos seus tipos de dados e quaisquer opções adicionais,
como se eles são anuláveis ou exclusivos.Useridusernameemaildb.Column
Finalmente, chamamos o método do objeto para criar as tabelas no banco de
dados.create_alldb
Em seguida, você pode usar o modelo para criar, ler, atualizar e excluir usuários
no banco de dados. Por exemplo:User
# Create a new user
new_user = User(username='john', email='john@example.com')
db.session.add(new_user)
db.session.commit()
# Query users
users = User.query.all()
print(users)
# Update a user
user = User.query.get(1)
user.email = 'john@example.net'
db.session.commit()
# Delete a user
user = User.query.get(1)
db.session.delete(user)
db.session.commit()

Tutorial Flask

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Tutorial Flask

Uploaded by

Copyright:

Available Formats

TUTORIAL FLASK.

from flask import Flask

return ’Hello World!’

The file has to be stored on the filesystem as static/style.css.

from flask import Flask, render_template

return render_template(’hello.html’, name=name)

Hello {{ name }}!

from flask import Flask, request

@app.route(’/upload’, methods=[’GET’, ’POST’])

from flask import Flask, abort, redirect, url_for

from flask import Flask, session, redirect, url_for, escape, request

Fornecer um arquivo estático do código (JSON)

Usar um arquivo estático em um modelo

<title>{{ title }}</title>

<link rel="stylesheet" type="text/css" href="/static/site.css" />

<span class="message">{{ message }}</span>{{ content }}

from datetime import datetime

from flask import render_template

from HelloFlask import app

formatted_now = now.strftime("%A, %d %B, %Y at %X")

html_content = "<html><head><title>Hello Flask</title></head><body>"

html_content += "<strong>Hello Flask!</strong> on " + formatted_now

Usando o método render_template

formatted_now = now.strftime("%A, %d %B, %Y at %X")

content = "<strong>Hello, Flask!</strong> on " + formatted_now)

<title>{{ title }}</title>

<strong>{{ message }}</strong>{{ content }}

formatted_now = now.strftime("%A, %d %B, %Y at %X")

title = "Hello Flask",

message = "Hello, Flask!",

content = " on " + formatted_now)

from flask import jsonify, Flask

Flask-SQLAlchemy é uma extensão Flask que fornece suporte para a biblioteca

Para usar o Flask-SQLAlchemy, você precisará instalar o Flask e o SQLAlchemy.

pip install flask sqlalchemy

Depois de ter essas bibliotecas instaladas, você pode usar o Flask-SQLAlchemy

from flask import Flask, render_template

# Convert plot to PNG image

# Render the template

No modelo, podemos exibir a imagem usando uma tag: <img>

Neste exemplo, importamos as extensões Flask e Flask-Matplotlib e criamos um

Em seguida, definimos uma rota que exibe um gráfico Matplotlib. Criamos um

Para renderizar o gráfico em um navegador da Web, você pode usar a função

return render_template('plot.html', plot=plot_html)

import matplotlib.pyplot as plt

from flask import send_file

return send_file(img, mimetype='image/png')

Para renderizar um modelo em um aplicativo Flask, você pode usar a função do

Aqui está um exemplo de como renderizar um modelo em um aplicativo Flask:

from flask import Flask, render_template

return render_template('index.html', title='Home')

Os modelos são normalmente armazenados em uma pasta no diretório raiz do

<title>{{ title }}</title>

<h1>Welcome to the {{ title }} page!</h1>

A função no Flask é uma forma de exibir mensagens temporárias para o usuário.

Para usar a função em um aplicativo Flask, você precisa configurar as

Aqui está um exemplo de como usar a função em um aplicativo Flask: flash

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

app.secret_key = 'some secret key'

@app.route('/login', methods=['GET', 'POST'])

if request.form['username'] == 'admin' and request.form['password'] == 'secret':

flash('You were successfully logged in')

flash('Invalid username or password')