Skip to content

Commit 4bec755

Browse files
jackfruedjackfrued
committedJun 29, 2020
更新了部分文档
1 parent 2747427 commit 4bec755

12 files changed

+361
-415
lines changed
 

‎Day41-55/45.报表和日志.md

+132
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,132 @@
1+
## 报表
2+
3+
### 导出Excel报表
4+
5+
报表就是用表格、图表等格式来动态显示数据，所以有人用这样的公式来描述报表：
6+
7+
```
8+
报表 = 多样的格式 + 动态的数据
9+
```
10+
11+
有很多的三方库支持在Python程序中写Excel文件，包括[xlwt](<https://xlwt.readthedocs.io/en/latest/>)、[xlwings](<https://docs.xlwings.org/en/latest/quickstart.html>)、[openpyxl](<https://openpyxl.readthedocs.io/en/latest/>)、[xlswriter](<https://xlsxwriter.readthedocs.io/>)、[pandas](<http://pandas.pydata.org/>)等，其中的xlwt虽然只支持写xls格式的Excel文件，但在性能方面的表现还是不错的。下面我们就以xlwt为例，来演示如何在Django项目中导出Excel报表，例如导出一个包含所有老师信息的Excel表格。
12+
13+
```Python
14+
def export_teachers_excel(request):
15+
# 创建工作簿
16+
wb = xlwt.Workbook()
17+
# 添加工作表
18+
sheet = wb.add_sheet('老师信息表')
19+
# 查询所有老师的信息
20+
queryset = Teacher.objects.all()
21+
# 向Excel表单中写入表头
22+
colnames = ('姓名', '介绍', '好评数', '差评数', '学科')
23+
for index, name in enumerate(colnames):
24+
sheet.write(0, index, name)
25+
# 向单元格中写入老师的数据
26+
props = ('name', 'detail', 'good_count', 'bad_count', 'subject')
27+
for row, teacher in enumerate(queryset):
28+
for col, prop in enumerate(props):
29+
value = getattr(teacher, prop, '')
30+
if isinstance(value, Subject):
31+
value = value.name
32+
sheet.write(row + 1, col, value)
33+
# 保存Excel
34+
buffer = BytesIO()
35+
wb.save(buffer)
36+
# 将二进制数据写入响应的消息体中并设置MIME类型
37+
resp = HttpResponse(buffer.getvalue(), content_type='application/vnd.ms-excel')
38+
# 中文文件名需要处理成百分号编码
39+
filename = quote('老师.xls')
40+
# 通过响应头告知浏览器下载该文件以及对应的文件名
41+
resp['content-disposition'] = f'attachment; filename*=utf-8''{filename}'
42+
return resp
43+
```
44+
45+
映射URL。
46+
47+
```Python
48+
urlpatterns = [
49+
# 此处省略上面的代码
50+
path('excel/', views.export_teachers_excel),
51+
# 此处省略下面的代码
52+
]
53+
```
54+
55+
### 生成前端统计图表
56+
57+
如果项目中需要生成前端统计图表，可以使用百度的[ECharts](<https://echarts.baidu.com/>)。具体的做法是后端通过提供数据接口返回统计图表所需的数据，前端使用ECharts来渲染出柱状图、折线图、饼图、散点图等图表。例如我们要生成一个统计所有老师好评数和差评数的报表，可以按照下面的方式来做。
58+
59+
```Python
60+
def get_teachers_data(request):
61+
queryset = Teacher.objects.all()
62+
names = [teacher.name for teacher in queryset]
63+
good_counts = [teacher.good_count for teacher in queryset]
64+
bad_counts = [teacher.bad_count for teacher in queryset]
65+
# 返回JSON格式的数据
66+
return JsonResponse({'names': names, 'good': good_counts, 'bad': bad_counts})
67+
```
68+
69+
映射URL。
70+
71+
```Python
72+
urlpatterns = [
73+
path('teachers_data/', views.export_teachers_excel),
74+
]
75+
```
76+
77+
使用ECharts生成柱状图。
78+
79+
```HTML
80+
<!DOCTYPE html>
81+
<html lang="en">
82+
<head>
83+
<meta charset="UTF-8">
84+
<title>老师评价统计</title>
85+
</head>
86+
<body>
87+
<div id="main" style="width: 600px; height: 400px"></div>
88+
<p>
89+
<a href="/">返回首页</a>
90+
</p>
91+
<script src="https://cdn.bootcss.com/echarts/4.2.1-rc1/echarts.min.js"></script>
92+
<script>
93+
var myChart = echarts.init(document.querySelector('#main'))
94+
fetch('/teachers_data/')
95+
.then(resp => resp.json())
96+
.then(json => {
97+
var option = {
98+
color: ['#f00', '#00f'],
99+
title: {
100+
text: '老师评价统计图'
101+
},
102+
tooltip: {},
103+
legend: {
104+
data:['好评', '差评']
105+
},
106+
xAxis: {
107+
data: json.names
108+
},
109+
yAxis: {},
110+
series: [
111+
{
112+
name: '好评',
113+
type: 'bar',
114+
data: json.good
115+
},
116+
{
117+
name: '差评',
118+
type: 'bar',
119+
data: json.bad
120+
}
121+
]
122+
}
123+
myChart.setOption(option)
124+
})
125+
</script>
126+
</body>
127+
</html>
128+
```
129+
130+
运行效果如下图所示。
131+
132+
![](./res/echarts_bar_graph.png)

‎Day41-55/46. 日志和调试工具栏.md

+217
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,217 @@
1+
## 日志和调试工具栏
2+
3+
### 配置日志
4+
5+
项目开发阶段，显示足够的调试信息以辅助开发人员调试代码还是非常必要的；项目上线以后，将系统运行时出现的警告、错误等信息记录下来以备相关人员了解系统运行状况并维护代码也是很有必要的。与此同时，采集日志数据也是为网站做数字化运营奠定一个基础，通过对系统运行日志的分析，我们可以监测网站的流量以及流量分布，同时还可以挖掘出用户的使用习惯和行为模式。
6+
7+
接下来，我们先看看如何通过Django的配置文件来配置日志。Django的日志配置基本可以参照官方文档再结合项目实际需求来进行，这些内容基本上可以从官方文档上复制下来，然后进行局部的调整即可，下面给出一些参考配置。
8+
9+
```Python
10+
LOGGING = {
11+
'version': 1,
12+
# 是否禁用已经存在的日志器
13+
'disable_existing_loggers': False,
14+
# 日志格式化器
15+
'formatters': {
16+
'simple': {
17+
'format': '%(asctime)s %(module)s.%(funcName)s: %(message)s',
18+
'datefmt': '%Y-%m-%d %H:%M:%S',
19+
},
20+
'verbose': {
21+
'format': '%(asctime)s %(levelname)s [%(process)d-%(threadName)s] '
22+
'%(module)s.%(funcName)s line %(lineno)d: %(message)s',
23+
'datefmt': '%Y-%m-%d %H:%M:%S',
24+
}
25+
},
26+
# 日志过滤器
27+
'filters': {
28+
# 只有在Django配置文件中DEBUG值为True时才起作用
29+
'require_debug_true': {
30+
'()': 'django.utils.log.RequireDebugTrue',
31+
},
32+
},
33+
# 日志处理器
34+
'handlers': {
35+
# 输出到控制台
36+
'console': {
37+
'class': 'logging.StreamHandler',
38+
'level': 'DEBUG',
39+
'filters': ['require_debug_true'],
40+
'formatter': 'simple',
41+
},
42+
# 输出到文件(每周切割一次)
43+
'file1': {
44+
'class': 'logging.handlers.TimedRotatingFileHandler',
45+
'filename': 'access.log',
46+
'when': 'W0',
47+
'backupCount': 12,
48+
'formatter': 'simple',
49+
'level': 'INFO',
50+
},
51+
# 输出到文件(每天切割一次)
52+
'file2': {
53+
'class': 'logging.handlers.TimedRotatingFileHandler',
54+
'filename': 'error.log',
55+
'when': 'D',
56+
'backupCount': 31,
57+
'formatter': 'verbose',
58+
'level': 'WARNING',
59+
},
60+
},
61+
# 日志器记录器
62+
'loggers': {
63+
'django': {
64+
# 需要使用的日志处理器
65+
'handlers': ['console', 'file1', 'file2'],
66+
# 是否向上传播日志信息
67+
'propagate': True,
68+
# 日志级别(不一定是最终的日志级别)
69+
'level': 'DEBUG',
70+
},
71+
}
72+
}
73+
```
74+
75+
大家可能已经注意到了，上面日志配置中的`formatters`是**日志格式化器**，它代表了如何格式化输出日志，其中格式占位符分别表示：
76+
77+
1. `%(name)s` - 记录器的名称
78+
2. `%(levelno)s` - 数字形式的日志记录级别
79+
3. `%(levelname)s` - 日志记录级别的文本名称
80+
4. `%(filename)s` - 执行日志记录调用的源文件的文件名称
81+
5. `%(pathname)s` - 执行日志记录调用的源文件的路径名称
82+
6. `%(funcName)s` - 执行日志记录调用的函数名称
83+
7. `%(module)s` - 执行日志记录调用的模块名称
84+
8. `%(lineno)s` - 执行日志记录调用的行号
85+
9. `%(created)s` - 执行日志记录的时间
86+
10. `%(asctime)s` - 日期和时间
87+
11. `%(msecs)s` - 毫秒部分
88+
12. `%(thread)d` - 线程ID（整数）
89+
13. `%(threadName)s` - 线程名称
90+
14. `%(process)d` - 进程ID （整数）
91+
92+
日志配置中的handlers用来指定**日志处理器**，简单的说就是指定将日志输出到控制台还是文件又或者是网络上的服务器，可用的处理器包括：
93+
94+
1. `logging.StreamHandler(stream=None)` - 可以向类似与`sys.stdout`或者`sys.stderr`的任何文件对象输出信息
95+
2. `logging.FileHandler(filename, mode='a', encoding=None, delay=False)` - 将日志消息写入文件
96+
3. `logging.handlers.DatagramHandler(host, port)` - 使用UDP协议，将日志信息发送到指定主机和端口的网络主机上
97+
4. `logging.handlers.HTTPHandler(host, url)` - 使用HTTP的GET或POST方法将日志消息上传到一台HTTP 服务器
98+
5. `logging.handlers.RotatingFileHandler(filename, mode='a', maxBytes=0, backupCount=0, encoding=None, delay=False)` - 将日志消息写入文件，如果文件的大小超出`maxBytes`指定的值，那么将重新生成一个文件来记录日志
99+
6. `logging.handlers.SocketHandler(host, port)` - 使用TCP协议，将日志信息发送到指定主机和端口的网络主机上
100+
7. `logging.handlers.SMTPHandler(mailhost, fromaddr, toaddrs, subject, credentials=None, secure=None, timeout=1.0)` - 将日志输出到指定的邮件地址
101+
8. `logging.MemoryHandler(capacity, flushLevel=ERROR, target=None, flushOnClose=True)` - 将日志输出到内存指定的缓冲区中
102+
103+
上面每个日志处理器都指定了一个名为`level`的属性，它代表了日志的级别，不同的日志级别反映出日志中记录信息的严重性。Python中定义了六个级别的日志，按照从低到高的顺序依次是：NOTSET、DEBUG、INFO、WARNING、ERROR、CRITICAL。
104+
105+
最后配置的**日志记录器**是用来真正输出日志的，Django框架提供了如下所示的内置记录器：
106+
107+
1. `django` - 在Django层次结构中的所有消息记录器
108+
2. `django.request` - 与请求处理相关的日志消息。5xx响应被视为错误消息；4xx响应被视为为警告消息
109+
3. `django.server` - 与通过runserver调用的服务器所接收的请求相关的日志消息。5xx响应被视为错误消息；4xx响应被记录为警告消息；其他一切都被记录为INFO
110+
4. `django.template` - 与模板渲染相关的日志消息
111+
5. `django.db.backends` - 有与数据库交互产生的日志消息，如果希望显示ORM框架执行的SQL语句，就可以使用该日志记录器。
112+
113+
日志记录器中配置的日志级别有可能不是最终的日志级别，因为还要参考日志处理器中配置的日志级别，取二者中级别较高者作为最终的日志级别。
114+
115+
### 配置Django-Debug-Toolbar
116+
117+
如果想调试你的Django项目，你一定不能不过名为Django-Debug-Toolbar的神器，它是项目开发阶段辅助调试和优化的必备工具，只要配置了它，就可以很方便的查看到如下表所示的项目运行信息，这些信息对调试项目和优化Web应用性能都是至关重要的。
118+
119+
| 项目 | 说明 |
120+
| ----------- | --------------------------------- |
121+
| Versions | Django的版本 |
122+
| Time | 显示视图耗费的时间 |
123+
| Settings | 配置文件中设置的值 |
124+
| Headers | HTTP请求头和响应头的信息 |
125+
| Request | 和请求相关的各种变量及其信息 |
126+
| StaticFiles | 静态文件加载情况 |
127+
| Templates | 模板的相关信息 |
128+
| Cache | 缓存的使用情况 |
129+
| Signals | Django内置的信号信息 |
130+
| Logging | 被记录的日志信息 |
131+
| SQL | 向数据库发送的SQL语句及其执行时间 |
132+
133+
1. 安装Django-Debug-Toolbar。
134+
135+
```Shell
136+
pip install django-debug-toolbar
137+
```
138+
139+
2. 配置 - 修改settings.py。
140+
141+
```Python
142+
INSTALLED_APPS = [
143+
'debug_toolbar',
144+
]
145+
146+
MIDDLEWARE = [
147+
'debug_toolbar.middleware.DebugToolbarMiddleware',
148+
]
149+
150+
DEBUG_TOOLBAR_CONFIG = {
151+
# 引入jQuery库
152+
'JQUERY_URL': 'https://cdn.bootcss.com/jquery/3.3.1/jquery.min.js',
153+
# 工具栏是否折叠
154+
'SHOW_COLLAPSED': True,
155+
# 是否显示工具栏
156+
'SHOW_TOOLBAR_CALLBACK': lambda x: True,
157+
}
158+
```
159+
160+
3. 配置 - 修改urls.py。
161+
162+
```Python
163+
if settings.DEBUG:
164+
165+
import debug_toolbar
166+
167+
urlpatterns.insert(0, path('__debug__/', include(debug_toolbar.urls)))
168+
```
169+
170+
4. 在配置好Django-Debug-Toolbar之后，页面右侧会看到一个调试工具栏，如下图所示，上面包括了如前所述的各种调试信息，包括执行时间、项目设置、请求头、SQL、静态资源、模板、缓存、信号等，查看起来非常的方便。
171+
172+
![](res/django-debug-toolbar.png)
173+
174+
#### 优化ORM代码
175+
176+
在配置了日志或Django-Debug-Toolbar之后，我们可以查看一下之前将老师数据导出成Excel报表的视图函数执行情况，这里我们关注的是ORM框架生成的SQL查询到底是什么样子的，相信这里的结果会让你感到有一些意外。执行`Teacher.objects.all()`之后我们可以注意到，在控制台看到的或者通过Django-Debug-Toolbar输出的SQL是下面这样的：
177+
178+
```SQL
179+
SELECT `tb_teacher`.`no`, `tb_teacher`.`name`, `tb_teacher`.`detail`, `tb_teacher`.`photo`, `tb_teacher`.`good_count`, `tb_teacher`.`bad_count`, `tb_teacher`.`sno` FROM `tb_teacher`; args=()
180+
SELECT `tb_subject`.`no`, `tb_subject`.`name`, `tb_subject`.`intro`, `tb_subject`.`create_date`, `tb_subject`.`is_hot` FROM `tb_subject` WHERE `tb_subject`.`no` = 101; args=(101,)
181+
SELECT `tb_subject`.`no`, `tb_subject`.`name`, `tb_subject`.`intro`, `tb_subject`.`create_date`, `tb_subject`.`is_hot` FROM `tb_subject` WHERE `tb_subject`.`no` = 101; args=(101,)
182+
SELECT `tb_subject`.`no`, `tb_subject`.`name`, `tb_subject`.`intro`, `tb_subject`.`create_date`, `tb_subject`.`is_hot` FROM `tb_subject` WHERE `tb_subject`.`no` = 101; args=(101,)
183+
SELECT `tb_subject`.`no`, `tb_subject`.`name`, `tb_subject`.`intro`, `tb_subject`.`create_date`, `tb_subject`.`is_hot` FROM `tb_subject` WHERE `tb_subject`.`no` = 101; args=(101,)
184+
SELECT `tb_subject`.`no`, `tb_subject`.`name`, `tb_subject`.`intro`, `tb_subject`.`create_date`, `tb_subject`.`is_hot` FROM `tb_subject` WHERE `tb_subject`.`no` = 103; args=(103,)
185+
SELECT `tb_subject`.`no`, `tb_subject`.`name`, `tb_subject`.`intro`, `tb_subject`.`create_date`, `tb_subject`.`is_hot` FROM `tb_subject` WHERE `tb_subject`.`no` = 103; args=(103,)
186+
```
187+
188+
这里的问题通常被称为“1+N查询”（或“N+1查询”），原本获取老师的数据只需要一条SQL，但是由于老师关联了学科，当我们查询到N条老师的数据时，Django的ORM框架又向数据库发出了N条SQL去查询老师所属学科的信息。每条SQL执行都会有较大的开销而且会给数据库服务器带来压力，如果能够在一条SQL中完成老师和学科的查询肯定是更好的做法，这一点也很容易做到，相信大家已经想到怎么做了。是的，我们可以使用连接查询，但是在使用Django的ORM框架时如何做到这一点呢？对于多对一关联（如投票应用中的老师和学科），我们可以使用`QuerySet`的用`select_related()`方法来加载关联对象；而对于多对多关联（如电商网站中的订单和商品），我们可以使用`prefetch_related()`方法来加载关联对象。
189+
190+
在导出老师Excel报表的视图函数中，我们可以按照下面的方式优化代码。
191+
192+
```Python
193+
queryset = Teacher.objects.all().select_related('subject')
194+
```
195+
196+
事实上，用ECharts生成前端报表的视图函数中，查询老师好评和差评数据的操作也能够优化，因为在这个例子中，我们只需要获取老师的姓名、好评数和差评数这三项数据，但是在默认的情况生成的SQL会查询老师表的所有字段。可以用`QuerySet`的`only()`方法来指定需要查询的属性，也可以用`QuerySet`的`defer()`方法来指定暂时不需要查询的属性，这样生成的SQL会通过投影操作来指定需要查询的列，从而改善查询性能，代码如下所示：
197+
198+
```Python
199+
queryset = Teacher.objects.all().only('name', 'good_count', 'bad_count')
200+
```
201+
202+
当然，如果要统计出每个学科的老师好评和差评的平均数，利用Django的ORM框架也能够做到，代码如下所示：
203+
204+
```Python
205+
queryset = Teacher.objects.values('subject').annotate(
206+
good=Avg('good_count'), bad=Avg('bad_count'))
207+
```
208+
209+
这里获得的`QuerySet`中的元素是字典对象，每个字典中有三组键值对，分别是代表学科编号的`subject`、代表好评数的`good`和代表差评数的`bad`。如果想要获得学科的名称而不是编号，可以按照如下所示的方式调整代码：
210+
211+
```Python
212+
queryset = Teacher.objects.values('subject__name').annotate(
213+
good=Avg('good_count'), bad=Avg('bad_count'))
214+
```
215+
216+
可见，Django的ORM框架允许我们用面向对象的方式完成关系数据库中的分组和聚合查询。
217+

‎Day41-55/46.报表和日志.md

-351
This file was deleted.

‎Day41-55/47.中间件的应用.md

+1-54
Original file line numberDiff line numberDiff line change
@@ -1,55 +1,6 @@
11
## 中间件的应用
22

3-
### 实现登录验证
4-
5-
我们继续来完善投票应用。在上一个章节中，我们在用户登录成功后通过session保留了用户信息，接下来我们可以应用做一些调整，要求在为老师投票时必须要先登录，登录过的用户可以投票，否则就将用户引导到登录页面，为此我们可以这样修改视图函数。
6-
7-
```Python
8-
def praise_or_criticize(request: HttpRequest):
9-
"""投票"""
10-
if 'username' in request.session:
11-
try:
12-
tno = int(request.GET.get('tno', '0'))
13-
teacher = Teacher.objects.get(no=tno)
14-
if request.path.startswith('/praise'):
15-
teacher.good_count += 1
16-
else:
17-
teacher.bad_count += 1
18-
teacher.save()
19-
data = {'code': 200, 'message': '操作成功'}
20-
except (ValueError, Teacher.DoesNotExist):
21-
data = {'code': 404, 'message': '操作失败'}
22-
else:
23-
data = {'code': 401, 'message': '请先登录'}
24-
return JsonResponse(data)
25-
```
26-
27-
前端页面在收到`{'code': 401, 'message': '请先登录'}`后，可以将用户引导到登录页面，修改后的teacher.html页面的JavaScript代码部门如下所示。
28-
29-
```HTML
30-
<script>
31-
$(() => {
32-
$('.comment > a').on('click', (evt) => {
33-
evt.preventDefault()
34-
let a = $(evt.target)
35-
$.getJSON(a.attr('href'), (json) => {
36-
if (json.code == 200) {
37-
let span = a.next()
38-
span.text(parseInt(span.text()) + 1)
39-
} else if (json.code == 401) {
40-
location.href = '/login/?backurl=' + location.href
41-
} else {
42-
alert(json.message)
43-
}
44-
})
45-
})
46-
})
47-
</script>
48-
```
49-
50-
> 注意：为了在登录成功之后能够回到刚才投票的页面，我们在跳转登录时设置了一个`backurl`参数，把当前浏览器中的URL作为返回的页面地址。
51-
52-
这样我们已经实现了用户必须登录才能投票的限制，但是一个新的问题来了。如果我们的应用中有很多功能都需要用户先登录才能执行，例如将前面导出Excel报表和查看统计图表的功能都加以登录限制，那么我们是不是需要在每个视图函数中添加代码来检查session中是否包含了登录用户的信息呢？答案是否定的，如果这样做了，我们的视图函数中必然会充斥着大量的重复代码。编程大师*Martin Fowler*曾经说过：**代码有很多种坏味道，重复是最坏的一种**。在Django项目中，我们可以把验证用户是否登录这样的重复性代码放到中间件中。
3+
之前我们已经实现了用户必须登录才能投票的限制，但是一个新的问题来了。如果我们的应用中有很多功能都需要用户先登录才能执行，例如将前面导出Excel报表和查看统计图表的功能都做了必须登录才能访问的限制，那么我们是不是需要在每个视图函数中添加代码来检查session中是否包含`userid`的代码呢？答案是否定的，如果这样做了，我们的视图函数中必然会充斥着大量的重复代码。编程大师*Martin Fowler*曾经说过：**代码有很多种坏味道，重复是最坏的一种**。在Python程序中，我们可以通过装饰器来为函数提供额外的能力；在Django项目中，我们可以把类似于验证用户是否登录这样的重复性代码放到**中间件**中。
534

545
### Django中间件概述
556

@@ -144,7 +95,3 @@ MIDDLEWARE = [
14495
注意上面这个中间件列表中元素的顺序，当收到来自用户的请求时，中间件按照从上到下的顺序依次执行，这行完这些中间件以后，请求才会最终到达视图函数。当然，在这个过程中，用户的请求可以被拦截，就像上面我们自定义的中间件那样，如果用户在没有登录的情况下访问了受保护的资源，中间件会将请求直接重定向到登录页，后面的中间件和视图函数将不再执行。在响应用户请求的过程中，上面的中间件会按照从下到上的顺序依次执行，这样的话我们还可以对响应做进一步的处理。
14596

14697
中间件执行的顺序是非常重要的，对于有依赖关系的中间件必须保证被依赖的中间件要置于依赖它的中间件的前面，就好比我们刚才自定义的中间件要放到`SessionMiddleware`的后面，因为我们要依赖这个中间件为请求绑定的`session`对象才能判定用户是否登录。
147-
148-
### 小结
149-
150-
至此，除了对用户投票数量加以限制的功能外，这个投票应用就算基本完成了，整个项目的完整代码请参考<https://github.com/jackfrued/django1902>，其中用户注册时使用的手机验证码功能请大家使用自己注册的短信平台替代它。如果需要投票应用完整的视频讲解，可以在首页扫码打赏后留言联系作者获取视频下载地址，谢谢大家的理解和支持。

‎Day41-55/48.前后端分离开发入门.md

+1-1
Original file line numberDiff line numberDiff line change
@@ -161,4 +161,4 @@ class SubjectMapper(ModelMapper):
161161

162162
前后端分离的开发需要将前端页面作为静态资源进行部署，项目实际上线的时候，我们会对整个Web应用进行动静分离，静态资源通过Nginx或Apache服务器进行部署，生成动态内容的Python程序部署在uWSGI或者Gunicorn服务器上，对动态内容的请求由Nginx或Apache路由到uWSGI或Gunicorn服务器上。
163163

164-
在开发阶段，我们通常会使用Django自带的测试服务器，如果要尝试前后端分离，可以先将静态页面放在之前创建的放静态资源的目录下，具体的做法可以参考[项目完整代码](<https://github.com/jackfrued/django1902_vue/>)。
164+
在开发阶段，我们通常会使用Django自带的测试服务器，如果要尝试前后端分离，可以先将静态页面放在之前创建的放静态资源的目录下，具体的做法可以参考[项目完整代码]()。

‎Day41-55/52.文件上传.md

+4
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,4 @@
1+
## 文件上传
2+
3+
4+

‎Day41-55/52.文件上传和富文本编辑.md

-4
This file was deleted.

‎Day41-55/53.短信和邮件.md

-4
This file was deleted.

‎Day41-55/55.单元测试和项目上线.md ‎Day41-55/54.单元测试.md

File renamed without changes.

‎Day41-55/55.项目上线.md

+3
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,3 @@
1+
## 项目上线
2+
3+

‎README.md

+3-1
Original file line numberDiff line numberDiff line change
@@ -302,7 +302,9 @@
302302
- 在项目中使用celery实现任务异步化
303303
- 在项目中使用celery实现定时任务
304304

305-
#### Day55 - [单元测试和项目上线](./Day41-55/55.单元测试和项目上线.md)
305+
#### Day54 - [单元测试](./Day41-55/54.单元测试.md)
306+
307+
#### Day55 - [项目上线](./Day41-55/55.项目上线.md)
306308

307309
- Python中的单元测试
308310
- Django框架对单元测试的支持

0 commit comments

Comments
 (0)
Please sign in to comment.