Python编程： Django、Flask和Requests

Python Web框架与HTTP请求库：Django、Flask和Requests

Django - 全功能Web框架

Django是一个"全栈式"Web框架，遵循MTV(Model-Template-View)模式，内置了ORM、认证、管理后台等功能。

1.1 核心特性

• ORM系统：用Python类定义数据库模型

• 自动管理界面：内置Admin后台

• URL路由：优雅的URL设计

• 模板引擎：Django Template Language

• 表单处理：内置表单验证

• 安全防护：CSRF、XSS、SQL注入等防护

1.2 基本使用示例

# 安装：pip install django

# 项目结构
# myproject/
# ├── manage.py
# └── myproject/
#     ├── __init__.py
#     ├── settings.py
#     ├── urls.py
#     └── wsgi.py

# 创建项目
# django-admin startproject myproject
# cd myproject
# python manage.py startapp myapp

# 示例视图 (myapp/views.py)
from django.http import HttpResponse
from django.shortcuts import render
from .models import Article

def home(request):
    return HttpResponse("Welcome to Django!")

def article_list(request):
    articles = Article.objects.all()
    return render(request, 'articles/list.html', {'articles': articles})

# 示例模型 (myapp/models.py)
from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    published_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

# URL配置 (myapp/urls.py)
from django.urls import path
from . import views

urlpatterns = [
    path('', views.home),
    path('articles/', views.article_list, name='article-list'),
]

# 模板示例 (templates/articles/list.html)
{% for article in articles %}
    <h2>{{ article.title }}</h2>
    <p>{{ article.content }}</p>
{% endfor %}

1.3 Django REST framework

# 安装：pip install djangorestframework

# 序列化器 (serializers.py)
from rest_framework import serializers
from .models import Article

class ArticleSerializer(serializers.ModelSerializer):
    class Meta:
        model = Article
        fields = '__all__'

# 视图 (views.py)
from rest_framework import generics
from .models import Article
from .serializers import ArticleSerializer

class ArticleListCreateView(generics.ListCreateAPIView):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer

Flask - 微框架

Flask是一个轻量级"微框架"，核心简单但可通过扩展增加功能，适合小型项目和API开发。

1 核心特性

• 轻量级：核心简单，易于学习

• 灵活：可自由选择组件

• Jinja2模板：强大的模板引擎

• WSGI兼容：符合Python Web标准

• 扩展丰富：Flask-SQLAlchemy, Flask-Login等

2 基本使用示例

# 安装：pip install flask

from flask import Flask, render_template, request, jsonify

app = Flask(__name__)

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

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

@app.route('/api/data', methods=['GET', 'POST'])
def api_data():
    if request.method == 'POST':
        data = request.get_json()
        return jsonify({"status": "success", "data": data})
    return jsonify({"data": [1, 2, 3]})

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

3 Flask扩展示例

# Flask-SQLAlchemy
from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite'
db = SQLAlchemy(app)

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

# Flask-Login
from flask_login import LoginManager, UserMixin, login_user

login_manager = LoginManager(app)

class User(UserMixin, db.Model):
    # ...

@login_manager.user_loader
def load_user(user_id):
    return User.query.get(int(user_id))

@app.route('/login', methods=['POST'])
def login():
    user = User.query.filter_by(username=request.form['username']).first()
    if user:
        login_user(user)
        return "Logged in!"
    return "Invalid credentials", 401

Requests - HTTP请求库

Requests是一个优雅而简单的HTTP库，用于发送各种HTTP请求。

1 核心特性

• 人性化API：直观的HTTP方法(get, post等)

• 自动内容解码：自动处理编码

• 会话支持：保持会话状态

• SSL验证：支持HTTPS

• 超时控制：请求超时设置

2 基本使用示例

# 安装：pip install requests

import requests

# GET请求
response = requests.get('https://api.github.com')
print(response.status_code)
print(response.json())

# 带参数的GET请求
params = {'key1': 'value1', 'key2': 'value2'}
response = requests.get('https://httpbin.org/get', params=params)

# POST请求
data = {'key': 'value'}
response = requests.post('https://httpbin.org/post', data=data)

# JSON POST
response = requests.post('https://httpbin.org/post', json=data)

# 自定义头部
headers = {'user-agent': 'my-app/0.0.1'}
response = requests.get('https://api.github.com', headers=headers)

# 会话保持
session = requests.Session()
session.get('https://httpbin.org/cookies/set/sessioncookie/123456789')
response = session.get('https://httpbin.org/cookies')
print(response.json())  # 会显示之前的cookie

# 超时设置
try:
    response = requests.get('https://github.com', timeout=0.001)
except requests.exceptions.Timeout:
    print("请求超时!")

3 高级用法

# 流式下载
url = "https://example.com/large-file.zip"
response = requests.get(url, stream=True)
with open('large-file.zip', 'wb') as fd:
    for chunk in response.iter_content(chunk_size=128):
        fd.write(chunk)

# 上传文件
files = {'file': open('report.xls', 'rb')}
response = requests.post('https://httpbin.org/post', files=files)

# 代理支持
proxies = {
    'http': 'http://10.10.1.10:3128',
    'https': 'http://10.10.1.10:1080',
}
response = requests.get('https://example.com', proxies=proxies)

# 认证
from requests.auth import HTTPBasicAuth
response = requests.get('https://api.github.com/user', 
                       auth=HTTPBasicAuth('username', 'password'))

框架对比与选择指南

特性	Django	Flask	Requests
类型	全栈Web框架	微框架	HTTP客户端库
复杂度	高	低	很低
内置功能	ORM, Admin, 认证等	仅路由和模板	无
灵活性	较低(约定优于配置)	高	非常高
适用场景	复杂Web应用, CMS	小型应用, API, 微服务	发送HTTP请求
学习曲线	陡峭	平缓	非常平缓
扩展性	通过应用扩展	通过扩展包扩展	本身功能完整

选择建议：

• 需要快速构建功能完整的管理系统 → Django

• 构建REST API或小型Web应用 → Flask

• 需要与Web服务交互 → Requests

• 不确定项目规模 → 从Flask开始，需要时迁移到Django

实际项目结构示例

1 Django项目结构

myproject/
├── manage.py
├── requirements.txt
├── myproject/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── myapp/
    ├── migrations/
    ├── __init__.py
    ├── admin.py
    ├── apps.py
    ├── models.py
    ├── tests.py
    ├── urls.py
    └── views.py

2 Flask项目结构

myflaskapp/
├── app.py
├── config.py
├── requirements.txt
├── static/
├── templates/
└── instance/

3 Requests集成示例

# 在Flask应用中调用外部API
from flask import Flask, jsonify
import requests

app = Flask(__name__)

@app.route('/weather/<city>')
def weather(city):
    api_key = "your-api-key"
    url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}"
    response = requests.get(url)
    if response.status_code == 200:
        return jsonify(response.json())
    return jsonify({"error": "City not found"}), 404

安全最佳实践

1 Django安全

# settings.py 安全配置
SECRET_KEY = os.environ.get('SECRET_KEY')  # 从环境变量获取
DEBUG = False  # 生产环境必须关闭
ALLOWED_HOSTS = ['yourdomain.com']  # 限制主机头
CSRF_COOKIE_SECURE = True  # 仅HTTPS传输CSRF cookie
SESSION_COOKIE_SECURE = True  # 仅HTTPS传输会话cookie

2 Flask安全

# 配置示例
app.config.update(
    SECRET_KEY=os.environ.get('FLASK_SECRET_KEY'),
    SESSION_COOKIE_SECURE=True,
    REMEMBER_COOKIE_SECURE=True,
    SESSION_COOKIE_HTTPONLY=True,
    SESSION_COOKIE_SAMESITE='Lax',
)

# 使用Flask-Talisman扩展加强安全
from flask_talisman import Talisman
Talisman(app, force_https=True)

3 Requests安全

# 验证SSL证书(默认已启用)
requests.get('https://example.com', verify=True)

# 自定义CA证书包
requests.get('https://example.com', verify='/path/to/certfile')

# 禁用证书验证(不推荐，仅用于测试)
requests.get('https://example.com', verify=False)

掌握这三个工具的组合使用，可以构建从简单脚本到复杂Web应用的各类Python项目。Django适合大型全功能应用，Flask适合灵活的小型项目，而Requests则是与Web服务交互的利器。

 

Django、Flask和Requests的学习路径

针对Django、Flask和Requests这三个Python库，设计了分阶段的学习建议，帮助高效掌握它们。

学习顺序建议

1. 先学Requests（1-2周）

• 为什么先学：作为HTTP客户端库，Requests是理解Web交互的基础

• 学习目标：掌握HTTP协议基本原理和API调用方法

• 适用场景：爬虫开发、调用第三方API、微服务通信

2. 再学Flask（2-4周）

• 为什么接着学：轻量级框架，理解Web开发核心概念

• 学习目标：掌握路由、视图、模板等基础Web开发概念

• 适用场景：小型Web应用、REST API开发、原型开发

3. 最后学Django（4-8周）

• 为什么最后学：全功能框架，概念较多但体系完整

• 学习目标：掌握完整Web开发流程和MVC/MVT架构

• 适用场景：中大型Web应用、内容管理系统、企业级应用

分库详细学习建议

Requests学习路径

初级阶段（1-3天）

1. 掌握基本HTTP方法：

   response = requests.get('https://api.example.com/data')
   requests.post('https://api.example.com/data', data={'key': 'value'})

2. 理解响应对象：

   response.status_code  # 状态码
   response.text  # 响应内容
   response.json()  # JSON响应

中级阶段（3-7天）

1. 学习高级参数：

   # 带参数的请求
   params = {'key1': 'value1', 'key2': ['value2', 'value3']}
   requests.get('https://httpbin.org/get', params=params)

2. 会话保持：

   session = requests.Session()
   session.get('https://example.com/login', auth=('user', 'pass'))

高级阶段（1-2周）

1. 异常处理：

   try:
       response = requests.get(url, timeout=3)
       response.raise_for_status()
   except requests.exceptions.RequestException as err:
       print(f"请求错误: {err}")

2. 流式处理和自定义适配器

Flask学习路径

初级阶段（1周）

1. 基础应用结构：

   from flask import Flask
   app = Flask(__name__)
   
   @app.route('/')
   def home():
       return 'Hello World!'

2. 路由和视图：

   @app.route('/user/<username>')
   def show_user(username):
       return f'User: {username}'

中级阶段（2-3周）

1. 模板渲染（Jinja2）：

   from flask import render_template
   
   @app.route('/hello/')
   @app.route('/hello/<name>')
   def hello(name=None):
       return render_template('hello.html', name=name)

2. 使用扩展：

   from flask_sqlalchemy import SQLAlchemy
   db = SQLAlchemy(app)

高级阶段（3-4周）

1. 应用工厂模式：

   def create_app(config_filename):
       app = Flask(__name__)
       app.config.from_pyfile(config_filename)
       
       from yourapplication.model import db
       db.init_app(app)
       
       return app

2. 蓝图（Blueprints）组织大型应用

Django学习路径

初级阶段（2周）

1. 项目结构理解：

   django-admin startproject mysite
   python manage.py startapp polls

2. 基础MTV模式：

   # models.py
   class Question(models.Model):
       question_text = models.CharField(max_length=200)
   
   # views.py
   def index(request):
       return HttpResponse("Hello, world.")

中级阶段（3-4周）

1. 管理员界面：

   from django.contrib import admin
   admin.site.register(Question)

2. 表单处理：

   from django import forms
   
   class NameForm(forms.Form):
       your_name = forms.CharField(label='Your name', max_length=100)

高级阶段（4-8周）

1. REST框架：

   from rest_framework import serializers, viewsets
   
   class UserSerializer(serializers.ModelSerializer):
       class Meta:
           model = User
           fields = ['url', 'username']
   
   class UserViewSet(viewsets.ModelViewSet):
       queryset = User.objects.all()
       serializer_class = UserSerializer

2. 高级安全配置和性能优化

学习资源推荐

Requests

• 官方文档：Requests: HTTP for Humans™ — Requests 2.32.4 documentation

• 实践项目：构建一个天气查询CLI工具

Flask

• 官方文档：Welcome to Flask — Flask Documentation (3.1.x)

• 推荐教程：Miguel Grinberg的Flask Mega-Tutorial

• 实践项目：构建一个博客系统或待办事项应用

Django

• 官方文档：Django documentation | Django documentation | Django

• 推荐教程：Django官方入门教程

• 实践项目：构建一个完整的电子商务网站

常见学习误区与避免方法

1. 过早优化：先实现功能，再考虑优化

   • 错误做法：一开始就追求完美架构

   • 正确做法：先完成最小可行产品(MVP)

2. 忽视基础：直接跳入框架学习

   • 错误做法：不学Python基础直接学Django

   • 正确做法：先掌握Python核心概念

3. 孤立学习：只学不用

   • 错误做法：只看教程不写代码

   • 正确做法：每个概念都配合作业练习

4. 忽视调试：不学调试技巧

   • 错误做法：用print()调试一切

   • 正确做法：学习使用pdb和日志系统

学习时间规划

阶段	时间投入	学习内容	产出项目
第1-2周	每天2小时	Requests基础+Flask基础	API调用工具+简单Flask应用
第3-5周	每天2小时	Flask中级+Django基础	博客系统+Django管理后台
第6-8周	每天3小时	Django中级+项目实践	完整电子商务网站
第9周+	按需学习	高级主题和特定领域深入	个人定制项目

职业发展方向建议

1. Web开发工程师：

   • 重点：Django + Flask + 前端基础

   • 学习路线：Django → DRF → 前端框架(React/Vue)

2. API开发工程师：

   • 重点：Flask + Requests + FastAPI

   • 学习路线：Requests → Flask → FastAPI → 微服务架构

3. 全栈工程师：

   • 重点：Django + 前端 + 数据库

   • 学习路线：Django全栈 → 前端深入 → 性能优化

记住：学习过程中最重要的是保持编码实践，每个概念都通过实际项目来巩固。遇到问题时，学会查阅官方文档和使用调试工具，这是成长为专业开发者的关键能力。