当前位置： 首页 > article >正文

Python 课程21-Django

article 2024/10/4 3:13:29

前言

在当今互联网时代，Web开发已成为一项必备技能。而Python作为一门简洁、高效的编程语言，其Web框架Django以其强大的功能和快速开发的特点，受到了广大开发者的青睐。如果你想深入学习Django，构建自己的Web应用，那么本教程将是你的最佳起点。

本教程将以循序渐进的方式，带你从零开始，深入了解Django的各个核心组件，包括模型、视图、模板、URL路由等。通过实践，你将学会如何创建一个功能完整的博客应用。

目录

  1. 环境准备
    • 安装Django
  2. 创建Django项目
    • 初始化项目
    • 运行开发服务器
  3. 创建应用程序
    • 什么是Django应用
    • 创建博客应用
    • 注册应用
  4. 设计数据库模型（Models）
    • 定义博客文章模型
    • 迁移数据库
  5. Django管理后台
    • 创建超级用户
    • 注册模型到管理后台
    • 使用管理后台管理数据
  6. 编写视图（Views）
    • 什么是视图函数
    • 创建文章列表视图
    • 创建文章详情视图
  7. 配置URL路由
    • 项目级URL配置
    • 应用级URL配置
  8. 编写模板（Templates）
    • 设置模板目录
    • 创建文章列表模板
    • 创建文章详情模板
  9. 使用静态文件（Static Files）
    • 配置静态文件目录
    • 引入CSS样式美化页面
  10. 添加分页功能
    • 使用Paginator类
    • 在模板中添加分页控件
  11. 添加评论功能
    • 定义评论模型
    • 创建评论表单
    • 处理评论提交
  12. 用户认证与权限管理
    • 注册与登录功能
    • 权限控制
  13. 部署到生产环境
    • 使用Gunicorn和Nginx
    • 数据库迁移
    • 安全性设置
  14. 结论

一、环境准备

1. 安装Django

使用pip安装Django：

pip install django

 安装完成后，输入以下命令检查版本：

django-admin --version

二、创建Django项目

1. 初始化项目

使用django-admin命令创建一个新的Django项目，命名为mysite：

django-admin startproject mysite
cd mysite

 项目目录结构如下：

mysite/
    manage.py
    mysite/
        __init__.py
        settings.py
        urls.py
        wsgi.py

2. 运行开发服务器

启动Django自带的开发服务器：

python manage.py runserver

在浏览器中访问http://127.0.0.1:8000/，你应该能看到Django的欢迎页面，说明项目创建成功。

三、创建应用程序

1. 什么是Django应用

Django项目是由多个应用组成的，每个应用负责特定的功能。应用可以很容易地被复用。

2. 创建博客应用

使用以下命令创建名为blog的应用：

python manage.py startapp blog

 此时，项目目录中会多一个blog文件夹，结构如下：

blog/
    __init__.py
    admin.py
    apps.py
    models.py
    tests.py
    views.py

3. 注册应用

在mysite/settings.py中，将blog应用添加到INSTALLED_APPS列表中：

INSTALLED_APPS = [
    # Django默认应用
    'django.contrib.admin',
    'django.contrib.auth',
    # ...

    # 我们的博客应用
    'blog.apps.BlogConfig',
]

四、设计数据库模型（Models）

1. 定义博客文章模型

在blog/models.py中，定义Post模型，代表一篇博客文章：

from django.db import models
from django.utils import timezone

class Post(models.Model):
    title = models.CharField('标题', max_length=200)
    author = models.CharField('作者', max_length=100)
    content = models.TextField('内容')
    created_at = models.DateTimeField('创建时间', default=timezone.now)
    updated_at = models.DateTimeField('更新时间', auto_now=True)

    class Meta:
        verbose_name = '文章'
        verbose_name_plural = '文章'

    def __str__(self):
        return self.title

2. 迁移数据库

生成迁移文件：
python manage.py makemigrations

执行迁移：

python manage.py migrate

此时，Django会在数据库中创建对应的表。

五、Django管理后台

1. 创建超级用户

为了管理数据，我们需要创建一个超级用户：

python manage.py createsuperuser

按照提示输入用户名、邮箱和密码。

2. 注册模型到管理后台

在blog/admin.py中注册Post模型：

from django.contrib import admin
from .models import Post

@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'created_at')
    search_fields = ('title', 'content')

3. 使用管理后台管理数据

启动开发服务器，访问http://127.0.0.1:8000/admin/，使用刚创建的超级用户登录。你将看到Post模型，可以在这里添加、修改和删除文章。

六、编写视图（Views）

1. 什么是视图函数

视图函数负责处理HTTP请求，并返回HTTP响应。Django通过视图将模型和模板连接起来。

2. 创建文章列表视图

在blog/views.py中，添加以下代码：

from django.shortcuts import render
from .models import Post

def post_list(request):
    posts = Post.objects.all().order_by('-created_at')
    return render(request, 'blog/post_list.html', {'posts': posts})

3. 创建文章详情视图

def post_detail(request, pk):
    post = Post.objects.get(pk=pk)
    return render(request, 'blog/post_detail.html', {'post': post})

七、配置URL路由

1. 项目级URL配置

在mysite/urls.py中，包含blog应用的URL：

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('blog.urls')),
]

2. 应用级URL配置

在blog目录下创建urls.py，添加以下代码：

from django.urls import path
from . import views

app_name = 'blog'

urlpatterns = [
    path('', views.post_list, name='post_list'),
    path('post/<int:pk>/', views.post_detail, name='post_detail'),
]

八、编写模板（Templates）

1. 设置模板目录

在mysite/settings.py中，设置模板目录：

import os

TEMPLATES = [
    {
        # ...
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        # ...
    },
]

2. 创建文章列表模板

在项目根目录下创建templates/blog/post_list.html：

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>我的博客</title>
</head>
<body>
    <h1>博客文章列表</h1>
    {% for post in posts %}
        <div>
            <h2><a href="{% url 'blog:post_detail' pk=post.pk %}">{{ post.title }}</a></h2>
            <p>作者：{{ post.author }} | 创建时间：{{ post.created_at }}</p>
            <p>{{ post.content|truncatechars:100 }}</p>
        </div>
        <hr>
    {% empty %}
        <p>暂无文章。</p>
    {% endfor %}
</body>
</html>

3. 创建文章详情模板

在templates/blog/post_detail.html中：

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>{{ post.title }}</title>
</head>
<body>
    <h1>{{ post.title }}</h1>
    <p>作者：{{ post.author }} | 创建时间：{{ post.created_at }}</p>
    <div>
        {{ post.content }}
    </div>
    <a href="{% url 'blog:post_list' %}">返回列表</a>
</body>
</html>

九、使用静态文件（Static Files）

1. 配置静态文件目录

在mysite/settings.py中，添加：

STATIC_URL = '/static/'
STATICFILES_DIRS = [os.path.join(BASE_DIR, 'static')]

2. 引入CSS样式美化页面

在项目根目录下创建static/css/style.css，添加一些基本样式：

body {
    font-family: Arial, sans-serif;
    margin: 20px;
}

h1, h2 {
    color: #333;
}

a {
    text-decoration: none;
    color: #1a0dab;
}

 在模板中引入CSS文件：

<!-- 在<head>中添加 -->
{% load static %}
<link rel="stylesheet" href="{% static 'css/style.css' %}">

十、添加分页功能

1. 使用Paginator类

在views.py中，修改post_list视图，添加分页功能：

from django.core.paginator import Paginator

def post_list(request):
    post_list = Post.objects.all().order_by('-created_at')
    paginator = Paginator(post_list, 5)  # 每页显示5篇文章

    page_number = request.GET.get('page')
    posts = paginator.get_page(page_number)
    return render(request, 'blog/post_list.html', {'posts': posts})

2. 在模板中添加分页控件

<!-- 在post_list.html的底部添加 -->
<div class="pagination">
    <span class="step-links">
        {% if posts.has_previous %}
            <a href="?page=1">首页</a>
            <a href="?page={{ posts.previous_page_number }}">上一页</a>
        {% endif %}

        <span class="current">
            第 {{ posts.number }} 页，共 {{ posts.paginator.num_pages }} 页
        </span>

        {% if posts.has_next %}
            <a href="?page={{ posts.next_page_number }}">下一页</a>
            <a href="?page={{ posts.paginator.num_pages }}">尾页</a>
        {% endif %}
    </span>
</div>

十一、添加评论功能

1. 定义评论模型

在blog/models.py中，添加Comment模型：

class Comment(models.Model):
    post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name='comments')
    name = models.CharField('姓名', max_length=80)
    email = models.EmailField('邮箱')
    body = models.TextField('评论内容')
    created_at = models.DateTimeField('评论时间', default=timezone.now)

    class Meta:
        verbose_name = '评论'
        verbose_name_plural = '评论'

    def __str__(self):
        return f'评论 {self.body} 由 {self.name}'

 迁移数据库：

python manage.py makemigrations
python manage.py migrate

2. 创建评论表单

在blog/forms.py中：

from django import forms
from .models import Comment

class CommentForm(forms.ModelForm):
    class Meta:
        model = Comment
        fields = ('name', 'email', 'body')

3. 处理评论提交

在views.py中的post_detail视图，处理评论表单：

from .forms import CommentForm

def post_detail(request, pk):
    post = Post.objects.get(pk=pk)
    comments = post.comments.all()
    new_comment = None

    if request.method == 'POST':
        comment_form = CommentForm(data=request.POST)
        if comment_form.is_valid():
            # 创建评论对象，但不保存到数据库
            new_comment = comment_form.save(commit=False)
            # 关联到当前的文章
            new_comment.post = post
            # 保存评论
            new_comment.save()
    else:
        comment_form = CommentForm()

    return render(request, 'blog/post_detail.html', {
        'post': post,
        'comments': comments,
        'new_comment': new_comment,
        'comment_form': comment_form
    })

4. 更新文章详情模板

在post_detail.html中，添加评论显示和提交表单：

<h2>评论</h2>
{% for comment in comments %}
    <div>
        <p><strong>{{ comment.name }}</strong> 于 {{ comment.created_at }} 发表评论：</p>
        <p>{{ comment.body }}</p>
    </div>
{% empty %}
    <p>还没有评论，快来抢沙发！</p>
{% endfor %}

<h2>添加评论</h2>
{% if new_comment %}
    <p>你的评论已成功添加！</p>
{% else %}
    <form method="post">
        {% csrf_token %}
        {{ comment_form.as_p }}
        <button type="submit">提交评论</button>
    </form>
{% endif %}

十二、用户认证与权限管理

1. 注册与登录功能

创建注册表单

在blog/forms.py中，添加注册表单：

from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User

class RegisterForm(UserCreationForm):
    email = forms.EmailField(required=True)

    class Meta:
        model = User
        fields = ('username', 'email', 'password1', 'password2')
编写注册视图

在blog/views.py中：

from django.contrib.auth import login
from .forms import RegisterForm

def register(request):
    if request.method == 'POST':
        form = RegisterForm(request.POST)
        if form.is_valid():
            user = form.save()
            login(request, user)
            return redirect('blog:post_list')
    else:
        form = RegisterForm()
    return render(request, 'registration/register.html', {'form': form})
配置URL

在blog/urls.py中：

from django.contrib.auth import views as auth_views

urlpatterns += [
    path('register/', views.register, name='register'),
    path('login/', auth_views.LoginView.as_view(template_name='registration/login.html'), name='login'),
    path('logout/', auth_views.LogoutView.as_view(), name='logout'),
]
创建模板

创建templates/registration/register.html和templates/registration/login.html，编写相应的表单。

2. 权限控制

在需要限制访问的视图上添加装饰器，例如：

from django.contrib.auth.decorators import login_required

@login_required
def post_create(request):
    # 仅登录用户可以访问
    pass

十三、部署到生产环境

1. 使用Gunicorn和Nginx

在生产环境中，不建议使用Django自带的开发服务器。可以使用Gunicorn作为WSGI服务器，Nginx作为反向代理。

安装Gunicorn：
pip install gunicorn
启动Gunicorn：
gunicorn mysite.wsgi:application --bind 0.0.0.0:8000

2. 数据库迁移

在生产环境中，建议使用更强大的数据库，如PostgreSQL或MySQL。

安装数据库驱动：
pip install psycopg2-binary  # PostgreSQL
pip install mysqlclient      # MySQL
修改settings.py中的数据库配置。

3. 安全性设置

关闭调试模式：
DEBUG = False

设置允许的主机：

ALLOWED_HOSTS = ['yourdomain.com', 'www.yourdomain.com']

十四、结论

通过本教程，我们从零开始，深入探索了Django的核心功能，成功地构建了一个功能完善的博客应用。在这个过程中，你不仅了解了Django的基本架构和工作原理，还掌握了如何实际运用Django的模型、视图、模板和URL配置等核心组件。


http://www.kler.cn/news/331161.html

相关文章：

  • 初学Vue
  • 构造+bfs，CF 761E - Dasha and Puzzle
  • GPT带我学-设计模式16-原型模式
  • Codeforces Round 976 (Div. 2) and Divide By Zero 9.0（A~E）
  • Java Web 之 Cookie 详解
  • 网络协议一般分为几类？如何划分
  • 微服务nginx解析部署使用全流程
  • 通过fdisk初始化Linux数据盘
  • ECharts 快速使用
  • 【小程序】微信小程序课程 -4 项目实战
  • 快手：从 Clickhouse 到 Apache Doris，实现湖仓分离向湖仓一体架构升级
  • Vue.js与Flask/Django后端的配合----案例详细说明
  • 从零开始实现RPC框架---------项目介绍及环境准备
  • 433按键单片机解码
  • 深入理解MySQL中的MVCC原理及实现
  • 2024软件测试面试题大全（含答案+文档）
  • 开源大模型 vs闭源大模型
  • 【系统架构设计师】专题：基于构件的软件工程考点
  • Flutter WebSocket简单例子
  • 《C++ 小游戏：简易飞机大战游戏的实现》