Sjablonen gebruiken in Flask

Een webapplicatie vereist een onderdeel dat de gebruiker kan zien en dat heet weergave of bekijken en bestaat uit een interface geschreven in HTML waarmee we statische en dynamische gegevens kunnen weergeven volgens het pad dat de gebruiker opent.
Wanneer we werken met microframeworks zoals Kolf, standaard is het niet nodig om de weergave weer te geven om extra elementen te gebruiken, alleen de code terug te geven HTML overeenkomende die we kunnen bereiken om consistente gegevens te tonen.
Het probleem doet zich voor wanneer onze applicatie begint te groeien en we verschillende weergaven hebben, de herhaling van de code onze applicatie vult met elementen die we kunnen hergebruiken en dat het handmatig doen een groter werk voor ons is. Om dit probleem te voorkomen hebben we de sjabloonmotoren, die ons helpen de bestanden opnieuw te gebruiken HTML en zo de hoeveelheid code te verminderen en de leesbaarheid van ons programma te vergroten.
Jinja2 is een sjabloon-engine die volledig is geschreven in Python en is gemodelleerd naar de template engine van Django, dit stelt ons in staat om delen van code te plaatsen HTML en met de eigen code van de motor, labels opnemen die later zullen worden vervangen door gegevens uit onze applicatie.
Wat houdt het nog meer in?Het bevat ook zijn eigen functies die ons helpen bij het opmaken van de gegevens die we ontvangen, naast het omgaan met voorwaarden, datumfuncties en andere elementen die ons helpen om het gedrag van de sjabloon op een eenvoudige en expressieve manier te programmeren.
In de nieuwste versie van Kolf Deze motor is inbegrepen in de installatie, zodat het gebruik ervan gemakkelijker en sneller is.
We hadden het gehad over het maken van een weergave in Kolf het was zo simpel als het printen van de code HTML in de gewenste padfunctie, maar voor degenen die nieuw zijn in dit raamwerk kan dit erg verwarrend klinken.
In het volgende voorbeeld gaan we een weergave maken waarin we een parameter ontvangen en deze in het resultaat afdrukken, het interessante is dat deze parameter door de gebruiker kan worden ingevoerd, dus de weergave is dynamisch tot een bepaald punt, laten we eens kijken de code en dan gaan we naar de uitleg:

 from flask import Flaskapp = Flask (__ naam __) @ app.route ('/') @ app.route ('/ welkom') @ app.route ('/ welkom /') def welkom (naam = Geen): naam = naam of 'Gebruiker' return '' 'Welkom!
Dit is ons uitzicht gemaakt in Flask!

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

Wat we hier doen is iets heel eenvoudigs, eerst importeren we de bibliotheken die de . bevatten kader, dan definiëren we drie belangrijke routes, ze leiden ons allemaal naar dezelfde functie genaamd welkom en ontvangt een parameter die optioneel is, en als deze niet wordt ontvangen, wordt deze gewoon genegeerd in het programma.
Vervolgens maken we in de functie onze instructie opbrengst en hier geven we aan dat a Draad met daarin de HTML voor het uitzicht. Als we dit programma testen, krijgen we een acceptabel resultaat in de browser, laten we eens kijken:

Velen zullen misschien zeggen dat dit erg functioneel is, maar wat gebeurt er als we in plaats van die lege pagina te tonen, CSS-stijlen, JavaScript-effecten of andere dingen willen integreren. Dan zou onze HTML meer code vergen en daarom zou alles te ingewikkeld zijn, waardoor onze applicatie een hel zou worden.
Nu gaan we dezelfde weergave maken, maar met behulp van de sjabloon-engine die we aan het begin van de tutorial hebben beschreven, om het voorbeeld te bereiken, moeten we enkele voorbereidingen treffen, deze hebben te maken met de structuur van ons project, want als we Als je sjabloonbestanden gaat gebruiken, kun je ze het beste van de applicatie scheiden in andere mappen en daarmee onze visuele laag scheiden van de bedrijfsregels en de logische laag.
Als we dit weten, moeten we een map maken voor onze sjablonen, voor conventiedoeleinden zullen we het sjablonen noemen, maar we moeten ook andere dingen hebben, we moeten bijvoorbeeld een map hebben die als een module zal dienen en we zullen het met de naam noemen van de weergave die we gaan maken, behalve dat we enkele bestanden moeten hebben, zullen we in de volgende afbeelding de volledige structuur zien en dan gaan we naar de relevante code om alles te laten werken.

BestandsinhoudVoordat we verder gaan met het genereren en gebruiken van de sjabloon, moeten we de inhoud van de bestanden zien die ervoor zorgen dat onze applicatie zonder problemen kan werken, we zullen elk bestand kort bekijken om niet veel tijd te verspillen. Het is echter belangrijk op te merken dat dit een voorgestelde structuur is Kolf stelt elke ontwikkelaar in staat om de structuur te maken die het beste bij hem past volgens zijn doel.
Dit bestand is het bestand waarmee we de applicatie kunnen uitvoeren, vandaar de naam, het kan over het algemeen worden aangeroepen run.py Ook, maar voor de doeleinden van deze tutorial plaatsen we een naam die begrijpelijker is voor de Spaanstalige gemeenschap, hier moeten we de volgende code plaatsen:

 van flasko import appapp.run (debug = True)

Dit is het bestand dat zich in de hoofdmap van de applicatie bevindt, het is noodzakelijk om vast te stellen dat het zal worden uitgevoerd en zijn afhankelijkheden, in dit bestand definiëren we ook dat het bestand zal worden gebruikt views.py van de welkomstmap die we eerder hebben gezien, deze kan elke naam hebben, behalve views.py Het is een conventie die ons zal helpen een vriendelijke applicatie te behouden, hier moeten we het volgende plaatsen:

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

Dit bestand moet leeg zijn, omdat we het alleen nodig hebben om te bestaan, zodat: Kolf interpreteer dat deze map een module van onze applicatie is.
Aangezien we de basisbestanden voor onze applicatie hebben, is het tijd om de weergave te maken en de sjabloon te gebruiken. Het eerste dat we zullen doen is onze weergave maken, deze zal erg lijken op de vorige weergave, maar verbeterd, hiervoor moeten we in het bestand werken views.py en plaats het volgende:

 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', naam = naam)

Het eerste wat we doen is vanuit het framework de bibliotheek importeren waarmee we de sjablonen en een bibliotheek kunnen tonen om de browserverzoeken te verwerken.
Vervolgens definiëren we de routes die deze weergave zullen laten verschijnen, in dit geval is het de root / en ook wanneer het woord wordt geplaatst Welkom.
Eindelijk definiëren we onze functie Welkom die aan de variabelenaam de parameters toewijst die zijn verkregen uit het browserverzoek en dan maken we een terugkeer van de functie render_template, dit is degene die de sjabloon aanroept en de variabelenaam als parameters doorgeeft, waarbij we ook de naam van de sjabloon aangeven.
Het is tijd om de sjabloon te maken, dit is eigenlijk een bestand met inhoud HTML en met enkele tags die ons zullen helpen om het dynamiek te geven, is het te wijzigen bestand de index.html die in de map zit Sjablonen, laten we de code bekijken die we zullen gebruiken:

 Welkom {{naam}}
We gebruiken Flask!

Deze code is eenvoudig, we maken onze HTML basic en dan waar we willen dat de gegenereerde inhoud in de weergave verschijnt, plaatsen we gewoon dubbele accolades {{}} en binnenin, de naam van de parameter, betekent dit dat wanneer de toepassing wordt uitgevoerd, deze waarde wordt vervangen door de inhoud die we willen. Als we in de volgende afbeelding zien, zullen we ons realiseren hoe de naam die we als parameter via de URL doorgeven, wordt geplaatst:

We kunnen niet alleen parameters gebruiken, we kunnen ook woordenboeken maken Python met gegevens afkomstig van een persistentiebron zoals a Database of iets dergelijks en op deze manier nog meer data te kunnen plaatsen.
Verschillende sjablonenHet interessante aan deze zaak is dat we kunnen spelen met verschillende sjablonen voor verschillende delen van onze applicatie, dit scheidt de pure presentatielaag van wat we eigenlijk programmeren, door het verwijderen van de HTML vanuit het midden kunnen we ons in twee teams splitsen en zo goed werken zonder verwarring.
Hiermee ronden we deze tutorial af, we hebben geleerd om de sjablonen te gebruiken in applicaties gemaakt met Kolf, zal deze manier van werken ons moeite en herhaling van code besparen, vooral als we vertrouwen op de officiële documentatie van Jinja2 om het meeste uit de sjabloonengine te halen. Het is erg belangrijk om een ​​projectstructuur op te zetten en de verschillende soorten bestanden te scheiden, omdat we op deze manier een vriendelijk project behouden voor de rest van ons ontwikkelteam of in het geval dat we het willen uploaden naar een codenetwerk zoals GitHub om het gedane werk met de community te delen.