Master Flask: From Virtual Environments to Advanced Features

1. Flask Web Framework Overview

Flask is a lightweight Python web framework built on the Werkzeug WSGI toolkit and Jinja2 template engine, released under the BSD license. It is called a “microframework” because it provides a minimal core that can be extended with plugins for additional functionality.

2. Installing Flask with a Virtual Environment

First, create an isolated Python environment using pyenv on CentOS:

yum install zlib-devel bzip2 bzip2-devel readline-devel sqlite sqlite-devel openssl-devel
curl -L https://raw.githubusercontent.com/yyuu/pyenv-installer/master/bin/pyenv-installer | bash

Configure environment variables in ~/.bash_profile:

export PATH="~/.pyenv/bin:$PATH"
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"

Install a specific Python version (e.g., 2.7.12) and create a virtual environment:

pyenv install 2.7.12
pyenv virtualenv 2.7.12 venv27
mkdir -p virtu
cd virtu
pyenv local venv27

Install pip and configure the Alibaba Cloud mirror:

sudo yum -y install epel-release
sudo yum -y install pip
mkdir ~/.pip
cat > ~/.pip/pip.conf <<EOF
[global]
index-url = http://mirrors.aliyun.com/pypi/simple/
trusted-host = mirrors.aliyun.com
EOF

Finally, install Flask:

pip install flask
pip freeze   # list installed packages
python -c "import flask; print(flask.__version__)"   # verify installation

3. WSGI Specification

Flask runs on the WSGI protocol. A simple WSGI server can be created with the wsgiref module:

from wsgiref.simple_server import make_server

The server is suitable for testing but not recommended for production.

4. Basic Flask Application

A minimal Flask app looks like this:

from flask import Flask
app = Flask(__name__)

@app.route('/')
def index():
    return '<h1>Hello World!</h1>'

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

Variable URLs can be defined with angle‑bracket syntax:

@app.route('/hello/<name>')
def hello(name):
    return f'<h1>Hello {name}</h1>'

Supported converters include <string:name>, <int:uid>, and <path:prefix>. Custom converters can be created by subclassing werkzeug.routing.BaseConverter and registering them in app.url_map.converters.

5. Request Handling

Import the request object to access query parameters, form data, JSON payloads, etc. Example:

from flask import request
@app.route('/hi')
def hi():
    name = request.args.get('name')
    return f'<h1>hi {name}</h1>'

Common attributes: request.args, request.form, request.json, request.method, request.files.

6. Responses and Sessions

Use make_response to customize status codes, headers, and cookies:

from flask import make_response
resp = make_response('hello'.encode())
resp.set_cookie('name', 'jack')

Flask provides a session object backed by signed cookies for client‑side sessions.

7. Configuration

Load configuration from objects or files:

app = Flask(__name__)
app.config.from_object('yourapplication.default_settings')
app.config.from_pyfile('config.cfg')

Factory functions can create multiple app instances with different settings, facilitating testing and deployment.

8. Hook Functions

Flask supports lifecycle hooks such as before_request, after_request, teardown_appcontext, and errorhandler to run code at specific points.

9. Blueprints

Blueprints modularize an application by grouping related routes and views, which can then be registered on the main app with a URL prefix.

10. Extensions

Flask extensions add functionality such as ORM support, caching, authentication, and admin interfaces. Installation is typically done via pip install <extension>. Example with Flask‑SQLAlchemy:

from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db'
db = SQLAlchemy(app)

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