Usando modelos no Flask

Um aplicativo da web requer uma parte que o usuário possa ver, que é chamada Visão ou visualizar e consiste em uma interface escrita em HTML que nos permite mostrar dados estáticos e dinâmicos de acordo com o caminho que o usuário acessa.
Quando trabalhamos com microframeworks como Frasco, por padrão não é necessário exibir a visualização para usar elementos adicionais, retornando apenas o código HTML correspondente, podemos alcançar para mostrar dados consistentes.
O problema surge quando nossa aplicação começa a crescer e temos várias visualizações, a repetição do código preenche nossa aplicação com elementos que poderíamos reutilizar e que fazê-lo manualmente representa um trabalho maior para nós. Para evitar este problema, temos o motores de template, que nos ajudam a reutilizar os arquivos HTML e assim reduzir a quantidade de código, além de aumentar a legibilidade do nosso programa.
Jinja2 é um mecanismo de template escrito inteiramente em Pitão e foi modelado após o mecanismo de template de Django, isso nos permite colocar partes do código HTML e com o próprio código do motor, inclua rótulos que posteriormente serão substituídos por dados de nosso aplicativo.
O que mais isso inclui?Inclui também funções próprias que nos ajudam a formatar os dados que recebemos, além de tratar condicionais, funções de data e outros elementos que nos ajudam a programar o comportamento do template de forma simples e expressiva.
Na última versão do Frasco Este motor está incluso na instalação para que seu uso seja mais fácil e rápido.
Havíamos discutido a criação de uma visualização em Frasco era tão simples quanto imprimir o código HTML na função de caminho desejada, no entanto, para aqueles que são novos neste framework, isso pode parecer muito confuso.
No exemplo a seguir vamos criar uma view onde iremos receber um parâmetro e imprimi-lo no resultado, o interessante é que este parâmetro pode ser inserido pelo usuário, então a view é dinâmica até certo ponto, vamos ver o código e depois passaremos para a explicação:

 from flask import Flaskapp = Flask (__ name __) @ app.route ('/') @ app.route ('/ welcome') @ app.route ('/ welcome /') def welcome (name = None): name = nome ou 'Usuário' return '' 'Bem-vindo!
Essa é a nossa visão feita no Flask!

'' '% ifname __name__ ==' __main__ ': app.run ()

Aqui o que fazemos é algo muito simples, primeiro importamos as bibliotecas que contêm o estrutura, então definimos três rotas principais, todas elas nos conduzem à mesma função chamada welcome e recebem um parâmetro opcional onde se não for recebido será simplesmente ignorado dentro do programa.
Então, na função, criamos nossa instrução Retorna e aqui indicamos que um Corda contendo o HTML para a vista. Se testarmos este programa obteremos um resultado aceitável no navegador, vejamos:

Muitos podem dizer que isso é muito funcional, mas o que acontece se, em vez de mostrar aquela página em branco, quisermos integrar estilos CSS, efeitos JavaScript ou outras coisas. Então, nosso HTML precisaria de mais código e, portanto, tudo seria muito complicado, tornando nosso aplicativo um inferno de manusear.
Agora vamos criar a mesma visão, mas usando o template engine que descrevemos no início do tutorial, para conseguir o exemplo devemos fazer alguns preparativos, estes têm a ver com a estrutura do nosso projeto, pois se formos para usar arquivos de modelo, é melhor separá-los do aplicativo em outras pastas e, assim, dividir nossa camada visual das regras de negócios e da camada lógica.
Sabendo disso, devemos criar uma pasta para os nossos modelos, por convenção vamos chamá-la de modelos, porém devemos ter também outras coisas, por exemplo, devemos ter uma pasta que servirá de módulo e a chamaremos com o nome da view que vamos criar, além disso temos que ter alguns arquivos, na próxima imagem veremos a estrutura completa e depois iremos ao código pertinente para fazer tudo funcionar.

Conteúdo do arquivoAntes de passarmos à geração e utilização do template, devemos ver o conteúdo dos arquivos que farão nosso aplicativo funcionar sem problemas, veremos brevemente cada arquivo para não perder muito tempo. É importante notar que esta é uma estrutura sugerida, no entanto Frasco permite que cada desenvolvedor faça a estrutura que melhor lhe convier de acordo com seu objetivo.
Este arquivo é o que nos permite executar o aplicativo, daí seu nome, geralmente pode ser chamado run.py Além disso, mas para os fins deste tutorial, colocamos um nome que seja mais compreensível para a comunidade de língua espanhola, aqui devemos colocar o seguinte código:

 de flasko import appapp.run (debug = True)

Este é o arquivo que está na raiz da aplicação, é necessário poder estabelecer que se vai executar e suas dependências, neste arquivo é onde também definimos que o arquivo se vai utilizar views.py da pasta de boas-vindas que vimos antes, ela pode ter qualquer nome, exceto views.py É uma convenção que nos ajudará a manter uma aplicação amigável, aqui devemos colocar o seguinte:

 from flask import Flaskapp = Flask (__ name __) import flasko.bienvenido.views

Este arquivo deve estar vazio, pois só precisamos que ele exista para que Frasco interpretar que esta pasta é um módulo de nosso aplicativo.
Uma vez que temos os arquivos base para nosso aplicativo, é hora de criar a visualização e usar o modelo. A primeira coisa que faremos é criar nossa visão, esta será muito parecida com a visão anterior mas melhorada, para isso devemos trabalhar no arquivo views.py e coloque o seguinte:

 from flask import render_template, requestfrom flasko import [email protected] ('/') @ app.route ('/ welcome') def welcome_web (): name = request.args.get ('name', 'User') return render_template ('index.html', name = name)

A primeira coisa que fazemos é importar a biblioteca do framework que nos permite mostrar os modelos e uma biblioteca para processar as solicitações do navegador.
Em seguida, definimos as rotas que farão aparecer esta vista, neste caso é a raiz / e também quando a palavra é colocada Bem-vinda.
Finalmente, definimos nossa função Bem-vinda que atribui ao nome da variável os parâmetros obtidos na solicitação do navegador e então fazemos um retorno da função render_template, é este que irá chamar o template e passar o nome da variável como parâmetros, onde também indicamos o nome do template.
É hora de criar o modelo, este é basicamente um arquivo com conteúdo HTML e com algumas tags que nos ajudarão a dar dinamismo, o arquivo a modificar é o index.html que está na pasta modelos, vamos ver o código que usaremos:

 Bem-vindo {{name}}
Estamos usando o Flask!

Este código é simples, fazemos nosso HTML básico e, em seguida, onde queremos que o conteúdo gerado apareça na visualização, basta colocar colchetes {{}} e dentro, o nome do parâmetro, isso significa que quando a aplicação é executada, este valor é substituído pelo conteúdo que queremos. Se observarmos na imagem a seguir, perceberemos como se coloca o nome que passamos como parâmetro através da URL:

Não só podemos usar parâmetros, também podemos criar dicionários Pitão com dados provenientes de uma fonte de persistência como um Base de dados ou algo semelhante e assim poder colocar ainda mais dados.
Modelos diferentesO interessante sobre este assunto é que podemos brincar com diferentes modelos para diferentes partes de nossa aplicação, isso separa a camada de apresentação pura do que realmente programamos, removendo o HTML a partir do meio, podemos nos separar em duas equipes e, assim, trabalhar adequadamente sem confusão.
Com isso terminamos este tutorial, aprendemos a usar os modelos em aplicativos feitos com Frasco, esta forma de trabalhar nos poupará esforços e repetição de código, especialmente se contarmos com a documentação oficial do Jinja2 para obter o máximo do mecanismo de modelo. É muito importante estabelecer uma estrutura de projeto e separar os diferentes tipos de arquivos, pois assim manteremos um projeto amigável para o resto de nossa equipe de desenvolvimento ou no caso de querermos carregá-lo para uma rede de código como GitHub para compartilhar o trabalho realizado com a comunidade.