Flask Framework Overview

Introduction to Flask

Flask is a lightweight and flexible web framework for Python. Created by Armin Ronacher in 2010, Flask provides the essentials for web development without imposing a rigid structure or dependencies. This simplicity and flexibility make it an excellent choice for developers who want control over their application architecture.

What is a "Microframework"?

Flask is often described as a "microframework" because it provides only the core functionality needed to build a web application:

• URL routing
• Request and response handling
• Template rendering
• Basic development server
• Integrated unit testing support

Unlike full-stack frameworks like Django, Flask doesn't include built-in features like:

• ORM for database operations
• Form validation and handling
• User authentication
• Admin interfaces

However, all these features can be added through extensions or custom code, giving you the freedom to choose exactly which components you need and how they're implemented.

Key Features and Philosophy

Flask's Core Design Principles

• Simplicity: Flask aims to keep the core simple but extensible
• Flexibility: Few decisions are made for you, leaving you in control
• Fine-grained control: You decide how to structure your application
• Explicit over implicit: Behavior is explicit, reducing "magic"
• Pythonic: Follows Python's philosophy of readability and simplicity

Flask vs. Other Python Web Frameworks

Flask's Architecture and Components

Core Components

Flask is built on two main dependencies:

1. Werkzeug: A WSGI (Web Server Gateway Interface) utility library that handles the interface between web servers and Python web applications
2. Jinja2: A powerful templating engine for rendering HTML templates

Request-Response Cycle in Flask

1. Client sends an HTTP request to the server
2. WSGI server (e.g., Gunicorn, uWSGI) receives the request
3. Werkzeug processes the request and creates a request object
4. Flask app matches the URL to the appropriate route
5. The corresponding view function is executed
6. View function processes the request and returns a response
7. Jinja2 renders any templates if needed
8. Werkzeug converts the response to HTTP format
9. WSGI server sends the HTTP response back to the client

Flask Application Structure

A minimal Flask application can be as simple as:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

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

As applications grow, they typically evolve into a more organized structure:

myapp/
├── app/
│   ├── __init__.py          # Create and configure Flask app
│   ├── routes.py            # Route definitions
│   ├── models.py            # Database models
│   ├── forms.py             # Form definitions
│   ├── static/              # Static files (CSS, JavaScript, images)
│   │   ├── css/
│   │   ├── js/
│   │   └── img/
│   └── templates/           # Jinja2 templates
│       ├── base.html
│       └── index.html
├── config.py                # Configuration settings
├── requirements.txt         # Project dependencies
└── run.py                   # Application entry point

For larger applications, a blueprint-based structure is common:

myapp/
├── app/
│   ├── __init__.py
│   ├── extensions.py        # Flask extensions initialization
│   ├── models/              # Database models
│   ├── static/
│   ├── templates/
│   └── views/               # Blueprints for different parts of the app
│       ├── __init__.py
│       ├── auth/            # Authentication blueprint
│       │   ├── __init__.py
│       │   ├── forms.py
│       │   ├── routes.py
│       │   └── templates/
│       └── main/            # Main blueprint
│           ├── __init__.py
│           ├── forms.py
│           ├── routes.py
│           └── templates/
├── config.py
├── requirements.txt
└── run.py

Flask Ecosystem and Extensions

One of Flask's key strengths is its rich ecosystem of extensions that add functionality to the core framework.

Popular Flask Extensions

Creating a Flask Application with Extensions

Here's an example of a Flask application using several common extensions:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from flask_login import LoginManager
from flask_wtf.csrf import CSRFProtect

# Initialize extensions
db = SQLAlchemy()
migrate = Migrate()
login_manager = LoginManager()
csrf = CSRFProtect()

def create_app(config=None):
    # Create Flask app
    app = Flask(__name__)
    
    # Load configuration
    app.config.from_object('app.config.DevelopmentConfig')
    if config:
        app.config.update(config)
    
    # Initialize extensions with the app
    db.init_app(app)
    migrate.init_app(app, db)
    login_manager.init_app(app)
    csrf.init_app(app)
    
    # Set up login manager
    login_manager.login_view = 'auth.login'
    login_manager.login_message_category = 'info'
    
    # Register blueprints
    from app.views.auth import auth_bp
    from app.views.main import main_bp
    
    app.register_blueprint(auth_bp)
    app.register_blueprint(main_bp)
    
    return app

When to Use Flask

Ideal Use Cases

• Small to medium web applications where simplicity and flexibility are valued
• RESTful APIs where you need fine-grained control over requests and responses
• Microservices where a lightweight framework with minimal overhead is beneficial
• Prototypes and MVPs that need to be developed quickly
• Educational projects where understanding the core concepts of web development is important
• Applications requiring customization that might be difficult with more opinionated frameworks

When to Consider Alternatives

• Large, complex applications that benefit from the structure of a full-stack framework like Django
• Projects requiring extensive built-in functionality out of the box
• Applications with complex async requirements might be better served by FastAPI or Starlette
• Teams that prefer convention over configuration might be more productive with Django

from flask import Flask, jsonify, request

app = Flask(__name__)

@app.route('/api/users', methods=['GET'])
def get_users():
    # In a real app, this would come from a database
    users = [
        {'id': 1, 'name': 'Alice', 'email': 'alice@example.com'},
        {'id': 2, 'name': 'Bob', 'email': 'bob@example.com'}
    ]
    return jsonify(users)

@app.route('/api/users', methods=['POST'])
def create_user():
    if not request.json:
        return jsonify({'error': 'Invalid data'}), 400
        
    user_data = request.json
    # In a real app, this would be saved to a database
    return jsonify(user_data), 201

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

Getting Started with Flask

Installation and Setup

To get started with Flask, you'll need Python 3.6 or later. It's recommended to use a virtual environment:

# Create a virtual environment
python -m venv venv

# Activate the virtual environment
# On Windows:
venv\Scripts\activate
# On macOS/Linux:
source venv/bin/activate

# Install Flask
pip install flask

# Save dependencies
pip freeze > requirements.txt

Your First Flask Application

Create a file named app.py with the following content:

from flask import Flask, render_template

app = Flask(__name__)

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

@app.route('/about')
def about():
    return 'About page'

@app.route('/greet/')
def greet(name):
    return f'Hello, {name}!'

@app.route('/template')
def template_example():
    return render_template('hello.html', message='Hello from template!')

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

Create a templates folder and add a file named hello.html:

<!DOCTYPE html>
<html>
<head>
    <title>Flask Template Example</title>
</head>
<body>
    <h1>{{ message }}</h1>
    <p>This is a simple template example.</p>
</body>
</html>

Run your application:

python app.py

Visit http://127.0.0.1:5000/ in your browser to see your Flask application in action!

Practical Exercise

Summary

Key Takeaways

• Flask is a lightweight, flexible microframework for Python web development
• The core components of Flask are Werkzeug (WSGI toolkit) and Jinja2 (templating engine)
• Flask follows a "batteries included, but removable" philosophy
• Flask is ideal for small to medium applications, APIs, and microservices
• The Flask ecosystem includes many extensions for adding functionality
• Flask applications can start simple and evolve to more complex structures as needed

Additional Resources

• Flask Official Documentation
• Flask Tutorial
• Hackers and Slackers Flask Series
• Flask Boilerplate by Real Python
• Explore Flask

Next Lecture

In our next lecture, we'll explore setting up a Flask application, including project structure, configuration, and environment setup.