Python Flask tutorial: Build your first Flask application!

Getting to know the Flask framework#

Features of Flask#

Some features which make Flask an ideal framework for web application development are:

1. Flask provides a development server and a debugger
2. Flask uses Jinja2 templates (more on this later)
3. Flask is WSGI 1.0. compliant (more on this later)
4. Flask provides integrated support for unit testing
5. Flask has many extensions available for enhancing its existing functionalities

What is a micro-framework?#

Micro-frameworks are the opposite of full-stack frameworks, which also offer additional modules for features such as authentication, database ORM, input validation and sanitization, etc.

Why is Flask called a micro-framework?#

Flask is known as a micro-framework because it is lightweight and only provides components that are essential, such as routing, request handling, sessions, and so on. For the other functionalities such as data handling, the developer can write a custom module or use an extension. This approach avoids unnecessary boilerplate code, which is not even being used.

Key aspects of Flask: WSGI and Jinja2#

You might have heard comments such as “Flask is 100% WSGI compliant” or, “flask uses Jinja as a template language.” But what exactly does this mean? What are WSGI and Jinja2? Let’s learn what these terms mean, and their significance concerning Flask.

WSGI - Web Server Gateway Interface#

The Web Server Gateway Interface, or more commonly known as WSGI, is a standard that describes the specifications concerning the communication between a web server and a client application. The details of these specifications are present in PEP333. Here are some benefits of WSGI:

• Flexibility with the components of the application.
• Interoperability within different Python frameworks.
• Scalability of the application with an increase in users.
• Efficiency in terms of speed of development.

Jinja2 - A templating language#

Jinja is a template language used in Python. But, you might ask, what exactly is a template language?

Templates are the front-end, which the user sees. In the case of a website, the templates are the HTML pages. A template language is one that we can use inside HTML so that the content on the HTML page becomes dynamic.

Let’s move on to creating your first Flask application.

Hello World - Creating your first Flask application#

The simplest Flask application can be made using only one script! Let us call this file app.py. We will break down the program into steps and discuss each one.

Step 1: Importing modules#

For this application, we only need the Flask module from the flask package. So let’s import that first.

from flask import Flask

Step 2: Creating a Flask object#

We need to make an object with the imported Flask module. This object will be our WSGI application called app. As discussed before, the WSGI aspect of the application is taken care of by the Flask module.

app = Flask(__name__)

Step 3: Run the application in main#

To run our application, we need to call the run() function of our application object.

if __name__ == "__main__":
    app.run()

The run() function has some optional parameters. For complete documentation, refer here.

Step 4: Create a view function#

Before we run the application, we need to tell the application to show something as output in the browser window. Thus, we create a function called hello() which returns the string “Hello World!”. The output returned from this function will be shown in the browser.

def hello():
    return "Hello World!"; 

Step 5: Assign a URL route#

Finally, we need to tell the Flask app when to call the view function hello(). For this purpose, we will create a URL route. A URL route is associated with each view function. This association is created by using the route() decorator before each view function.

@app.route("/") 
def hello():
    return "Hello World!"; 

Complete implementation

The following program shows the complete implementation of a “Hello World” application in Flask!

from flask import Flask
app = Flask(__name__)
@app.route("/")
def hello():
    return "Hello World!";
 
if __name__ == "__main__":
    app.run(debug = True, host = "0.0.0.0", port = 3000)

URL routes and views#

Wait, what are URL routes and views?#

The homepage of a website can usually be found at the URL hostname followed by /, /home, /index or something self-explanatory. These kinds of URLs enable the users to remember the URL and access it easily. It would be unexpected if the homepage were at a random URL such as /39283@&3911 or /more_eggs. Flask allows us to use the route() decorator to bind a meaningful URL to each view function we create.

What is a view function?#

In the discussion of the MTV (Model-Template-View) architecture, we learned what a view is. In Flask, we create a function that acts as the view. Recall from the Hello World example, we created a function called hello. This function acted as a view. Then, we bonded it with a route.

@app.route("/")
def hello():
    return "Hello World!";

The route() decorator#

The route decorator takes the following parameters:

• rule: The rule represents the URL rule which is passed as a string to the decorator.
• endpoint (not needed): The endpoint is the name of the view function which is bound to the URL route. Flask assumes this parameter itself, and the developer does not need to specify it.
• options (optional): The options are an optional parameter. We will discuss it in more detail later.

Static routing#

In static routing, we specify a constant URL string as rule to the route() decorator. For example in the mini-application given below, we have specified two static routes having URLs / and /educative respectively.

Example:

from flask import Flask, render_template
app = Flask(__name__)
 
@app.route("/")
def home():
    return "Welcome to the HomePage!"
 
@app.route("/educative")
def learn():
    return "Happy Learning at Educative!"
 
 
if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0", port=3000)

Explanation

home() view

This view function corresponds to the route "/". When you open the URL or check the “Output” tab, this view will be called. The "/" is always the default route of any web application. For example, when we go to educative.io the host = “educative.io” and route = “/”.

learn() view

This view function corresponds to the route "/educative". When you open the URL and append "/educative", this view will be called.

For example, when we go to educative.io/explore, the host = “educative.io” and route = “/explore”.