PyCharm与Django强强联手打造无缝开发体验从项目创建到部署全流程优化助力开发者轻松构建高质量Web应用

威震华夏关云长

引言：PyCharm与Django的完美结合

PyCharm是由JetBrains开发的一款功能强大的Python集成开发环境(IDE)，而Django则是Python世界中最受欢迎的Web框架之一。两者的结合为Web开发者提供了一个高效、便捷的开发环境，极大地提升了开发效率和代码质量。本文将详细介绍如何利用PyCharm和Django的强强联手，从项目创建到部署的全流程优化，帮助开发者轻松构建高质量的Web应用。

PyCharm与Django简介

PyCharm：Python开发的首选IDE

PyCharm是一款专为Python开发设计的集成开发环境，提供了智能代码编辑、代码分析、图形化调试器、集成测试器、版本控制系统集成等强大功能。PyCharm有两个版本：专业版和社区版。其中，专业版提供了对Web框架（包括Django）的全面支持，是开发Django应用的首选工具。

PyCharm的主要优势包括：

1. 智能代码编辑：提供代码补全、语法高亮、错误检查等功能。
2. 强大的调试工具：图形化调试器，支持断点、变量监视等。
3. 集成版本控制：支持Git、SVN等版本控制系统。
4. 数据库工具：内置数据库客户端，支持多种数据库。
5. Web框架支持：对Django、Flask等Web框架的全面支持。

Django：高效的Python Web框架

Django是一个高级的Python Web框架，遵循”DRY(Don’t Repeat Yourself)“原则，旨在快速开发和干净、实用的设计。Django的主要特点包括：

1. MTV架构：模型(Model)、模板(Template)、视图(View)的清晰分离。
2. ORM系统：强大的对象关系映射，简化数据库操作。
3. 自动管理界面：自动生成管理后台。
4. 内置安全功能：防止CSRF、XSS、SQL注入等常见攻击。
5. 丰富的生态系统：大量的第三方包和扩展。

在PyCharm中创建Django项目

安装必要的软件

在开始之前，确保已安装以下软件：

1. Python：Django需要Python环境，建议使用Python 3.6或更高版本。
2. PyCharm Professional：专业版提供了完整的Django支持。
3. Django：可以通过pip安装。

安装Django的命令：

2. pip install django

复制代码

创建新的Django项目

在PyCharm中创建Django项目的步骤如下：

1. 打开PyCharm，选择”File” > “New Project”。
2. 在左侧选择”Django”。
3. 设置项目位置和名称。
4. 选择Python解释器。可以新建虚拟环境，推荐使用虚拟环境以隔离项目依赖。
5. 点击”Create”。

PyCharm将自动创建Django项目的基本结构，包括：

2. myproject/
3.     manage.py
4.     myproject/
5.         __init__.py
6.         settings.py
7.         urls.py
8.         asgi.py
9.         wsgi.py

复制代码

配置项目设置

创建项目后，需要进行一些基本配置：

1. 数据库设置：在settings.py中配置数据库连接。默认使用SQLite，适合开发环境。

2. # settings.py
3. DATABASES = {
4.     'default': {
5.         'ENGINE': 'django.db.backends.sqlite3',
6.         'NAME': BASE_DIR / 'db.sqlite3',
7.     }
8. }

复制代码

对于生产环境，可以配置为PostgreSQL或MySQL：

2. # PostgreSQL配置示例
3. DATABASES = {
4.     'default': {
5.         'ENGINE': 'django.db.backends.postgresql',
6.         'NAME': 'mydatabase',
7.         'USER': 'mydatabaseuser',
8.         'PASSWORD': 'mypassword',
9.         'HOST': 'localhost',
10.         'PORT': '5432',
11.     }
12. }

复制代码

1. 静态文件设置：配置静态文件的存储和访问路径。

2. # settings.py
3. STATIC_URL = '/static/'
4. STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
5. STATICFILES_DIRS = [
6.     os.path.join(BASE_DIR, 'static'),
7. ]

复制代码

1. 模板设置：配置模板路径。

2. # settings.py
3. TEMPLATES = [
4.     {
5.         'BACKEND': 'django.template.backends.django.DjangoTemplates',
6.         'DIRS': [os.path.join(BASE_DIR, 'templates')],
7.         'APP_DIRS': True,
8.         'OPTIONS': {
9.             'context_processors': [
10.                 'django.template.context_processors.debug',
11.                 'django.template.context_processors.request',
12.                 'django.contrib.auth.context_processors.auth',
13.                 'django.contrib.messages.context_processors.messages',
14.             ],
15.         },
16.     },
17. ]

复制代码

在PyCharm中开发Django应用

创建Django应用

在Django项目中，应用是功能模块的集合。创建应用的步骤如下：

1. 在PyCharm底部的Terminal中运行命令：

2. python manage.py startapp myapp

复制代码

1. 在settings.py中注册新创建的应用：

2. # settings.py
3. INSTALLED_APPS = [
4.     'django.contrib.admin',
5.     'django.contrib.auth',
6.     'django.contrib.contenttypes',
7.     'django.contrib.sessions',
8.     'django.contrib.messages',
9.     'django.contrib.staticfiles',
10.     'myapp',  # 新添加的应用
11. ]

复制代码

定义模型

模型是Django应用的数据结构，定义在models.py文件中。PyCharm提供了对模型定义的智能支持。

2. # myapp/models.py
3. from django.db import models
4. from django.utils import timezone
6. class Post(models.Model):
7.     title = models.CharField(max_length=200)
8.     content = models.TextField()
9.     created_date = models.DateTimeField(default=timezone.now)
10.     published_date = models.DateTimeField(blank=True, null=True)
11.    
12.     def publish(self):
13.         self.published_date = timezone.now()
14.         self.save()
15.    
16.     def __str__(self):
17.         return self.title
19. class Comment(models.Model):
20.     post = models.ForeignKey('Post', on_delete=models.CASCADE, related_name='comments')
21.     author = models.CharField(max_length=100)
22.     text = models.TextField()
23.     created_date = models.DateTimeField(default=timezone.now)
24.     approved_comment = models.BooleanField(default=False)
25.    
26.     def approve(self):
27.         self.approved_comment = True
28.         self.save()
29.    
30.     def __str__(self):
31.         return self.text

复制代码

定义模型后，需要创建并应用数据库迁移：

2. python manage.py makemigrations
3. python manage.py migrate

复制代码

PyCharm的数据库工具可以可视化管理数据库，查看表结构和数据。

创建视图

视图处理HTTP请求并返回响应。在PyCharm中，可以轻松创建和编辑视图。

2. # myapp/views.py
3. from django.shortcuts import render, get_object_or_404, redirect
4. from django.utils import timezone
5. from .models import Post, Comment
6. from .forms import PostForm, CommentForm
8. def post_list(request):
9.     posts = Post.objects.filter(published_date__lte=timezone.now()).order_by('published_date')
10.     return render(request, 'myapp/post_list.html', {'posts': posts})
12. def post_detail(request, pk):
13.     post = get_object_or_404(Post, pk=pk)
14.     return render(request, 'myapp/post_detail.html', {'post': post})
16. def post_new(request):
17.     if request.method == "POST":
18.         form = PostForm(request.POST)
19.         if form.is_valid():
20.             post = form.save(commit=False)
21.             post.author = request.user
22.             post.save()
23.             return redirect('post_detail', pk=post.pk)
24.     else:
25.         form = PostForm()
26.     return render(request, 'myapp/post_edit.html', {'form': form})
28. def post_edit(request, pk):
29.     post = get_object_or_404(Post, pk=pk)
30.     if request.method == "POST":
31.         form = PostForm(request.POST, instance=post)
32.         if form.is_valid():
33.             post = form.save(commit=False)
34.             post.author = request.user
35.             post.save()
36.             return redirect('post_detail', pk=post.pk)
37.     else:
38.         form = PostForm(instance=post)
39.     return render(request, 'myapp/post_edit.html', {'form': form})

复制代码

创建表单

Django提供了强大的表单处理功能。在PyCharm中，可以轻松创建和编辑表单类。

2. # myapp/forms.py
3. from django import forms
4. from .models import Post, Comment
6. class PostForm(forms.ModelForm):
7.     class Meta:
8.         model = Post
9.         fields = ('title', 'content',)
11. class CommentForm(forms.ModelForm):
12.     class Meta:
13.         model = Comment
14.         fields = ('author', 'text',)

复制代码

配置URL

URL配置将URL映射到视图。在PyCharm中，可以轻松管理和编辑URL配置。

2. # myproject/urls.py
3. from django.contrib import admin
4. from django.urls import path, include
5. from django.conf import settings
6. from django.conf.urls.static import static
8. urlpatterns = [
9.     path('admin/', admin.site.urls),
10.     path('', include('myapp.urls')),
11. ]
13. if settings.DEBUG:
14.     urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

复制代码

2. # myapp/urls.py
3. from django.urls import path
4. from . import views
6. urlpatterns = [
7.     path('', views.post_list, name='post_list'),
8.     path('post/<int:pk>/', views.post_detail, name='post_detail'),
9.     path('post/new/', views.post_new, name='post_new'),
10.     path('post/<int:pk>/edit/', views.post_edit, name='post_edit'),
11. ]

复制代码

创建模板

模板定义了页面的HTML结构。PyCharm提供了对Django模板的语法高亮和智能提示。

2. <!-- myapp/templates/myapp/base.html -->
3. <!DOCTYPE html>
4. <html>
5. <head>
6.     <title>My Django Blog</title>
7.     <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
8. </head>
9. <body>
10.     <div class="container">
11.         <nav class="navbar navbar-expand-lg navbar-light bg-light">
12.             <a class="navbar-brand" href="{% url 'post_list' %}">Django Blog</a>
13.             <div class="collapse navbar-collapse">
14.                 <ul class="navbar-nav mr-auto">
15.                     <li class="nav-item">
16.                         <a class="nav-link" href="{% url 'post_new' %}">New Post</a>
17.                     </li>
18.                 </ul>
19.             </div>
20.         </nav>
21.         <div class="content">
22.             {% block content %}
23.             {% endblock %}
24.         </div>
25.     </div>
26. </body>
27. </html>

复制代码

2. <!-- myapp/templates/myapp/post_list.html -->
3. {% extends 'myapp/base.html' %}
5. {% block content %}
6.     <h1>Blog Posts</h1>
7.     {% for post in posts %}
8.         <div class="post">
9.             <h2><a href="{% url 'post_detail' pk=post.pk %}">{{ post.title }}</a></h2>
10.             <p>Published: {{ post.published_date }}</p>
11.             <p>{{ post.content|truncatewords:30 }}</p>
12.         </div>
13.     {% endfor %}
14. {% endblock %}

复制代码

PyCharm中的Django开发优化技巧

使用PyCharm的代码智能功能

PyCharm提供了多种代码智能功能，可以大大提高Django开发效率：

1. 代码补全：PyCharm提供智能代码补全，包括Django模型字段、视图函数、模板标签等。
2. 快速导航：使用Ctrl + B(Windows/Linux)或Cmd + B(Mac)可以快速跳转到定义处。例如，从视图函数跳转到模板，或从模板标签跳转到定义。
3. 代码检查：PyCharm会实时检查代码中的错误和潜在问题，并提供建议。
4. 重构：支持重命名、提取方法、提取变量等重构操作，并自动更新相关引用。

代码补全：PyCharm提供智能代码补全，包括Django模型字段、视图函数、模板标签等。

快速导航：使用Ctrl + B(Windows/Linux)或Cmd + B(Mac)可以快速跳转到定义处。例如，从视图函数跳转到模板，或从模板标签跳转到定义。

代码检查：PyCharm会实时检查代码中的错误和潜在问题，并提供建议。

重构：支持重命名、提取方法、提取变量等重构操作，并自动更新相关引用。

使用PyCharm的调试工具

PyCharm提供了强大的调试工具，可以帮助开发者快速定位和解决问题：

1. 设置断点：在代码行号旁边点击即可设置断点。
2. 启动调试：点击工具栏上的调试按钮或使用Shift + F9快捷键启动调试。
3. 变量监视：在调试过程中，可以监视变量的值，甚至修改变量值。
4. 表达式求值：在调试过程中，可以评估任意Python表达式的值。
5. Django模板调试：PyCharm支持Django模板的调试，可以在模板中设置断点。

设置断点：在代码行号旁边点击即可设置断点。

启动调试：点击工具栏上的调试按钮或使用Shift + F9快捷键启动调试。

变量监视：在调试过程中，可以监视变量的值，甚至修改变量值。

表达式求值：在调试过程中，可以评估任意Python表达式的值。

Django模板调试：PyCharm支持Django模板的调试，可以在模板中设置断点。

使用PyCharm的数据库工具

PyCharm内置了强大的数据库工具，可以方便地管理和操作数据库：

1. 数据库连接：在PyCharm中可以直接连接到数据库，无需使用外部工具。
2. SQL编辑器：提供SQL语法高亮、代码补全和执行功能。
3. 数据编辑：可以直接在PyCharm中编辑数据库表中的数据。
4. ER图：可以生成数据库的实体关系图，直观地查看表之间的关系。

数据库连接：在PyCharm中可以直接连接到数据库，无需使用外部工具。

SQL编辑器：提供SQL语法高亮、代码补全和执行功能。

数据编辑：可以直接在PyCharm中编辑数据库表中的数据。

ER图：可以生成数据库的实体关系图，直观地查看表之间的关系。

在PyCharm中调试和测试Django应用

配置Django服务器

在PyCharm中，可以配置和运行Django开发服务器：

1. 打开”Run” > “Edit Configurations”。
2. 点击”+“按钮，选择”Django Server”。
3. 配置服务器参数，如主机、端口等。
4. 点击”OK”保存配置。

现在，可以通过点击工具栏上的运行按钮或使用Shift + F10快捷键启动Django服务器。

创建和运行测试

测试是确保代码质量的重要手段。在PyCharm中，可以轻松创建和运行Django测试：

1. 创建测试：在tests.py文件中创建测试用例。

2. # myapp/tests.py
3. from django.test import TestCase
4. from django.utils import timezone
5. from django.urls import reverse
6. from .models import Post
8. class PostModelTest(TestCase):
9.     def create_post(self, title="Test Post", content="Test Content"):
10.         return Post.objects.create(title=title, content=content, created_date=timezone.now())
11.    
12.     def test_post_creation(self):
13.         post = self.create_post()
14.         self.assertTrue(isinstance(post, Post))
15.         self.assertEqual(post.__str__(), post.title)
17. class PostViewTest(TestCase):
18.     def setUp(self):
19.         self.post = Post.objects.create(title="Test Post", content="Test Content",
20.                                       created_date=timezone.now(), published_date=timezone.now())
21.    
22.     def test_post_list_view(self):
23.         url = reverse('post_list')
24.         resp = self.client.get(url)
25.         self.assertEqual(resp.status_code, 200)
26.         self.assertIn(self.post.title, resp.content.decode())
27.    
28.     def test_post_detail_view(self):
29.         url = reverse('post_detail', kwargs={'pk': self.post.pk})
30.         resp = self.client.get(url)
31.         self.assertEqual(resp.status_code, 200)
32.         self.assertIn(self.post.title, resp.content.decode())

复制代码

1. 运行测试：右键点击tests.py文件，选择”Run ‘Unittests in tests’“或使用快捷键Ctrl + Shift + F10。
2. 查看测试结果：测试结果将显示在底部工具窗口中，包括通过的测试、失败的测试和错误信息。
3. 调试测试：可以像调试普通代码一样调试测试用例，快速定位问题。

运行测试：右键点击tests.py文件，选择”Run ‘Unittests in tests’“或使用快捷键Ctrl + Shift + F10。

查看测试结果：测试结果将显示在底部工具窗口中，包括通过的测试、失败的测试和错误信息。

调试测试：可以像调试普通代码一样调试测试用例，快速定位问题。

在PyCharm中部署Django应用

准备生产环境

部署Django应用到生产环境需要进行一些配置修改：

1. 修改设置：创建生产环境设置文件。

2. # myproject/settings_production.py
3. from .settings import *
5. # SECURITY WARNING: don't run with debug turned on in production!
6. DEBUG = False
8. ALLOWED_HOSTS = ['your-domain.com', 'www.your-domain.com']
10. # Database
11. # https://docs.djangoproject.com/en/3.1/ref/settings/#databases
12. DATABASES = {
13.     'default': {
14.         'ENGINE': 'django.db.backends.postgresql',
15.         'NAME': 'mydatabase',
16.         'USER': 'mydatabaseuser',
17.         'PASSWORD': 'mypassword',
18.         'HOST': 'localhost',
19.         'PORT': '5432',
20.     }
21. }
23. # Static files (CSS, JavaScript, Images)
24. # https://docs.djangoproject.com/en/3.1/howto/static-files/
25. STATIC_ROOT = '/var/www/static/'
26. MEDIA_ROOT = '/var/www/media/'
28. # Security settings
29. SECURE_SSL_REDIRECT = True
30. SESSION_COOKIE_SECURE = True
31. CSRF_COOKIE_SECURE = True
32. SECURE_BROWSER_XSS_FILTER = True
33. SECURE_CONTENT_TYPE_NOSNIFF = True
34. X_FRAME_OPTIONS = 'DENY'

复制代码

1. 收集静态文件：

2. python manage.py collectstatic --settings=myproject.settings_production

复制代码

使用PyCharm部署到远程服务器

PyCharm提供了多种部署选项，可以轻松将Django应用部署到远程服务器：

1. 配置远程服务器：打开”Tools” > “Deployment” > “Configuration”。点击”+“添加新的服务器配置。配置服务器类型（如SFTP、FTP等）、主机、端口、用户名和密码。配置本地和远程路径映射。
2. 打开”Tools” > “Deployment” > “Configuration”。
3. 点击”+“添加新的服务器配置。
4. 配置服务器类型（如SFTP、FTP等）、主机、端口、用户名和密码。
5. 配置本地和远程路径映射。
6. 部署文件：右键点击项目或特定文件，选择”Deployment” > “Upload to…“。或者使用”Tools” > “Deployment” > “Upload to…“。
7. 右键点击项目或特定文件，选择”Deployment” > “Upload to…“。
8. 或者使用”Tools” > “Deployment” > “Upload to…“。
9. 自动上传：在部署配置中，可以启用”Automatic Upload”选项。这样，当文件被修改时，PyCharm会自动上传到远程服务器。
10. 在部署配置中，可以启用”Automatic Upload”选项。
11. 这样，当文件被修改时，PyCharm会自动上传到远程服务器。

配置远程服务器：

• 打开”Tools” > “Deployment” > “Configuration”。
• 点击”+“添加新的服务器配置。
• 配置服务器类型（如SFTP、FTP等）、主机、端口、用户名和密码。
• 配置本地和远程路径映射。

部署文件：

• 右键点击项目或特定文件，选择”Deployment” > “Upload to…“。
• 或者使用”Tools” > “Deployment” > “Upload to…“。

自动上传：

• 在部署配置中，可以启用”Automatic Upload”选项。
• 这样，当文件被修改时，PyCharm会自动上传到远程服务器。

使用Docker部署Django应用

Docker可以简化Django应用的部署过程。在PyCharm中，可以轻松创建和管理Docker容器：

1. 创建Dockerfile：

2. # Dockerfile
3. FROM python:3.8
4. ENV PYTHONUNBUFFERED 1
5. RUN mkdir /code
6. WORKDIR /code
7. COPY requirements.txt /code/
8. RUN pip install -r requirements.txt
9. COPY . /code/

复制代码

1. 创建docker-compose.yml：

2. # docker-compose.yml
3. version: '3'
4. services:
5.   db:
6.     image: postgres
7.     environment:
8.       POSTGRES_PASSWORD: mypassword
9.       POSTGRES_DB: mydatabase
10.       POSTGRES_USER: mydatabaseuser
11.   web:
12.     build: .
13.     command: python manage.py runserver 0.0.0.0:8000
14.     volumes:
15.       - .:/code
16.     ports:
17.       - "8000:8000"
18.     depends_on:
19.       - db

复制代码

1. 在PyCharm中使用Docker：打开”Run” > “Edit Configurations”。点击”+“按钮，选择”Docker” > “Docker-compose”。选择docker-compose.yml文件。配置服务名称和命令。点击”OK”保存配置。
2. 打开”Run” > “Edit Configurations”。
3. 点击”+“按钮，选择”Docker” > “Docker-compose”。
4. 选择docker-compose.yml文件。
5. 配置服务名称和命令。
6. 点击”OK”保存配置。
7. 运行Docker容器：点击工具栏上的运行按钮或使用Shift + F10快捷键启动Docker容器。PyCharm将自动构建镜像并启动容器。
8. 点击工具栏上的运行按钮或使用Shift + F10快捷键启动Docker容器。
9. PyCharm将自动构建镜像并启动容器。

在PyCharm中使用Docker：

• 打开”Run” > “Edit Configurations”。
• 点击”+“按钮，选择”Docker” > “Docker-compose”。
• 选择docker-compose.yml文件。
• 配置服务名称和命令。
• 点击”OK”保存配置。

运行Docker容器：

• 点击工具栏上的运行按钮或使用Shift + F10快捷键启动Docker容器。
• PyCharm将自动构建镜像并启动容器。

使用Gunicorn和Nginx部署Django应用

在生产环境中，通常使用Gunicorn作为应用服务器，Nginx作为反向代理：

1. 安装Gunicorn：

2. pip install gunicorn

复制代码

1. 创建Gunicorn配置文件：

2. # gunicorn.conf.py
3. bind = "0.0.0.0:8000"
4. workers = 4

复制代码

1. 创建Nginx配置文件：

2. # /etc/nginx/sites-available/myproject
3. server {
4.     listen 80;
5.     server_name your-domain.com www.your-domain.com;
7.     location /static/ {
8.         root /var/www/static;
9.     }
11.     location /media/ {
12.         root /var/www/media;
13.     }
15.     location / {
16.         proxy_pass http://127.0.0.1:8000;
17.         proxy_set_header Host $host;
18.         proxy_set_header X-Real-IP $remote_addr;
19.         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
20.     }
21. }

复制代码

1. 启用Nginx配置：

2. sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled/
3. sudo nginx -t
4. sudo systemctl restart nginx

复制代码

1. 创建systemd服务文件：

2. # /etc/systemd/system/gunicorn.service
3. [Unit]
4. Description=gunicorn daemon
5. After=network.target
7. [Service]
8. User=www-data
9. Group=www-data
10. WorkingDirectory=/path/to/your/project
11. ExecStart=/path/to/your/venv/bin/gunicorn --config gunicorn.conf.py myproject.wsgi:application
13. [Install]
14. WantedBy=multi-user.target

复制代码

1. 启动Gunicorn服务：

2. sudo systemctl start gunicorn
3. sudo systemctl enable gunicorn

复制代码

实际案例：构建一个博客应用

为了展示PyCharm和Django的强大功能，让我们通过构建一个简单的博客应用来实践上述知识。

创建项目和应用

首先，在PyCharm中创建一个新的Django项目，然后创建一个博客应用：

2. python manage.py startapp blog

复制代码

在settings.py中注册应用：

2. INSTALLED_APPS = [
3.     'django.contrib.admin',
4.     'django.contrib.auth',
5.     'django.contrib.contenttypes',
6.     'django.contrib.sessions',
7.     'django.contrib.messages',
8.     'django.contrib.staticfiles',
9.     'blog',
10. ]

复制代码

定义模型

定义博客文章和评论的模型：

2. # blog/models.py
3. from django.db import models
4. from django.contrib.auth.models import User
5. from django.utils import timezone
7. class PublishedManager(models.Manager):
8.     def get_queryset(self):
9.         return super().get_queryset().filter(status='published')
11. class Post(models.Model):
12.     STATUS_CHOICES = (
13.         ('draft', 'Draft'),
14.         ('published', 'Published'),
15.     )
16.     title = models.CharField(max_length=250)
17.     slug = models.SlugField(max_length=250, unique_for_date='publish')
18.     author = models.ForeignKey(User, on_delete=models.CASCADE, related_name='blog_posts')
19.     body = models.TextField()
20.     publish = models.DateTimeField(default=timezone.now)
21.     created = models.DateTimeField(auto_now_add=True)
22.     updated = models.DateTimeField(auto_now=True)
23.     status = models.CharField(max_length=10, choices=STATUS_CHOICES, default='draft')
24.    
25.     objects = models.Manager()  # The default manager.
26.     published = PublishedManager()  # Our custom manager.
27.    
28.     class Meta:
29.         ordering = ('-publish',)
30.    
31.     def __str__(self):
32.         return self.title
34. class Comment(models.Model):
35.     post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name='comments')
36.     name = models.CharField(max_length=80)
37.     email = models.EmailField()
38.     body = models.TextField()
39.     created = models.DateTimeField(auto_now_add=True)
40.     updated = models.DateTimeField(auto_now=True)
41.     active = models.BooleanField(default=True)
42.    
43.     class Meta:
44.         ordering = ('created',)
45.    
46.     def __str__(self):
47.         return f'Comment by {self.name} on {self.post}'

复制代码

运行数据库迁移：

2. python manage.py makemigrations
3. python manage.py migrate

复制代码

创建视图

创建博客文章列表、详情和评论视图：

2. # blog/views.py
3. from django.shortcuts import render, get_object_or_404
4. from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
5. from .models import Post, Comment
6. from .forms import CommentForm
8. def post_list(request):
9.     object_list = Post.published.all()
10.     paginator = Paginator(object_list, 3)  # 3 posts in each page
11.     page = request.GET.get('page')
12.     try:
13.         posts = paginator.page(page)
14.     except PageNotAnInteger:
15.         # If page is not an integer deliver the first page
16.         posts = paginator.page(1)
17.     except EmptyPage:
18.         # If page is out of range deliver last page of results
19.         posts = paginator.page(paginator.num_pages)
20.     return render(request, 'blog/post/list.html', {'posts': posts})
22. def post_detail(request, year, month, day, post):
23.     post = get_object_or_404(Post, slug=post,
24.                                    status='published',
25.                                    publish__year=year,
26.                                    publish__month=month,
27.                                    publish__day=day)
28.    
29.     # List of active comments for this post
30.     comments = post.comments.filter(active=True)
31.    
32.     new_comment = None
33.    
34.     if request.method == 'POST':
35.         # A comment was posted
36.         comment_form = CommentForm(data=request.POST)
37.         if comment_form.is_valid():
38.             # Create Comment object but don't save to database yet
39.             new_comment = comment_form.save(commit=False)
40.             # Assign the current post to the comment
41.             new_comment.post = post
42.             # Save the comment to the database
43.             new_comment.save()
44.     else:
45.         comment_form = CommentForm()
46.    
47.     return render(request, 'blog/post/detail.html', {'post': post,
48.                                                      'comments': comments,
49.                                                      'new_comment': new_comment,
50.                                                      'comment_form': comment_form})

复制代码

创建表单

创建评论表单：

2. # blog/forms.py
3. from django import forms
4. from .models import Comment
6. class CommentForm(forms.ModelForm):
7.     class Meta:
8.         model = Comment
9.         fields = ('name', 'email', 'body')

复制代码

配置URL

配置博客应用的URL：

2. # blog/urls.py
3. from django.urls import path
4. from . import views
6. app_name = 'blog'
8. urlpatterns = [
9.     path('', views.post_list, name='post_list'),
10.     path('<int:year>/<int:month>/<int:day>/<slug:post>/',
11.          views.post_detail,
12.          name='post_detail'),
13. ]

复制代码

在项目的主URL配置中包含博客应用的URL：

2. # myproject/urls.py
3. from django.contrib import admin
4. from django.urls import path, include
5. from django.conf import settings
6. from django.conf.urls.static import static
8. urlpatterns = [
9.     path('admin/', admin.site.urls),
10.     path('blog/', include('blog.urls')),
11. ]
13. if settings.DEBUG:
14.     urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

复制代码

创建模板

创建博客文章列表和详情模板：

2. <!-- blog/templates/blog/base.html -->
3. <!DOCTYPE html>
4. <html>
5. <head>
6.     <title>{% block title %}Django Blog{% endblock %}</title>
7.     <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.5.2/css/bootstrap.min.css">
8. </head>
9. <body>
10.     <div class="container">
11.         <nav class="navbar navbar-expand-lg navbar-light bg-light">
12.             <a class="navbar-brand" href="{% url 'blog:post_list' %}">Django Blog</a>
13.             <div class="collapse navbar-collapse">
14.                 <ul class="navbar-nav mr-auto">
15.                     <li class="nav-item">
16.                         <a class="nav-link" href="{% url 'admin:index' %}">Admin</a>
17.                     </li>
18.                 </ul>
19.             </div>
20.         </nav>
21.         <div class="content">
22.             {% block content %}
23.             {% endblock %}
24.         </div>
25.     </div>
26. </body>
27. </html>

复制代码

2. <!-- blog/templates/blog/post/list.html -->
3. {% extends "blog/base.html" %}
5. {% block title %}Django Blog{% endblock %}
7. {% block content %}
8.     <h1>Django Blog</h1>
9.     {% for post in posts %}
10.         <h2>
11.             <a href="{{ post.get_absolute_url }}">
12.                 {{ post.title }}
13.             </a>
14.         </h2>
15.         <p class="date">
16.             Published {{ post.publish }} by {{ post.author }}
17.         </p>
18.         {{ post.body|truncatewords:30|linebreaks }}
19.     {% endfor %}
20.    
21.     {% include "pagination.html" with page=posts %}
22. {% endblock %}

复制代码

2. <!-- blog/templates/blog/post/detail.html -->
3. {% extends "blog/base.html" %}
5. {% block title %}{{ post.title }}{% endblock %}
7. {% block content %}
8.     <h1>{{ post.title }}</h1>
9.     <div class="date">
10.         Published {{ post.publish }} by {{ post.author }}
11.     </div>
12.     {{ post.body|linebreaks }}
13.    
14.     <hr>
15.    
16.     <h2>Comments</h2>
17.     {% if new_comment %}
18.         <div class="alert alert-success">
19.             Your comment has been added.
20.         </div>
21.     {% endif %}
22.     {% for comment in comments %}
23.         <div class="comment">
24.             <p class="info">
25.                 Comment {{ forloop.counter }} by {{ comment.name }}
26.                 {{ comment.created }}
27.             </p>
28.             {{ comment.body|linebreaks }}
29.         </div>
30.     {% empty %}
31.         <p>There are no comments yet.</p>
32.     {% endfor %}
33.    
34.     <h2>Add a new comment</h2>
35.     <form action="." method="post">
36.         {{ comment_form.as_p }}
37.         {% csrf_token %}
38.         <p><input type="submit" value="Add comment"></p>
39.     </form>
40. {% endblock %}

复制代码

注册模型到管理后台

将博客文章和评论模型注册到Django管理后台：

2. # blog/admin.py
3. from django.contrib import admin
4. from .models import Post, Comment
6. @admin.register(Post)
7. class PostAdmin(admin.ModelAdmin):
8.     list_display = ('title', 'slug', 'author', 'publish', 'status')
9.     list_filter = ('status', 'created', 'publish', 'author')
10.     search_fields = ('title', 'body')
11.     prepopulated_fields = {'slug': ('title',)}
12.     raw_id_fields = ('author',)
13.     date_hierarchy = 'publish'
14.     ordering = ('status', 'publish')
16. @admin.register(Comment)
17. class CommentAdmin(admin.ModelAdmin):
18.     list_display = ('name', 'email', 'post', 'created', 'active')
19.     list_filter = ('active', 'created', 'updated')
20.     search_fields = ('name', 'email', 'body')

复制代码

运行项目

现在，可以运行项目并查看结果：

2. python manage.py runserver

复制代码

访问http://127.0.0.1:8000/blog/查看博客文章列表。

总结：PyCharm与Django的强强联手

PyCharm和Django的结合为Python Web开发提供了一个强大、高效的开发环境。通过本文的介绍，我们可以看到：

1. 项目创建和配置：PyCharm提供了直观的界面来创建和配置Django项目，大大简化了项目初始化过程。
2. 代码开发：PyCharm的智能代码编辑、代码补全、错误检查等功能，使Django开发更加高效和准确。
3. 调试和测试：PyCharm提供了强大的调试工具和测试支持，帮助开发者快速定位和解决问题。
4. 数据库管理：PyCharm的数据库工具使数据库操作变得简单直观。
5. 版本控制：集成的版本控制系统使代码管理更加方便。
6. 部署优化：PyCharm提供了多种部署选项，包括远程服务器部署和Docker容器部署，简化了部署流程。

项目创建和配置：PyCharm提供了直观的界面来创建和配置Django项目，大大简化了项目初始化过程。

代码开发：PyCharm的智能代码编辑、代码补全、错误检查等功能，使Django开发更加高效和准确。

调试和测试：PyCharm提供了强大的调试工具和测试支持，帮助开发者快速定位和解决问题。

数据库管理：PyCharm的数据库工具使数据库操作变得简单直观。

版本控制：集成的版本控制系统使代码管理更加方便。

部署优化：PyCharm提供了多种部署选项，包括远程服务器部署和Docker容器部署，简化了部署流程。

通过这些功能，PyCharm和Django的强强联手，使开发者能够专注于业务逻辑，而不是繁琐的配置和部署工作，从而更轻松地构建高质量的Web应用。

无论是初学者还是经验丰富的开发者，都可以从PyCharm和Django的结合中受益，提高开发效率和代码质量。希望本文能够帮助读者更好地理解和使用PyCharm和Django，构建出更加优秀的Web应用。