python中常见的5种框架解读

下面是 Python 中常见的 5 种框架的详细解读。

1. Django

Django 是一个由 Python 写成的高级 Web 开发框架，它的核心理念是："Don't Repeat Yourself"（DRY）。

Django 已经集成了许多常用的功能模块，如：数据库 ORM（Object-Relational Mapping）映射关系、路由系统、表单、用户认证、文件系统处理等，大幅提高了 Web 开发效率。同时，Django 系统化的架构、完善的文档和较好的社区支持，也使得它成为了 Python Web 开发的领军框架。

示例说明：

以一个简单的博客网站为例，使用 Django 框架实现博客 CRUD 操作。我们可以使用 Django 提供的 Model 类定义我们的博客模型，代码如下：

from django.db import models

class Blog(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    create_time = models.DateTimeField(auto_now_add=True)
    modified_time = models.DateTimeField(auto_now=True)

使用 Django，我们只需要定义好模型，就可以使用内置命令 migrate 同步到数据库：

python manage.py migrate

然后，我们可以创建一个视图函数，在该函数中实现博客的添加、修改、删除等功能：

from django.shortcuts import render, get_object_or_404
from .models import Blog
from .forms import BlogForm

def blog_list(request):
    blogs = Blog.objects.all()
    return render(request, 'bloglist.html', {'blogs':blogs})

def blog_detail(request, id):
    blog = get_object_or_404(Blog, pk=id)
    return render(request, 'blogdetail.html', {'blog':blog})

def blog_create(request):
    if request.method == 'POST':
        form = BlogForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('blog_list')
    form = BlogForm()
    return render(request, 'blogcreate.html', {'form':form})

def blog_update(request, id):
    blog = get_object_or_404(Blog, pk=id)
    if request.method == 'POST':
        form = BlogForm(request.POST, instance=blog)
        if form.is_valid():
            form.save()
            return redirect('blog_list')
    form = BlogForm(instance=blog)
    return render(request, 'blogupdate.html', {'form':form})

def blog_delete(request, id):
    blog = get_object_or_404(Blog, pk=id)
    blog.delete()
    return redirect('blog_list')

然后，我们只需要在模板中定义好对应的表单，加载静态文件，就可以访问我们的博客网站了。

2. Flask

Flask 是另一个轻量级的 Python Web 开发框架，其定位是实现简单、灵活且可扩展的 Web 应用。

相对于 Django 的技术栈比较深，需要掌握一定的 ORM、路由系统、静态文件处理等基础知识。Flask 只需要一个核心库和若干扩展库就可以构建一个简单却功能强大的 Web 应用。

示例说明：

以一个简单的博客网站为例，使用 Flask 框架实现博客 CRUD 操作。我们可以使用 Flask 提供的装饰器来定义路由，代码如下：

from flask import Flask, render_template, request, redirect, url_for
from flask_wtf import FlaskForm
from wtforms import StringField, TextAreaField
from wtforms.validators import DataRequired
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SECRET_KEY'] = 'you will never guess'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db'
db = SQLAlchemy(app)

class Blog(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(50), nullable=False)
    content = db.Column(db.Text, nullable=False)

@app.route('/')
def blog_list():
    blogs = Blog.query.all()
    return render_template('bloglist.html', blogs=blogs)

@app.route('/blog/<int:id>')
def blog_detail(id):
    blog = Blog.query.get_or_404(id)
    return render_template('blogdetail.html', blog=blog)

@app.route('/blog/create', methods=('GET', 'POST'))
def blog_create():
    form = BlogForm()
    if form.validate_on_submit():
        blog = Blog(title=form.title.data, content=form.content.data)
        db.session.add(blog)
        db.session.commit()
        return redirect(url_for('blog_list'))
    return render_template('blogcreate.html', form=form)

@app.route('/blog/update/<int:id>', methods=('GET', 'POST'))
def blog_update(id):
    blog = Blog.query.get_or_404(id)
    form = BlogForm(obj=blog)
    if form.validate_on_submit():
        form.populate_obj(blog)
        db.session.commit()
        return redirect(url_for('blog_list'))
    return render_template('blogupdate.html', form=form)

@app.route('/blog/delete/<int:id>')
def blog_delete(id):
    blog = Blog.query.get_or_404(id)
    db.session.delete(blog)
    db.session.commit()
    return redirect(url_for('blog_list'))

class BlogForm(FlaskForm):
    title = StringField('标题', validators=[DataRequired()])
    content = TextAreaField('内容', validators=[DataRequired()])

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

3. Pyramid

Pyramid 是一个轻量级的开源 Web 框架，具有简单、可扩展、可重用的特性。Pyramid 的关键特性是它的“纯 Python”性质：框架本身十分简单，重要的功能是通过插件提供的，以此来尽量减轻框架本身的体量。

Pyramid 提供了丰富的工具和库，可以帮助开发者快速构建 Web 应用程序，极大地提高了开发效率。在大型项目中，Pyramid 也是一个非常好的选择，并且性能表现优良。

示例说明：

以一个简单的图书管理系统为例，使用 Pyramid 框架实现图书的信息 CRUD 操作。我们可以使用 SQLAlchemy 提供的对象关系映射功能来定义模型，使用 Pyramids 提供的视图。代码如下：

from pyramid.config import Configurator
from pyramid.response import Response
from sqlalchemy import engine_from_config, Column, Integer, Unicode
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

DBSession = sessionmaker()

Base = declarative_base()

class Book(Base):
    __tablename__ = 'book'
    id = Column(Integer, primary_key=True)
    name = Column(Unicode(255), nullable=False)
    author = Column(Unicode(255), nullable=False)
    content = Column(Unicode(1000), nullable=False)

def book_list(request):
    session = DBSession()
    books = session.query(Book).all()
    return {'books':books}

def book_create(request):
    session = DBSession()
    if request.method == 'POST':
        name = request.POST.get('name')
        author = request.POST.get('author')
        content = request.POST.get('content')
        book = Book(name=name, author=author, content=content)
        session.add(book)
        session.commit()
        return Response('添加成功！')
    return {}

def book_update(request):
    session = DBSession()
    if request.method == 'POST':
        book_id = request.POST.get('id')
        name = request.POST.get('name')
        author = request.POST.get('author')
        content = request.POST.get('content')
        book = session.query(Book).get(book_id)
        book.name = name
        book.author = author
        book.content = content
        session.add(book)
        session.commit()
        return Response('修改成功！')
    return {}

def book_delete(request):
    session = DBSession()
    if request.method == 'POST':
        book_id = request.POST.get('id')
        book = session.query(Book).get(book_id)
        session.delete(book)
        session.commit()
        return Response('删除成功！')
    return {}

if __name__ == '__main__':
    settings = {'sqlalchemy.url': 'sqlite:///book.db'}
    config = Configurator(settings=settings)
    config.add_static_view(name='static', path='./static')

    config.add_route('book_list', '/')
    config.add_view(book_list, route_name='book_list', renderer='booklist.html')

    config.add_route('book_create', '/book/create')
    config.add_view(book_create, route_name='book_create', renderer='json')

    config.add_route('book_update', '/book/update')
    config.add_view(book_update, route_name='book_update', renderer='json')

    config.add_route('book_delete', '/book/delete')
    config.add_view(book_delete, route_name='book_delete', renderer='json')

    engine = engine_from_config(settings, prefix='sqlalchemy.')
    Base.metadata.create_all(engine)
    DBSession.configure(bind=engine)
    app = config.make_wsgi_app()
    serve(app, host='127.0.0.1', port=8080)

4. CherryPy

CherryPy 是一个小巧的 Web 框架，当然，瘦身的代价是 CherryPy 没有 Django、Flask 和 Pyramid 那样庞大的生态系统。但是它很轻量级，由于它没有数据库 ORM、HTML 表单等功能模块，所以它的最小化构建版本十分小巧，有利于部署和维护。

CherryPy 支持 HTTP、HTTPS、WSGI、FastCGI、FCGI、SCGI、AJAX、CGI、mod_python 和 pure CGI，并且在源码级别高度模块化，可以方便地按需扩展。

示例说明：

以一个简单的Web服务为例，使用 CherryPy 框架实现对不同 url 的请求响应。代码如下：

import cherrypy

class HelloWorld:
    @cherrypy.expose
    def index(self):
        return "Hello world!"

    @cherrypy.expose
    def welcome(self, name=None):
        if name:
            return "Welcome %s!" % name
        else:
            return "Welcome!"

if __name__ == '__main__':
    cherrypy.quickstart(HelloWorld())

5. Tornado

Tornado 是一个高性能的 Python Web 框架，最初由 FriendFeed 社交网站的开发人员开发。Tornado 最为突出的特点是异步编程。

Tornado 提供了非常强大的网络库，包括 HTTP 客户端和服务器、异步框架、协程库、WebSockets、RPC 等等。

相比于 Flask 和 Pyramid 等 Web 框架，Tornado 具有天然的高并发性，如果需要处理大量请求，Tornado 无疑是一个优秀的选择。

示例说明：

以一个简单的Web服务为例，使用 Tornado 框架实现对不同 url 的请求响应。代码如下：

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

class WelcomeHandler(tornado.web.RequestHandler):
    def get(self, name):
        self.write("Welcome %s!" % name)

if __name__ == "__main__":
    application = tornado.web.Application([
        (r"/", MainHandler),
        (r"/welcome/(.*)", WelcomeHandler),
    ])
    application.listen(8080)
    tornado.ioloop.IOLoop.current().start()

到此为止，就是“Python 中常见的 5 种框架解读” 的完整攻略，希望对开发者们有所帮助。