Python - Flask

Python Flask Framework 

Introduction to Flask Framework in Python

Flask is a lightweight, flexible, and powerful web framework written in Python. It is widely used for building web applications, REST APIs, microservices, and backend systems. Flask follows the WSGI (Web Server Gateway Interface) standard and is based on Werkzeug (a WSGI utility library) and Jinja2 (a powerful templating engine). Due to its simplicity and minimalistic design, Flask is often referred to as a “microframework”. However, the term “micro” does not mean that Flask lacks features; instead, it means Flask provides only the core essentials and allows developers to choose the tools and libraries they need.

Flask is one of the most searched Python web frameworks, along with Django and FastAPI. It is especially popular among beginners, startups, and developers who want full control over their application architecture. Flask is suitable for both small projects and large-scale applications when structured properly.

Why Learn Flask?

Learning Flask is beneficial for Python developers because it helps in understanding core web development concepts such as routing, HTTP methods, request-response cycles, templating, sessions, cookies, authentication, and database integration. Flask is easy to learn, highly customizable, and has extensive community support. It is commonly used in real-world projects, making it an excellent skill for students, professionals, and job seekers.

Key Features of Flask

Flask provides a wide range of features that make web development efficient and enjoyable:

• Lightweight and minimalistic core
• Built-in development server and debugger
• RESTful request dispatching
• Jinja2 templating engine
• Secure cookie-based sessions
• Easy URL routing
• Extensible with Flask extensions
• Support for REST APIs and JSON responses

Flask Architecture and Design Philosophy

Flask follows the Model-View-Controller (MVC) or more accurately, the Model-View-Template (MVT) architecture. While Flask does not enforce a strict project structure, developers commonly use MVC principles to organize their code.

Flask focuses on:

• Explicit configuration rather than implicit behavior
• Flexibility over strict conventions
• Modularity and scalability

Installing Flask in Python

Before installing Flask, ensure that Python is installed on your system. Flask supports Python 3.x. It is recommended to use a virtual environment to manage dependencies.

Using pip to Install Flask

pip install flask

To verify the installation, you can check the Flask version:

python -m flask --version

Creating Your First Flask Application

A basic Flask application consists of creating an instance of the Flask class and defining routes using decorators. Below is a simple “Hello World” Flask application.

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "Hello, Welcome to Flask!"

if __name__ == '__main__':
    app.run(debug=True)

When you run this application, Flask starts a local development server. Access the application in your browser using the provided URL, usually http://127.0.0.1:5000.

Flask Routing and URL Mapping

Routing in Flask is used to map URLs to specific functions. Flask uses decorators to bind URLs with view functions. Routing is one of the most important concepts in Flask.

Basic Routing Example

@app.route('/about')
def about():
    return "This is the About Page"

Dynamic Routing with Variables

Flask allows dynamic URL parameters, making applications more flexible.

@app.route('/user/<username>')
def user_profile(username):
    return f"Welcome {username}"

HTTP Methods in Flask

Flask supports HTTP methods such as GET, POST, PUT, DELETE, and PATCH.

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        return "Login Successful"
    return "Login Page"

Flask Templates and Jinja2

Flask uses Jinja2 as its templating engine. Templates help in rendering dynamic HTML content and separating business logic from presentation.

Rendering Templates

from flask import render_template

@app.route('/dashboard')
def dashboard():
    return render_template('dashboard.html')

Templates are stored inside a folder named templates.

Passing Data to Templates

@app.route('/profile')
def profile():
    name = "John"
    return render_template('profile.html', username=name)

Flask Static Files

Static files such as CSS, JavaScript, and images are stored in a folder named static. Flask automatically serves files from this directory.

Using Static Files

<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">

Flask Forms and User Input Handling

Handling user input is essential for web applications. Flask provides request object to access form data.

Form Handling Example

from flask import request

@app.route('/submit', methods=['POST'])
def submit():
    name = request.form['name']
    return f"Hello {name}"

Flask Sessions and Cookies

Sessions allow data to be stored across requests. Flask uses secure cookies for session management.

Using Sessions

from flask import session

app.secret_key = 'secretkey'

@app.route('/set_session')
def set_session():
    session['user'] = 'Admin'
    return "Session Set"

Flask Database Integration

Flask supports multiple databases such as SQLite, MySQL, PostgreSQL, and MongoDB. SQLAlchemy is commonly used as an ORM with Flask.

Using SQLite with Flask

import sqlite3

conn = sqlite3.connect('database.db')
cursor = conn.cursor()
cursor.execute("CREATE TABLE users (id INTEGER, name TEXT)")
conn.commit()
conn.close()

Flask Blueprints

Blueprints help in organizing large Flask applications by splitting them into modules.

Creating a Blueprint

from flask import Blueprint

admin = Blueprint('admin', __name__)

@admin.route('/admin')
def admin_panel():
    return "Admin Panel"

Flask REST API Development

Flask is widely used for building RESTful APIs. It supports JSON responses and HTTP methods.

Simple API Example

from flask import jsonify

@app.route('/api/data')
def api_data():
    return jsonify({"name": "Flask", "type": "Framework"})

Flask Error Handling

Error handling improves user experience and application stability.

Custom Error Pages

@app.errorhandler(404)
def page_not_found(error):
    return "Page Not Found", 404

Flask Security Best Practices

Security is crucial in Flask applications. Some best practices include:

• Using HTTPS
• Validating user input
• Protecting secret keys
• Using authentication and authorization

Flask Deployment

Flask applications can be deployed using servers like Gunicorn, uWSGI, and platforms like AWS, Heroku, and DigitalOcean.

Running Flask with Gunicorn

gunicorn app:app

Advantages of Flask

• Easy to learn and use
• Highly flexible
• Large ecosystem of extensions
• Ideal for APIs and microservices

Limitations of Flask

• No built-in admin panel
• Requires manual configuration for large projects
• Less opinionated than Django

Use Cases of Flask

Flask is used in:

• REST API development
• Machine learning model deployment
• Backend for mobile applications
• Microservices architecture

Flask is a powerful and flexible Python web framework that allows developers to build scalable, maintainable, and efficient web applications. With its simple syntax, extensive documentation, and strong community support, Flask is an excellent choice for both beginners and experienced developers. Learning Flask opens doors to web development, backend engineering, and API development using Python.