Bruke maler i Flask

En webapplikasjon krever en del som brukeren kan se som kalles utsikt eller visning og består av et grensesnitt skrevet inn HTML som lar oss vise statiske og dynamiske data i henhold til banen som brukeren får tilgang til.
Når vi jobber med mikrorammer som Kolbe, som standard er det ikke nødvendig å vise visningen for å bruke flere elementer, bare returnere koden HTML tilsvarende kan vi oppnå for å vise konsistente data.
Problemet oppstår når applikasjonen vår begynner å vokse og vi har flere visninger, gjentagelsen av koden fyller applikasjonen vår med elementer som vi kan gjenbruke, og at det å gjøre det manuelt representerer et større arbeid for oss. For å unngå dette problemet har vi malmotorer, som hjelper oss med å gjenbruke filene HTML og dermed redusere mengden kode i tillegg til å øke lesbarheten til programmet vårt.
Jinja2 er en malmotor skrevet helt inn Python og ble modellert etter malmotoren til Django, dette lar oss plassere deler av koden HTML og med motorens egen kode, ta med etiketter som senere vil bli erstattet av data fra applikasjonen vår.
Hva mer inneholder det?Den inneholder også sine egne funksjoner som hjelper oss med å formatere dataene vi mottar, i tillegg til å håndtere betingelser, datofunksjoner og andre elementer som hjelper oss å programmere oppførselen til malen på en enkel og uttrykksfull måte.
I den siste versjonen av Kolbe Denne motoren er inkludert i installasjonen, så bruken er enklere og raskere.
Vi hadde diskutert å skape en visning i Kolbe det var så enkelt som å skrive ut koden HTML i ønsket bane -funksjon, men for de som er nye i dette rammeverket kan dette høres veldig forvirrende ut.
I det følgende eksemplet skal vi lage en visning der vi vil motta en parameter og skrive den ut i resultatet, det interessante er at denne parameteren kan angis av brukeren, så visningen er dynamisk til et bestemt punkt, la oss se koden, og så går vi videre til forklaringen:

 fra kolbeimport Flaskapp = Kolbe (__ navn __) @ app.route ('/') @ app.route ('/ velkommen') @ app.route ('/ velkommen/') def velkommen (navn = Ingen): navn = navn eller 'Bruker' retur '' 'Velkommen!
Dette er vårt syn gjort i Flask!

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

Her er det vi gjør noe veldig enkelt, først importerer vi bibliotekene som inneholder rammeverk, så definerer vi tre viktige ruter, alle av dem fører oss til den samme funksjonen som kalles velkommen og mottar en parameter som er valgfri der hvis den ikke blir mottatt, blir den ganske enkelt ignorert i programmet.
Så i funksjonen lager vi vår instruksjon komme tilbake og her indikerer vi at a String som inneholder HTML for utsikten. Hvis vi tester dette programmet, får vi et akseptabelt resultat i nettleseren, la oss se:

Mange kan si at dette er veldig funksjonelt, men hva skjer hvis vi i stedet for å vise den tomme siden ønsker å integrere CSS -stiler, JavaScript -effekter eller andre ting. Da ville HTML -koden vår ta mer kode, og derfor ville alt være altfor komplisert, noe som ville gjøre applikasjonen vår helvete å håndtere.
Nå skal vi lage den samme visningen, men ved å bruke malmotoren som vi har beskrevet i begynnelsen av opplæringen, for å oppnå eksemplet må vi gjøre noen forberedelser, disse har å gjøre med strukturen i prosjektet vårt, siden hvis vi er Når du skal bruke malfiler, er det best å skille dem fra applikasjonen til andre mapper og dermed dele vårt visuelle lag fra forretningsreglene og logikklaget.
Når vi vet dette, må vi lage en mappe for malene våre, for konvensjonelle formål vil vi kalle det maler, men vi må også ha andre ting, for eksempel må vi ha en mappe som skal fungere som en modul, og vi vil kalle den med navnet av visningen som vi skal lage, I tillegg til at vi må ha noen filer, i det neste bildet vil vi se hele strukturen, og deretter vil vi gå til den relevante koden for å få alt til å fungere.

FilinnholdFør vi går videre til generering og bruk av malen, må vi se innholdet i filene som får programmet vårt til å kjøre uten problemer, vi vil kort se hver fil for ikke å kaste bort mye tid. Det er imidlertid viktig å merke seg at dette er en foreslått struktur Kolbe lar hver utvikler lage den strukturen som passer ham best i henhold til hans mål.
Denne filen er den som lar oss kjøre applikasjonen, derav navnet, den kan vanligvis kalles run.py Også, men for formålet med denne opplæringen legger vi et navn som er mer forståelig for det spansktalende samfunnet, her må vi plassere følgende kode:

 fra flasko import appapp.run (debug = True)

Dette er filen som er i roten til applikasjonen, det er nødvendig for å kunne fastslå at den skal kjøres og dens avhengigheter, i denne filen er der vi også definerer at filen skal brukes views.py av velkomstmappen som vi har sett før, kan dette ha noe annet enn views.py Det er en konvensjon som vil hjelpe oss med å opprettholde en vennlig applikasjon, her må vi plassere følgende:

 fra kolbeimport Flaskapp = Kolbe (__ navn __) import flasko.bienvenido.views

Denne filen må være tom siden vi bare trenger den for å eksistere slik at Kolbe tolke at denne mappen er en modul i applikasjonen vår.
Siden vi har basisfilene for applikasjonen vår, er det på tide å lage visningen og bruke malen. Det første vi skal gjøre er å lage vårt syn, dette vil være veldig likt det forrige, men forbedret, for dette må vi jobbe i filen views.py og legg inn følgende:

 fra kolbeimport 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)

Det første vi gjør er fra rammeverket å importere biblioteket som lar oss vise malene og et bibliotek for å behandle nettleserforespørslene.
Deretter definerer vi rutene som skal få denne visningen til å vises, i dette tilfellet er det roten / og også når ordet plasseres Velkommen.
Til slutt definerer vi vår funksjon Velkommen som tilordner variabelnavnet parametrene hentet fra nettleserforespørselen, og deretter returnerer vi funksjonen render_template, dette er den som vil kalle malen og passere variabelnavnet som parametere, hvor vi også angir navnet på malen.
Det er på tide å lage malen, dette er i utgangspunktet en fil med innhold HTML og med noen koder som vil hjelpe oss å gi den dynamikk, er filen som skal endres index.html som er i mappen maler, la oss se koden vi skal bruke:

 Velkommen {{name}}
Vi bruker Flask!

Denne koden er enkel, vi lager vår HTML grunnleggende, og der vi vil at det genererte innholdet skal vises i visningen, plasserer vi bare doble seler {{}} og inne, navnet på parameteren, betyr dette at når programmet kjøres, blir denne verdien erstattet med innholdet vi ønsker. Hvis vi ser i det følgende bildet, vil vi innse hvordan navnet vi sender som en parameter gjennom URL -en er plassert:

Ikke bare kan vi bruke parametere, vi kan også lage ordbøker Python med data som kommer fra en utholdenhetskilde som en Database eller noe lignende og på denne måten å kunne plassere enda flere data.
Ulike malerDet interessante med denne saken er at vi kan leke med forskjellige maler for forskjellige deler av applikasjonen vår, dette skiller det rene presentasjonslaget fra det vi faktisk programmerer, ved å fjerne HTML fra midten kan vi dele oss i to lag og dermed fungere skikkelig uten forvirring.
Med dette fullfører vi denne opplæringen, vi har lært å bruke malene i applikasjoner laget med Kolbe, vil denne måten å jobbe spare oss krefter og gjentagelse av kode, spesielt hvis vi er avhengige av den offisielle dokumentasjonen til Jinja2 for å få mest mulig ut av malmotoren. Det er veldig viktig å etablere en prosjektstruktur og skille de forskjellige filtypene, siden vi på denne måten vil opprettholde et vennlig prosjekt for resten av vårt utviklingsteam eller i tilfelle vi ønsker å laste det opp til et kodenettverk som f.eks. GitHub for å dele arbeidet som er gjort med samfunnet.