XenonStack Recommends

A Complete Introduction to Python Flask Framework

Acknowledging Data Management
          Best Practices with DataOps Image


XenonStack White Arrow Image

Overview of Python Flask Framework

Web apps are developed to generate content based on retrieved data that changes based on a user’s interaction with the site. The server is responsible for querying, retrieving, and updating data. This makes web applications to be slower and more complicated to deploy than static websites for simple applications. There are two primary coding environments for the whole web app ecosystem. This article will give an overview of the Python Flask Framework and Its best practices.

Client-side Scripting

The code executed on the user’s browser visible to anyone who has access to the system, generating the first results.

Server-side Scripting

This type of code is run on the backend on a web server. To enable developers to design, build, maintain, host web apps over the internet, a web framework necessary.
Analyze Big Data and make predictions out of the data requires training with Machine Learning Algorithms. Source: Machine Learning Model on Kubernetes

What is Web Framework?

A web framework is an architecture containing tools, libraries, and functionalities suitable to build and maintain massive web projects using a fast and efficient approach. They are designed to streamline programs and promote code reuse. To create the server-side of the web application, you need to use a server-side language. Python is home to numerous such frameworks, famous among which are Django and Flask. Python Flask Framework is a lightweight micro-framework based on Werkzeug, Jinja2. It is called a micro framework because it aims to keep its core functionality small yet typically extensible to cover an array of small and large applications. Flask Framework depends on two external libraries: The Jinja2 template, Werkzeug WSGI toolkit. Even though we have a plethora of web apps at our disposal, Flask tends to be better suited due to -
  • Built-in development server, fast debugger.
  • Integrated support for unit testing.
  • RESTful request dispatching.
  • Jinja2 Templating.
  • Support for secure cookies.
  • Lightweight and modular design allows for a flexible framework.

What are the Critical elements of the Python Flask Framework?

Initialization: flask applications must create an application instance. The web server passes all the requests it receives from clients to objects for handling using a protocol for WSG from flask import Flask app = Flask (__name__) (An application instance is an object of class Flask.)

The layout of the Python Flask Framework

  • Module Init - (project_root/app_name/admin/__init__.py) - required to enable the app
  • Module URL - (project_root/app_name/admin/url.py) - Url definitions of each module
  • App root Init - (project_root/app_name/__init__.py) - Not necessary to define the entire app within __init__.py
  • Module Views - (project_root/app_ame/admin/views.py) - Defines views for each module. Separate ‘.py.’ Files as the project scale to ensure they are accessible to URLs.
  • Module Templates - (project_root/app_name/admin/templates/admin/main.html) - Normal template folder.

Continuous delivery concentrates on automating the software delivery process to deploy the code at production at any point. Source: CI and CD Pipeline for Python

Routes and View Functions in Flask Framework Instance

Clients send requests to the webserver, in turn, sends them to the Flask application instance. The instance needs to know what code needs to run for each URL requested and map URLs to Python functions. The association between a URL and the function that handles it is called a route. The most convenient way to define a route in a Flask application is through the (app.route). Decorator exposed by the application instance, which registers the ‘decorated function,’ decorators are python feature that modifies the behavior of a function.

def index():
return 'Xenonstack'
The index is a view function, and the response can even be a string format HTML.
  • Server Startup - The application instance has a ‘run’ method that launches flask’s integrated development webserver -

if __name__ == '__main__':
Once the script starts, it waits for requests and services in a loop.
  • Local-Host - Run a python script in a virtual environment. Flask starts the server listening on and port 5000 by default. To accept connection from any remote address, use host = ‘’

HTTP Methods


To process incoming data in Flask, you need to use the request object, including mime-type, IP address, and data. HEAD: Un-encrypted data sent to server w/o response.


Sends data to the server requesting a response body.


Read form inputs and register a user, send HTML data to the server are methods handled by the route. Flask attaches methods to each route so that different view functions can handle different request methods to the same URL.


Flask invokes a view function. It has to return a response value to the client. HTTP requires it to be more than a string response, a status code.
  • Informational – 1xx
  • Successful – 2xx
  • Redirection – 3xx
  • Client Error – 4xx
  • Server Error – 5xx


To maintain the site. Flask uses a powerful template engine, ‘Jinja2’, in its simplest form. A Jinja2 template is a file that contains the text of a response, returned by a view function that has a dynamic component represented by a variable.


Dynamic url routing support is included using ‘url_for()’ helper function. For example, url_for('sagar', name='project_file', _external=True) would return http://localhost:5000/sagar/project_file.


CSRF(Cross-Site-Request-Forgery) occurs when a malicious website sends requests to a different website on which the victim logs in. Flask-WTF protects against all such attacks. Apart from that, Flask also implements some common security mechanisms like session-based management, role mgmt, password hashing, basic HTTP and token-based authentication, optional log-in tracking.

Database Connectivity

Flask has no restrictions for the use of databases; there’s no native support for databases. However, they can be broadly divided into two categories.
  • That following relational model for, e.g., SQL, sqlite3 mainly for structured data.
  • That not following the relational model for, e.g., NoSQL primarily for unstructured data.
Flask-SQLAlchemy is a Flask extension that simplifies the use of SQLAlchemy inside Flask applications. SQLAlchemy is a robust relational database framework that supports several databases back ends. It offers a high-level ORM and low-level access to the database’s native SQL functionality.

Build and Pipelines

Travis can be used for continuous integration to upload application images to docker hubs. After the publishing image to the Docker hub, it triggers a webhook to pull onto target servers.

Nginx Reverse Proxy

serve static files directly. Forward other requests to the application’s web server listening on the localhost. Testing - End-to-End tests are carried out using Flask test client and Selenium.
    • Unittest - built-in unit test framework. xUnit based.
    • Py.test - module to build unit tests.
We can also test each part of a flask application individually.
Test-Driven Development is an approach in which we build a test first, then fail the test and finally refactor our code to pass the test. Source: Test-Driven Development and Unit Testing in Python

Deploying Python Flask Framework on to Heroku Cloud

      • Install Heroku client and Foreman (to test simulated Heroku environment on pc).
      • Create an application using Heroku CLI and Git.
      • Add ‘procfile’ to the application using a gunicorn webserver run ‘ Heroku create <unique-app-name>-api-heroku’ in the application folder.
      • Push application to master branch https://git.heroku.com/kbucket-api-heroku.git , clone the repository, and push to heroku-master.
      • Note the app URL like (https://<unique-app-name>-api-heroku.herokuapp.com/ ). The application lives here. Heroku will assign the data that will garner to a PostgreSQL database.
      • One can also test the live API of the application, and if successfully deployed, it will return a 201 status code.

What is Flask Over Django?

Django is a full-stack web framework, while Flask is a micro lightweight f/w. But in recent times, Flask seems to have outdone Django, with more and more developers focusing on microservices and micro-frontends to reduce the loading time of a webpage. All of the user capability is available on a compact yet powerful f/w in Flask as compare to a host of additional resources in Django. Ease of development and faster deployment times in Flask.

Related blogs and Articles

Unit Testing of Machine Learning with Test Driven

Data Science

Unit Testing of Machine Learning with Test Driven

Machine Learning Unit Testing with Test-Driven Development A pattern built for development in performance testing is known as Test-Driven Machine Learning Development. It is a process that enables the developers to write code and estimate the intended behavior of the application. The requirements for the Test-Driven Machine Learning Development process are mentioned below- Detect the change...