Flask from Beginner to Master: Core Technologies and Extended Applications

1. Introduction and Installation of Flask¶

What is Flask?¶

Flask is a lightweight Python Web framework developed by Armin Ronacher. Its design philosophy is “micro,” meaning the core is simple and flexible while supporting rich extensions to meet complex needs. Unlike Django’s “batteries-included” approach (with many built-in features), Flask is more like a basic skeleton where developers can add components as needed. It’s perfect for beginners to get started and can also support large-scale project development.

Installing Flask¶

Installing Flask is straightforward. Using a virtual environment is recommended to avoid dependency conflicts:

# Create a virtual environment (optional but recommended)
python -m venv myenv
# Activate the virtual environment (Windows)
myenv\Scripts\activate
# Activate the virtual environment (Mac/Linux)
source myenv/bin/activate

# Install Flask
pip install flask

After installation, verify in Python:

import flask
print(flask.__version__)  # Outputs the version number, e.g., 2.0.1

2. Flask Getting Started: First Application¶

Hello World¶

Create your first Flask app by creating a new app.py file:

from flask import Flask

# Create a Flask application instance
app = Flask(__name__)

# Define a route: when a user visits the root path ('/'), the hello_world function is executed
@app.route('/')
def hello_world():
    return 'Hello, Flask!'  # Return the response content

# Run the application (only when executed directly)
if __name__ == '__main__':
    app.run(debug=True)  # debug=True enables debug mode (for development)

Run with python app.py and visit http://127.0.0.1:5000/ to see “Hello, Flask!”.

3. Core Technologies: Routing, Views, and Templates¶

1. Routing and View Functions¶

Routing: Defined using the @app.route() decorator to specify the URL path and HTTP methods.
View Functions: Handle route requests and return responses.

Dynamic Routes (with Parameters)¶

Support URL parameters, e.g., to get a user ID:

@app.route('/user/<int:user_id>')  # <type:name> specifies parameter type (int, string, etc.)
def show_user(user_id):
    return f'User ID: {user_id}'  # Pass parameters directly to the response

# Access: http://127.0.0.1:5000/user/123

Multi-HTTP Method Support¶

Allow the same route to handle different request methods (GET/POST):

from flask import request  # Required for request handling

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        return 'Login successful!'
    else:
        return 'Please fill out the login form'  # Show form for GET requests

2. Template Engine (Jinja2)¶

Flask uses the Jinja2 template engine by default for dynamic HTML rendering.

Basic Usage¶

Create a templates folder (required name) in the project root and add index.html:

<!-- templates/index.html -->
<!DOCTYPE html>
<html>
<head>
    <title>{{ title }}</title>  <!-- Template variable -->
</head>
<body>
    <h1>{{ message }}</h1>
    {% if user %}  <!-- Conditional statement -->
        <p>Welcome back, {{ user.name }}!</p>
    {% else %}
        <p>Please log in</p>
    {% endif %}
</body>
</html>

Render the template in a view function:

from flask import render_template  # Import the rendering function

@app.route('/')
def index():
    context = {
        'title': 'Flask Introduction',
        'message': 'Hello, Jinja2!',
        'user': {'name': 'Xiaoming'}  # Pass dictionary data
    }
    return render_template('index.html', **context)  # Unpack the dictionary

3. Static Files¶

CSS, JS, images, etc., are placed in the static folder (required name) and referenced using url_for:

<!-- Reference CSS in the template -->
<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
<!-- Reference an image -->
<img src="{{ url_for('static', filename='logo.png') }}" alt="Logo">

4. Advanced Core Features¶

1. Session Management and Redirection¶

Redirection: Use the redirect function to jump to a specified URL:

  from flask import redirect, url_for

  @app.route('/goto-home')
  def goto_home():
      return redirect(url_for('index'))  # Redirect to the index route

Sessions: Store user state (requires a secret key):

  app.secret_key = 'your-secret-key-here'  # Secret key (random string for development)

  @app.route('/login')
  def login():
      session['user_id'] = 123  # Store user ID in the session
      return 'Login successful'

  @app.route('/profile')
  def profile():
      user_id = session.get('user_id')  # Retrieve session data
      return f'User ID: {user_id}'

2. Database Operations (Flask-SQLAlchemy)¶

Flask doesn’t natively include an ORM, but the Flask-SQLAlchemy extension simplifies database operations (using SQLite as an example):

Install the extension: pip install flask-sqlalchemy
Configure and initialize:

   from flask_sqlalchemy import SQLAlchemy

   app = Flask(__name__)
   app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///mydb.db'  # SQLite database path
   app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False  # Disable modification tracking
   db = SQLAlchemy(app)  # Initialize the database

Define a model:

   class User(db.Model):
       id = db.Column(db.Integer, primary_key=True)
       name = db.Column(db.String(80), unique=True, nullable=False)
       email = db.Column(db.String(120), unique=True, nullable=False)

       def __repr__(self):
           return f'<User {self.name}>'

   # Create tables (execute once when starting)
   with app.app_context():
       db.create_all()

Database operation example:

   # Add a user
   user = User(name='Xiaohong', email='hong@example.com')
   db.session.add(user)
   db.session.commit()

   # Query a user
   users = User.query.filter_by(name='Xiaohong').first()
   print(users.email)  # Output: hong@example.com

Flask-Login is an extension for handling user login and session management:

Install: pip install flask-login
Initialize and configure:

   from flask_login import LoginManager, UserMixin

   login_manager = LoginManager(app)
   login_manager.login_view = 'login'  # Redirect to 'login' route if not logged in

   class User(UserMixin, db.Model):  # UserMixin provides default implementations (is_authenticated, etc.)
       # Model definition as above...

User loading and login:

   @login_manager.user_loader
   def load_user(user_id):
       return User.query.get(int(user_id))  # Load user by ID

   @app.route('/login', methods=['POST'])
   def login():
       user = User.query.filter_by(name=request.form['name']).first()
       if user and check_password_hash(user.password, request.form['password']):
           login_user(user)  # Log the user in
           return redirect(url_for('index'))
       return 'Login failed'

5. Common Extensions and Use Cases¶

1. Flask-WTF (Form Handling)¶

Simplify form validation:

from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField
from wtforms.validators import DataRequired

class LoginForm(FlaskForm):
    name = StringField('Username', validators=[DataRequired()])
    password = PasswordField('Password', validators=[DataRequired()])

@app.route('/login', methods=['GET', 'POST'])
def login():
    form = LoginForm()
    if form.validate_on_submit():  # Validate the form
        return 'Login successful'
    return render_template('login.html', form=form)

2. Flask-RESTful (API Development)¶

Rapidly develop RESTful-style APIs:

from flask_restful import Api, Resource

api = Api(app)

class HelloAPI(Resource):
    def get(self):
        return {'message': 'Hello, API!'}

api.add_resource(HelloAPI, '/api/hello')  # Bind the route

3. Flask-Admin (Admin Dashboard)¶

Automatically generate admin interfaces for content management systems:

from flask_admin import Admin
from flask_admin.contrib.sqla import ModelView

admin = Admin(app)
admin.add_view(ModelView(User, db.session))  # Register the User model in the admin

6. Deployment and Production Environment¶

1. Basic Deployment¶

Flask’s built-in server is only for development. For production, use a WSGI server:
- Gunicorn: pip install gunicorn

  gunicorn -w 4 -b 0.0.0.0:8000 app:app  # 4 worker processes

Nginx: Act as a reverse proxy to forward requests to Gunicorn

2. Cloud Platform Deployment¶

PythonAnywhere: Free Python hosting platform (upload code and configure wsgi.py)
Heroku: Specify the startup command via Procfile and set environment variables (e.g., SECRET_KEY)
Docker: Containerized deployment (Dockerfile example):

  FROM python:3.9
  WORKDIR /app
  COPY requirements.txt .
  RUN pip install -r requirements.txt
  COPY . .
  CMD ["gunicorn", "-b", "0.0.0.0:5000", "app:app"]

7. Summary and Learning Path¶

Key Takeaways¶

Basics: Routing, views, templates, static files, sessions
Advanced: Databases (SQLAlchemy), user authentication (Login), form handling (WTF)
Extensions: API development (RESTful), admin dashboards (Admin)

Learning Suggestions¶

Hands-on Practice: Start with simple projects like personal blogs or to-do lists
Read Official Documentation: Flask Official Documentation
Explore Extensions: Try Flask-SocketIO for real-time chat or Flask-Caching for performance optimization
Troubleshooting: Check Flask Common Issues when encountering errors

Flask’s flexibility and rich extension ecosystem allow it to handle both small projects and large-scale applications. Mastering core technologies and then leveraging extensions to implement complex features is the key to progressing from beginner to expert!