Aan de slag met Flask, een Python microframework

In dit artikel introduceren we Flask, een populaire microframework voor Python die een alternatief biedt voor de reus die Django is.

Flask is ontworpen om lichtgewicht en flexibel te zijn, waardoor ontwikkelaars webapps snel en gemakkelijk kunnen maken. In dit artikel gaan we in op wat Flask is, zijn belangrijkste kenmerken, de voordelen van zijn eenvoudige API, zijn flexibiliteit bij het ondersteunen van derden-extensies, de meest voorkomende Flask-extensies en wanneer het wel en niet een goed moment is om Flask te gebruiken.

Belangrijkste Afhaalrestaurants

Wat is Flask?

Flask is een micro web framework geschreven in Python dat wordt gebruikt voor het ontwikkelen van webtoepassingen. Het is gebaseerd op een simpele filosofie van het houden van dingen simpel en lichtgewicht, waardoor ontwikkelaars alleen de belangrijkste tools krijgen die nodig zijn om web apps te bouwen zonder onnodige complexiteit.

Het is gebouwd op Werkzeug WSGI toolkit, die de web server functionaliteit biedt die nodig is voor het afhandelen van aanvragen en antwoorden, en de Jinja2 templating engine, die Flask de mogelijkheid geeft om HTML templates af te handelen, waardoor ontwikkelaars dynamische webtoepassingen kunnen creëren.

Hier zijn enkele van de belangrijkste kenmerken van Flask die het zo’n geweldig framework maken om mee te werken:

• Het heeft een eenvoudige API voor het maken van webroutes en het afhandelen van aanvragen.
• De Jinja-sjabloonengine biedt ondersteuning voor HTML-sjablonen, waardoor ontwikkelaars gemakkelijk webpagina’s kunnen maken.
• Het is zeer uitbreidbaar, vanwege de ondersteuning voor externe extensies, zodat een ontwikkelaar extensies kan installeren afhankelijk van de behoeften van hun project.
• Het is gebundeld met een ontwikkelingsserver die het gemakkelijk maakt om apps te testen en af te handelen.

Over het algemeen biedt Flask een krachtige, flexibele en toch eenvoudige framework voor het bouwen van webapplicaties. Het is een goede keuze voor zowel nieuwe als ervaren webontwikkelaars en is een van de meest populaire web frameworks in de Python-webontwikkelingsomgeving.

Voordelen van Flask

Laten we nu een gedetailleerdere blik werpen op enkele van de voordelen van het gebruik van Flask in ontwikkeling.

Eenvoud. De ontwerpfilosofie van Flask legt de nadruk op eenvoud, waardoor het gemakkelijk is voor ontwikkelaars op elk niveau om te begrijpen en te gebruiken. Dit betekent ook dat ontwikkelaars een zeer minimale leercurve hebben, aangezien ze slechts enkele concepten en API’s moeten leren om aan de slag te gaan met het bouwen van webapplicaties.

Flexibiliteit. De micro-aard van Flask – alleen de kernfuncties van een webframework bieden – geeft ontwikkelaars de mogelijkheid om het aan te passen en uit te breiden om hun vereisten te voldoen met behulp van Flask-extensies of externe bibliotheken.

Documentatie. De Flask-documentatie is zeer uitgebreid, met goede dekking van basis tot geavanceerde onderwerpen, waardoor het zeer gemakkelijk is voor ontwikkelaars om te leren hoe ze het framework moeten gebruiken.

Compatibiliteit. Flask is compatibel met een breed scala aan Python-versies, waardoor het gemakkelijk te gebruiken is met bestaande Python-codebases. Het biedt ook ondersteuning voor meerdere webservers, waardoor het eenvoudig is om het te implementeren op verschillende hostingplatforms.

Snelle ontwikkeling. De eenvoud en flexibiliteit van Flask verminderen de noodzaak voor kopijtekst om een toepassing op te zetten, waardoor ontwikkelaars snel aan de slag kunnen.

Op het web wordt Flask op veel interessante manieren gebruikt. Enkele opmerkelijke voorbeelden zijn:

• PgAdmin. Het Postgres-beheerinterface draait op een Flask-instantie, waardoor ontwikkelaars een interface krijgen waar ze hun Postgres-databases kunnen beheren.
• Twilio. Dit is een communicatieplatform dat Flask gebruikt in verschillende van zijn API’s.
• Pinterest. Dit fotodelingsplatform gebruikt Flask in de webontwikkelingsstack, waardoor het team gemakkelijk aangepaste functies en integraties kan maken.

Wanneer Flask gebruiken

De eenvoud en gebruiksvriendelijkheid van Flask maken het een uitstekende keuze voor een breed scala aan webprojecten:

• Prototyping. De gebruiksvriendelijkheid en flexibiliteit maken het een uitstekende keuze voor het snel maken van prototypes, waardoor ontwikkelaars nieuwe functies snel kunnen bouwen en testen.
• Het creëren van RESTful API’s. Zijn eenvoudige API maakt het gemakkelijk om HTTP-verzoeken te creëren en te beheren.
• E-commerce apps. Het werkt goed voor het bouwen van online marktplaatsen en e-commerceplatformen.
• Financieel. Het is handig voor het bouwen van financiële toepassingen, met accountbeheer, transactieverwerking en beleggingsvolgsysteem.
• AI. Het biedt een nuttige en eenvoudige manier om AI-trainingsmodellen te bouwen en in te zetten.

Wanneer niet te gebruiken Flask

Hoewel Flask een geweldig framework is en een aantal voordelen en geweldige functies heeft, zijn er situaties waarin deze functies tegenwerken. Laten we enkele van de projecten bekijken die beter bij andere soorten frameworks passen.

Projecten die ingebouwde functionaliteit vereisen. Als microframework biedt Flask alleen de kernonderdelen die nodig zijn om een webtoepassing te creëren. Als een project bijvoorbeeld een beheerdersinterface, authenticatie of een ORM vereist, dan is Django een betere optie.

Projecten met strikte beveiligingsvereisten. Aangezien Flask een flexibel framework is, moeten we vertrouwen op externe extensies om een zekere mate van beveiliging in onze apps te implementeren. Hoewel dit zeker werkt, is het beter om te vertrouwen op een meer beproefd framework dat een meer beveiligde aanpak hanteert, zoals Tornado of Twisted.

Projecten die een bepaalde programmeerstandaard afdwingen. Vanwege de flexibiliteit van Flask, laten ontwikkelingen ervan ontwikkelaars toe om apps op welke manier dan ook te maken die zij passend vinden. Echter, frameworks zoals Django zorgen ervoor dat ontwikkelaars zich aan een bepaalde conventie houden, wat betekent dat ontwikkelaars gemakkelijk van het ene project naar het andere kunnen gaan.

Het opzetten van een Flask ontwikkelomgeving

Laten we nu eens kijken hoe je aan de slag kunt gaan met Flask, van het instellen van de ontwikkelomgeving, de installatie, tot het opstarten van een minimale applicatie.

Vereisten

Python moet geïnstalleerd zijn op de ontwikkelmachine. Hier zijn instructies voor (hoewel we het misschien al geïnstalleerd hebben).

Een Virtuele Omgeving Aanmaken

A virtual environment is an isolated Python environment where we can install packages for a given project without affecting the global Python installation. (Here’s further discussion about why virtual environments are useful.) There are different packages for creating virtual environments in Python, such as virtualenv, venv, or Conda.

In dit artikel gebruiken we virtualenv. We kunnen het installeren met de volgende opdracht:

pip install virtualenv

Zodra virtualenv is geïnstalleerd, kunnen we een map maken waar onze Flask-applicatie zal zijn. We kunnen de map naar willekeur noemen – behalve Flask, want dat zal conflicten veroorzaken. We noemen de onze flask_intro:

mkdir flask_intro

Vervolgens gaan we naar die map zodat we ermee kunnen beginnen:

cd flask_intro

In die map gaan we nu onze virtuele omgeving maken met de volgende opdracht:

virtualenv myenv

De bovenstaande opdracht maakt een virtuele omgeving en noemt het myenv. Laten we deze activeren zodat we Flask erin kunnen installeren. Om de virtuele omgeving te activeren op Linux of macOS, gebruik de volgende opdracht:

. myenv/bin/activate

Op Windows, gebruik deze opdracht:

. myenv\Scripts\activate

Zodra onze virtuele omgeving is geactiveerd, zal het de naam van de virtuele omgeving laten zien in de shellprompt, vergelijkbaar met de uitvoer hieronder:

(myenv)/~(path to your project directory)$

Binnen onze geactiveerde virtuele omgeving kunnen we Flask gaan installeren met het volgende commando:

pip install Flask

Zodra Flask is geïnstalleerd, gaan we verder en maken we een minimale applicatie. We zullen een module maken die onze Flask-applicatie zal bevatten. Voor de eenvoud noemen we het hello.py. Op Linux of macOS kunnen we het volgende commando gebruiken om het bestand te maken in onze flask_intro directory:

touch hello.py

Het commando hierboven creëert een bestand met de naam hello.py. We kunnen ook een ontwikkelomgeving gebruiken om het bestand te maken. Zodra het bestand is gemaakt, plaats de onderstaande code erin en sla het op:

# hello.py
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello, World!'

In de bovenstaande code importeren we de Flask klasse uit het flask module, dan creëren we een instantie van Flask die we app noemen en passeren we de __name__ variabele.

Dan hebben we de route decorator @app.route(“\”), wat betekent dat de hello_world() functie wordt geactiveerd wanneer iemand de hoofdroute van onze applicatie bezoekt zodra deze wordt uitgevoerd.

Er zijn verschillende manieren waarop we de applicatie kunnen uitvoeren, dus laten we enkele van hen bekijken. De eerste manier is om het flask commando met een aantal argumenten te voorzien: --app, dan de naam van de module die onze Flask-applicatie bevat, en dan run. Zie hieronder:

flask –app <the name of your module> run

Gebruikmakend van het bovenstaande voorbeeld om onze voorbeeldapplicatie uit te voeren:

flask –app hello run

Dat zal onze applicatie op de standaardpoort 5000 laten draaien, zodat de applicatie beschikbaar is op http://localhost:5000/ of op http://127.0.0.1:5000/. Als we de applicatie op een andere poort willen laten draaien, kunnen we de poort opgeven met behulp van de -p of --port optie. Bijvoorbeeld:

flask --app hello run --port=8080

Dat zal de server op poort 8080 laten draaien. De andere manier om de applicatie te draaien, is gewoon met behulp van de flask run commando’s. Om dat te kunnen doen, moeten we Flask echter de naam van het module vertellen die de Flask-instantie zal bevatten, en dat doen we door de FLASK_APP omgevingsvariabele in te stellen. In ons geval bevindt de Flask-applicatie zich in een bestand genaamd hello.py. We kunnen het zo instellen:

export FLASK_APP=hello

Nu we de FLASK_APP omgevingsvariabele hebben ingesteld, kunnen we de ontwikkelingsserver zo opstarten:

flask run

Met dat code hebben we nu een webapplicatie draaien. Dit demonstreert de kernfilosofie van Flask: we hebben niet veel kopieer- en plakcode nodig om dingen op gang te brengen. De applicatie die we hierboven hebben ingesteld, is echter niet erg functioneel of nuttig, aangezien deze alleen de tekenreeks “Hello World!” op onze webpagina weergeeft. Om iets nuttigs te doen, kunnen we naar sjablonen grijpen. We zullen kijken hoe we ze kunnen aanpakken.

Flask Templates

Flask templates zijn een manier om dynamische webpagina’s te maken die verschillende inhoud kunnen weergeven op basis van verschillende factoren, zoals gegevens uit een database of gebruikersinput. Sjablonen in Flask zijn een combinatie van HTML en speciale tijdelijke aanduidingen genaamd template variabelen die worden vervangen door daadwerkelijke waarden tijdens runtime.

Sjablonen worden opgeslagen in de templates directory. Dus om sjablonen te gebruiken, moeten we de render_template() methode importeren van flask. De render_template() methode neemt een sjabloonnaam en eventuele optionele gegevens die aan de sjabloon moeten worden doorgegeven.

Laten we een voorbeeld bekijken van een functie die een sjabloon gebruikt om een webpagina weer te geven:

# index.py
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def index():
    title = 'Welcome to my website!'
    message = 'This is an example of using Flask templates.'
    return render_template('index.html', title=title, message=message)

In bovenstaand voorbeeld hebben we een view-functie – index() – die is gebonden aan de root-URL (“/”) door de @app.route() decorator. De functie heeft twee variabelen, title en message. Tot slot passen we de sjabloon index.html toe op de render_template(), samen met de title en message variabelen.

Voor het bovenstaande code om te werken, moeten we een index.html sjabloon hebben dat zich in een templates directory bevindt. Dus de sjabloon zal er ongeveer zo uitzien:

# index.html
<!doctype html>
<html>
<head>
    <title>{{ title }}</title>
</head>
<body>
    <h1>{{ title }}</h1>
    <p>{{ message }}</p>
</body>
</html>

In het index.html bestand worden de tijdelijke aanduidingen {{title}} en {{ message }} vervangen door de waarden die zijn doorgegeven aan de sjabloon in de render_template() methode.

Sjablonen kunnen ook complexere logica bevatten zoals if statements en for loops, waardoor meer dynamische pagina’s kunnen worden gegenereerd.

Dus sjablonen in Flask bieden ontwikkelaars een zeer krachtige optie voor het maken van dynamische webpagina’s die rijk zijn aan door de gebruiker gegenereerde informatie.

Flask Routing

De meeste webtoepassingen hebben meer dan één URL, dus we hebben een manier nodig om te weten welke functie welke URL behandelt. In Flask wordt deze mapping bekend als routing – het proces van het binden of inrichten van URLs aan weergavefuncties. Het binden van URLs aan weergavefuncties stelt de toepassing in staat om verschillende soorten aanvragen te verwerken, zoals GET, POST, PUT, DELETE en meer. Het stelt de toepassing ook in staat om meerdere aanvragen van verschillende clients te verwerken.

Om routes in Flask in te stellen, gebruiken we de route() decorator. De decorator bindt een URL aan een weergavefunctie – dus wanneer een gebruiker een URL bezoekt die in onze toepassing bestaat, activeert Flask de bijbehorende weergavefunctie om de aanvraag te verwerken.

Laten we een voorbeeld bekijken:

# hello.py
from flask import Flask, render_template

app = Flask(__name__)

@app.route("/about")
def about():
    return "This is the about page"

In bovenstaand voorbeeld definiëren we een over URL (/about). Wanneer de toepassing een aanvraag ontvangt voor de about URL, roept Flask de about() functie aan, die de tekenreeks “Dit is de over pagina” retourneert.

Tot nu toe gebruiken al deze voorbeelden, hoewel ze verschillende pagina’s retourneren, allemaal alleen de GET HTTP-aanvraag. Om in staat te zijn om specifieke aanvragen te verwerken, kunnen we de HTTP-methode als optioneel argument aan de route() decorator specificeren.

Laten we een voorbeeld bekijken van een PUT aanvraag:

from flask import Flask, request

app = Flask(__name__)

@app.route('/users/<int:user_id>', methods=['PUT'])
def update_user(user_id):
    # gebruik de gebruikersgegevens uit het aanvraaglichaam
    data = request.get_json()
    # doe iets met de gebruikersgegevens, zoals het bijwerken van de gebruiker in de database
    # ...
    # retourneer een antwoord dat aangeeft of het is geslaagd of mislukt
    return {'message': f'User {user_id} updated successfully'}, 200

In dit voorbeeld definiëren we een route die een PUT verzoek afhandelt om gebruikersgegevens bij te werken met hun user_id. We gebruiken <int:user_id> in de route om aan te geven dat de gebruikers-ID een integer moet zijn.

In de update_user() functie halen we de gebruikersgegevens uit het aanvraaglichaam met behulp van de request.get_json() methode. We doen iets met de gebruikersgegevens, zoals het bijwerken van de gebruiker in de database, en retourneren vervolgens een antwoord dat aangeeft of het is geslaagd of mislukt, samen met een HTTP-statuscode (een 200 in dit geval om succes te tonen).

Over het algemeen stelt routing Flask in staat om verschillende soorten verzoeken af te handelen en stelt ons toepassing in staat om op verschillende manieren op gegevens te reageren, afhankelijk van de URL die een gebruiker bezoekt.

Flask Forms en Validatie

Naast het weergeven van gegevens voor gebruikers, kunnen Flask-templates ook invoer van gebruikers aannemen voor verdere verwerking of opslag. Hiervoor biedt Flask ingebouwde ondersteuning voor het verwerken van HTML-formulieren en het afhandelen van gebruikersinvoer. Flask-formulieren zijn gebaseerd op de WTForms-bibliotheek, die een flexibele en krachtige manier biedt om formuliergegevens af te handelen en validaties uit te voeren. De bibliotheek maakt echter geen deel uit van de standaard Flask-installatie, dus we moeten deze installeren met behulp van de volgende opdracht:

pip install WTForms

Nadat we WTForms hebben geïnstalleerd, moeten we om formulieren in Flask te gebruiken een formulierklasse definiëren die onderdeel is van flask_wtf.FlaskForm. De klasse zal de velden bevatten die op het formulier zullen staan en eventuele validatieregels die op hen moeten worden toegepast.

Laten we een voorbeeld bekijken van een aanmeldingsformulier:

# forms.py
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Email, Length

class LoginForm(FlaskForm):
    email = StringField('Email', validators=[DataRequired(), Email()])
    password = PasswordField('Password', validators=[DataRequired(), Length(min=6)])
    submit = SubmitField('Log In')

In bovenstaand voorbeeld definiëren we een aanmeldingsformulier met twee velden – email en password – en een verzendknop. We hebben ook een validators argument dat wordt gebruikt om validatieregels voor elk veld te specificeren. Bijvoorbeeld, in dit geval vereisen we dat het email veld een geldig e-mailadres bevat en het password veld een wachtwoord van niet minder dan zes tekens.

Nadat we de formulierklasse hebben gedefinieerd, kunnen we deze gebruiken in de aanmeldingsviewfunctie om het formulier weer te geven en de door de gebruiker ingediende formuliergegevens te verwerken. Laten we een voorbeeld van de viewfunctie bekijken:

# views.py
from flask import render_template, request
from .forms import LoginForm

@app.route('/login', methods=['GET', 'POST'])
def login():
    form = LoginForm()
    if form.validate_on_submit():
        email = form.email.data
        password = form.password.data
        # doe iets met de formuliergegevens
    return render_template('login.html', form=form)

In bovenstaand voorbeeld hebben we een login view die twee HTTP-methoden (GET en POST) accepteert, dus wanneer gebruikers de URL vanuit een browser openen, wordt de LoginForm als een HTML-formulier weergegeven met behulp van de render_template methode, en wanneer een gebruiker het formulier indient, controleren we of het formulier geldig is met behulp van de validate_on_submit methode. Als het formulier geldig is, kunnen we de e-mail en het wachtwoord openen.

Het login.html formulier zou er bijvoorbeeld zo uit kunnen zien:

# login.html
<h1>Login</h1>
<form method="POST">
  {{ form.csrf_token }}
  <div>
    {{ form.email.label }} {{ form.email() }}
    {% for error in form.email.errors %}
    <span style="color: red;">[{{ error }}]</span>
    {% endfor %}
  </div>
  <div>
    {{ form.password.label }} {{ form.password() }}
    {% for error in form.password.errors %}
      <span style="color: red;">[{{ error }}]</span>
    {% endfor %}
  </div>
  {{ form.submit() }}
</form>

De bovenstaande template zal de velden email en password weergeven, samen met hun labels, en een verzendknop met de tekst “Login”. Het veld form.csrf_token is opgenomen om aanvallen van cross-site request forgery (CSRF) te voorkomen. De {% for %} loops worden gebruikt om eventuele validatiefouten die kunnen optreden weer te geven.

Door Flask-formulieren te gebruiken, hebben we een krachtige manier om gebruikersinvoer te verwerken, en we kunnen de gegevens die ze invoeren valideren.

Flask Extensies

Zoals we hebben gezien, is Flask een microframework dat alleen de belangrijkste onderdelen bevat die nodig zijn om een webtoepassing te maken. Als we echter functionaliteit nodig hebben die niet standaard door Flask wordt aangeboden, moeten we pakketten toevoegen aan de installatie. Flask-extensies zijn de manier waarop we deze aanvullende functionaliteit bieden. We kunnen gewoon het benodigde pakket installeren. Er zijn vele extensies gemaakt door de Flask-community.

Hier zijn enkele van de populairste:

• Flask-SQLAlchemy: biedt integratie met het SQLAlchemy-toolkit dat het gemakkelijk maakt om met databases te werken.
• Flask-Login: biedt gebruikersauthenticatie en sessiebeheer aan Flask.
• Flask-Mail: biedt een eenvoudige interface om e-mails vanuit Flask te verzenden.

Er zijn honderden extensies gemaakt door de Flask-community om verschillende functionaliteit te verwerken. Het gebruik van de extensies is over het algemeen eenvoudig. Eerst moeten we de gewenste extensie installeren met behulp van pip.

Laten we een voorbeeld bekijken van het gebruik van Flask-SQLAlchemy. Eerst moeten we het installeren:

pip install flask-sqlalchemy

Vervolgens moeten we het configureren. Bijvoorbeeld:

# sqlalchemy_example.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.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)

    def __repr__(self):
        return '<User %r>' % self.username

In het voorbeeld hierboven hebben we een User model met een username en email veld. We configureren ook SQLALCHEMY_DATABASE_URI, wat aangeeft dat we een SQLite-database gebruiken die zich bevindt op example.db. Met dat ingesteld, hebben we nu toegang tot het db object dat ons in staat stelt om met de database te communiceren. Bijvoorbeeld, we kunnen een nieuwe gebruiker aanmaken en deze toevoegen aan de database, zoals hieronder:

#views.py 
from app import db, User

user = User(username='john', email='[email protected]')
db.session.add(user)
db.session.commit()

Met Flask-extensies is ons toepassing in staat om meer functionaliteit te hebben dan normaal met de kern Flask-implementatie.

Conclusie

In dit artikel hebben we Flask geïntroduceerd, een lichtgewicht en flexibel webframework voor Python. We hebben de voordelen van het gebruik van Flask voor webontwikkeling besproken, inclusief de eenvoud, flexibiliteit en gemak van gebruik. We hebben ook besproken hoe je een ontwikkelomgeving kunt installeren, routes kunt aanmaken, templates kunt gebruiken, formulieren kunt afhandelen en extensies zoals Flask-SQLAlchemy kunt gebruiken.

Samenvattend, is Flask een uitstekende keuze voor het bouwen van webtoepassingen van elke grootte, van kleine persoonlijke projecten tot grote commerciële toepassingen. Het is gemakkelijk om te leren en te gebruiken, maar biedt ook geavanceerde functies via zijn vele extensies.

Als je geïnteresseerd bent in meer te weten te komen over Flask, hier zijn enkele aanvullende bronnen:

• Flask documentatie
• Flask Mega-Tutorial, door Miguel Grinberg
• Flask Web Development, door Miguel Grinberg
• A simple Flask app tutorial
• Real Python Flask tutorials

Als je meer wilt leren over Django en Flask en hun beste gebruiksvoorbeelden, bekijk dan Python Web Development with Django and Flask.

Veelgestelde vragen over Flask, de Python-framework