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 = Flask(__name__)
@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():
now = datetime.now()
formatted_now = now.strftime("%A, %d %B, %Y at %X")
return render_template(
"index.html",
content = "<strong>Hello, Flask!</strong> on " + formatted_now)
<html>
<head>
<title>{{ title }}</title>
</head>
<body>
<strong>{{ message }}</strong>{{ content }}
</body>
</html>
def home():
now = datetime.now()
formatted_now = now.strftime("%A, %d %B, %Y at %X")
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 = Flask(__name__)
@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 = Flask(__name__)
@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 import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
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:
from flask import Flask, render_template
import matplotlib.pyplot as plt
import io
import base64
app = Flask(__name__)
@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 import Flask
from flask_matplotlib import Matplotlib
import matplotlib.pyplot as plt
app = Flask(__name__)
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
import matplotlib.pyplot as plt
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:
from flask import Flask, render_template
app = Flask(__name__)
@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>
<title>{{ title }}</title>
</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 = Flask(__name__)
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 = Flask(__name__)
@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 import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
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()
