Använda mallar i Flask

Ett webbprogram kräver en del som användaren kan se som kallas se eller visa och består av ett gränssnitt skrivet in HTML som gör att vi kan visa statisk och dynamisk data enligt den sökväg som användaren kommer åt.
När vi arbetar med mikroramverk som Flaska, som standard är det inte nödvändigt att visa vyn för att använda ytterligare element, bara returnera koden HTML motsvarande kan vi uppnå för att visa konsekventa data.
Problemet uppstår när vår applikation börjar växa och vi har flera synpunkter, upprepningen av koden fyller vår applikation med element som vi kan återanvända och att göra det manuellt representerar ett större arbete för oss. För att undvika detta problem har vi mallmotorer, som hjälper oss att återanvända filerna HTML och därmed minska mängden kod utöver att öka läsbarheten för vårt program.
Jinja2 är en mallmotor helt skriven i Pytonorm och modellerades efter mallmotorn av Django, detta gör att vi kan placera delar av kod HTML och med motorns egen kod, inkludera etiketter som senare kommer att ersättas med data från vår applikation.
Vad innehåller den mer?Den innehåller också egna funktioner som hjälper oss att formatera data vi får, förutom att hantera villkor, datumfunktioner och andra element som hjälper oss att programmera mallens beteende på ett enkelt och uttrycksfullt sätt.
I den senaste versionen av Flaska Denna motor ingår i installationen så att användningen blir enklare och snabbare.
Vi hade diskuterat att skapa en vy i Flaska det var lika enkelt som att skriva ut koden HTML i önskad sökfunktion, men för de som är nya inom detta ramverk kan detta låta mycket förvirrande.
I följande exempel ska vi skapa en vy där vi kommer att ta emot en parameter och skriva ut den i resultatet, det intressanta är att denna parameter kan anges av användaren, så vyn är dynamisk till en viss punkt, låt oss se koden och sedan går vi vidare till förklaringen:

 från kolvimport Flaskapp = Kolv (__ namn __) @ app.route ('/') @ app.route ('/ välkommen') @ app.route ('/ välkommen/') def välkommen (namn = Ingen): namn = namn eller 'Användare' retur '' 'Välkommen!
Detta är vår uppfattning gjord i Flask!

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

Här är det vi gör mycket enkelt, först importerar vi biblioteken som innehåller ramverk, då definierar vi tre nyckelvägar, alla leder oss till samma funktion som kallas välkommen och får en parameter som är valfri där den om den inte tas emot helt enkelt ignoreras inom programmet.
Sedan i funktionen skapar vi vår instruktion lämna tillbaka och här anger vi att a Sträng som innehåller HTML för utsikten. Om vi ​​testar det här programmet får vi ett acceptabelt resultat i webbläsaren, låt oss se:

Många kanske säger att det här är mycket funktionellt, men vad händer om vi istället för att visa den tomma sidan vill integrera CSS -stilar, JavaScript -effekter eller andra saker. Då skulle vår HTML ta mer kod och därför skulle allt vara alltför komplicerat, vilket skulle göra vår applikation helvetet att hantera.
Nu ska vi skapa samma vy men med hjälp av mallmotorn som vi har beskrivit i början av handledningen, för att uppnå exemplet måste vi göra några förberedelser, dessa har att göra med strukturen i vårt projekt, eftersom om vi är kommer att använda mallfiler är det bäst att skilja dem från programmet till andra mappar och därigenom dela vårt visuella lager från affärsreglerna och logiklagret.
Genom att veta detta måste vi skapa en mapp för våra mallar, för konventionella ändamål kommer vi att kalla det mallar, men vi måste också ha andra saker, till exempel måste vi ha en mapp som fungerar som en modul och vi kommer att kalla den med namnet av den vy som vi ska skapa, Förutom att vi måste ha några filer, i nästa bild kommer vi att se hela strukturen och sedan gå till den relevanta koden för att få allt att fungera.

FilinnehållInnan vi går vidare till generering och användning av mallen måste vi se innehållet i filerna som får vår applikation att köras utan problem, vi kommer att se varje fil i korthet för att inte slösa mycket tid. Det är dock viktigt att notera att detta är en föreslagen struktur Flaska låter varje utvecklare göra den struktur som passar honom bäst enligt sitt mål.
Denna fil är den som tillåter oss att köra programmet, därav dess namn, det kan i allmänhet kallas run.py Men för denna handledning lägger vi ett namn som är mer förståeligt för det spansktalande samhället, här måste vi placera följande kod:

 från flasko import appapp.run (debug = True)

Det här är filen som är i roten till applikationen, det är nödvändigt för att kunna fastställa att den kommer att köras och dess beroenden, i den här filen är det där vi också definierar att filen ska användas views.py av välkomstmappen som vi har sett tidigare kan den ha vilket namn som helst views.py Det är en konvention som hjälper oss att behålla en vänlig applikation, här måste vi placera följande:

 från kolvimport Flaskapp = Kolv (__ namn __) importera flasko.bienvenido.views

Den här filen måste vara tom eftersom vi bara behöver den för att existera så att Flaska tolka att den här mappen är en modul i vår applikation.
Eftersom vi har basfilerna för vår applikation är det dags att skapa vyn och använda mallen. Det första vi kommer att göra är att skapa vår vy, den här kommer att likna den föregående vyn men förbättras, för detta måste vi arbeta i filen views.py och placera följande:

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

Det första vi gör är från ramverket att importera biblioteket som gör att vi kan visa mallarna och ett bibliotek för att behandla webbläsarförfrågningarna.
Därefter definierar vi de rutter som ska få denna vy att visas, i det här fallet är det roten / och även när ordet placeras Välkommen.
Slutligen definierar vi vår funktion Välkommen som tilldelar variabelnamnet parametrarna som erhållits från webbläsarens begäran och sedan återställer vi funktionen render_template, detta är den som kommer att anropa mallen och skicka variabelnamnet som parametrar, där vi också anger namnet på mallen.
Det är dags att skapa mallen, det här är i grunden en fil med innehåll HTML och med några taggar som hjälper oss att ge den dynamik, är filen att ändra den index.html som finns i mappen mallar, låt oss se koden som vi kommer att använda:

 Välkommen {{name}}
Vi använder Flask!

Denna kod är enkel, vi gör vår HTML grundläggande och sedan där vi vill att det genererade innehållet ska visas i vyn, placerar vi bara dubbla hängslen {{}} och inuti, namnet på parametern, betyder det att när programmet körs ersätts detta värde med det innehåll vi vill ha. Om vi ​​ser i följande bild kommer vi att inse hur namnet som vi skickar som en parameter via URL: en placeras:

Inte bara kan vi använda parametrar, vi kan också skapa ordböcker Pytonorm med data som kommer från en uthållighetskälla som en Databas eller något liknande och på så sätt kunna placera ännu mer data.
Olika mallarDet intressanta med den här frågan är att vi kan leka med olika mallar för olika delar av vår applikation, detta skiljer det rena presentationslagret från det vi faktiskt programmerar genom att ta bort HTML från mitten kan vi dela upp oss i två lag och därmed fungera ordentligt utan förvirring.
Med detta avslutar vi denna handledning, vi har lärt oss att använda mallarna i applikationer gjorda med Flaska, detta sätt att arbeta kommer att spara oss ansträngning och upprepning av kod, särskilt om vi litar på den officiella dokumentationen av Jinja2 för att få ut det mesta av mallmotorn. Det är mycket viktigt att etablera en projektstruktur och separera de olika filtyperna, eftersom vi på detta sätt kommer att behålla ett vänligt projekt för resten av vårt utvecklingsteam eller om vi vill ladda upp det till ett kodnätverk som t.ex. GitHub för att dela arbetet med gemenskapen.