简介

本篇文章介绍如何使用3D打印件、ESP32、温度传感器和执行器搭建微型堆肥反应器 CP500。系统通过水浴维持反应温度，并控制循环泵和曝气泵。本文重点记录结构、接线和调试流程，具体控制参数需要根据实际容积、加热功率和散热条件调整。

硬件清单

继电器、MOSFET 和电源的额定电压、电流必须覆盖实际负载，并保留余量。加热、水泵等大功率负载不能由 ESP32 引脚直接供电。

准备3D模型

3D模型包括：
水浴结构、物料内筒、筛网、物料盖、水箱、水箱盖，底部主板、底部支撑柱4个、主板盖
模型地址通过网盘分享的文件：3D打印模型
链接: 提取码: 8888

3D打印

采用拓竹3D打印机打印3D部件，其中水箱和水箱盖采用ASA材料打印(也可以采用耐热性能更高的其他耗材)，其他部件采用ABS打印

具体打印方法如下：
下载拓竹Bambu Studio软件，连接打印机，打开下载好的3D模型，设置均已提前设置好，直接切盘打印即可

打印前建议根据设备用途再检查以下项目：

• 水箱和水浴部件的壁厚、层间结合与耐温性能；
• 过线孔、传感器孔和水管接口是否需要预留密封余量；
• 与水接触的打印件先单独做 24 小时静置漏水测试；
• 打印完成后清理支撑和毛刺，避免水管被锐边割伤。

装配顺序

1. 先安装底部主板、支撑柱和电源模块，低压控制线与负载电源线分开走线；
2. 安装水箱、循环水泵和水管，在不通电的情况下完成漏水测试；
3. 放入水浴筒和物料内筒，确保内筒可以正常取出；
4. 固定 DS18B20 探头，避免探头紧贴加热棒或容器壁造成局部温度偏差；
5. 最后连接继电器、MOSFET 和 ESP32，并为接头做好绝缘与应力释放。

接线

所有3D模型打印完毕后，需要结合准备的设备（esp32单片机、电源板、水泵、曝气泵、加热棒、温度传感器、2路继电器、场效应管）进行接线，接线方法如下：
Esp32接2路继电器（分别控制加热和水箱）、接MOS（场效应管，控制曝气）
Esp32接温度传感器Ds18b20（分别为3个监测水浴温度，1个物料温度、1个水箱温度，物料和水箱温度共线）
电源板接esp32（5V）接加热棒、水泵（12V），接曝气泵（3V）

详细连线

esp32 pin4接物料和水箱温度传感器信号线，pin5接接水浴温度传感器信号线，温度传感器采用esp32 3V3和GND供电
pin25接继电器加热棒控制信号线，pin26接继电器水泵控制信号线，pin27接气泵MOS控制信号线，2路继电器和MOS采用esp32 5V和GND供电

整理后的引脚表如下：

DS18B20 数据线通常需要接上拉电阻，常用值为 4.7 kΩ，连接在数据线和 3V3 之间。多个探头共用一条 OneWire 总线时，应尽量缩短总线长度并保证接头可靠。

上电前务必确认继电器模块是高电平触发还是低电平触发。程序中的开关逻辑与模块触发方式相反时，设备可能在 ESP32 启动阶段意外开启。

程序

代码地址：esp32-cp500。程序通过 initSensors(4, 5, 25, 26, 27) 初始化上述引脚，主要完成以下工作：

• 读取物料、水浴和水箱温度，并过滤明显异常值；
• 根据温差或设定值控制加热棒和循环水泵；
• 保证加热和循环泵按照控制逻辑互斥，避免错误组合；
• 定时或远程控制曝气；
• 通过 MQTT 上报测量结果和设备状态。

首次烧录前需要根据仓库说明填写 Wi-Fi、MQTT、温度上限、测量周期和曝气周期等配置。建议先断开加热棒与水泵，只观察串口输出和 GPIO 状态，确认逻辑无误后再逐个接入负载。

上电检查

1. 只给 ESP32 供电：检查所有 DS18B20 是否都能返回合理温度；
2. 测试执行器空载输出：观察继电器和 MOSFET 指示灯，确认 GPIO 与实际通道对应；
3. 单独测试水泵：水路中加水并排尽空气，确认方向和流量正常；
4. 低温测试加热：设置较低目标温度，验证加热能在达到阈值后停止；
5. 测试异常保护：拔掉一个温度探头或模拟超温，确认程序不会继续加热；
6. 连续运行测试：正式加入物料前至少运行一个完整控制周期，检查漏水、接头温升和网络重连。

安全说明

• 水、电和加热部件必须可靠隔离，所有接头做好防水和绝缘；
• 加热棒必须在允许的液位和散热条件下工作，避免干烧；
• ESP32 与继电器只负责控制，负载电流应走独立电源回路；
• 感性负载应使用合适的驱动和续流保护；
• 软件温控不能代替独立的温度保险、过流保护和漏电保护。

参考资料

• 项目完整代码：esp32-cp500
• Arduino ESP32 官方文档

硬件准备

硬件列表：

• ESP32 开发板；
• 移远 EC800K 通信模块或带稳压、SIM 卡座和天线座的开发板；
• 可提供足够瞬时电流的独立电源；
• 4G 天线、可用的 SIM 卡和串口连接线；
• 如果两块板的 UART 电平不一致，还需要双向电平转换模块。

EC800K 核心模块与不同厂商开发板的供电电压可能不同，接线前必须查看手中开发板的原理图。蜂窝模块发射时会产生较大的瞬时电流，不建议直接从 ESP32 的 3V3 引脚取电，否则很容易出现反复重启、掉网或 MQTT 莫名断开的情况。

本文配套代码使用 ESP32 的 UART1，默认引脚如下：

串口参数为 115200, 8N1。如果你的 EC800K 固件使用其他波特率，需要同步修改代码中的 ec800kSerial.begin()。

PlatformIO 项目

完整代码位于 esp32-ec800k-mqtt。项目的 platformio.ini 可以保持为：

1
2
3
4
5

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

核心代码的作用是建立一个串口透传终端：电脑串口监视器输入 AT 指令，ESP32 转发给 EC800K；模块返回的内容再打印到电脑。这样可以先把网络注册和 MQTT 指令逐条调通，再考虑封装成自动状态机。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <Arduino.h>
#include <HardwareSerial.h>

HardwareSerial ec800kSerial(1);

void setup() {
  Serial.begin(115200);
  ec800kSerial.begin(115200, SERIAL_8N1, 16, 17);
}

void loop() {
  while (Serial.available()) {
    ec800kSerial.write(Serial.read());
  }
  while (ec800kSerial.available()) {
    Serial.write(ec800kSerial.read());
  }
}

仓库中的版本使用 FreeRTOS 任务异步读取串口，并增加了缓冲区和输出过滤，更适合继续扩展。

联网前检查

插入 SIM 卡并连接天线后，先在串口监视器依次检查：

1
2
3
4
5

AT
AT+CPIN?
AT+CSQ
AT+CEREG?
AT+CGATT?

正常情况下，AT 返回 OK，CPIN 显示 SIM 卡已就绪，CEREG 表明已经注册到分组网络，CGATT 返回已附着。CSQ 用于查看信号质量；如果长时间无法注册，应先检查天线、SIM 卡、供电和当地运营商网络，而不是直接排查 MQTT。

MQTT AT 指令流程

EC800K 不同固件的 MQTT 指令参数可能略有区别，应以模块对应版本的 AT 手册为准。常见的调试顺序如下，其中地址、端口、客户端 ID 和主题都需要替换成自己的值：

1
2
3

AT+QMTOPEN=0,"broker.example.com",1883
AT+QMTCONN=0,"esp32-ec800k-client"
AT+QMTSUB=0,1,"device/test/down",0

发布消息通常使用固件支持的 QMTPUB 或 QMTPUBEX 指令，例如：

1
2

AT+QMTPUBEX=0,0,0,0,"device/test/up",18
{"temperature":25}

每一步都要等待模块的异步结果再继续，尤其是 QMTOPEN。仅收到命令行的 OK 不代表 MQTT 已经连接成功，还需要检查随后出现的 +QMTOPEN、+QMTCONN、+QMTSUB 或 +QMTPUBEX 结果码。

断开连接时可以按固件手册依次关闭 MQTT 客户端和网络连接。程序化控制时不要简单地连续发送一串 AT 指令，建议将流程拆分为“等待网络注册 → 打开连接 → 登录 → 订阅/发布 → 断线重连”几个状态，并为每个状态设置超时。

常见问题

串口完全没有响应

先交换 RX/TX，确认共地，再检查波特率和模块是否已经正常开机。有些开发板还需要拉低 PWRKEY 一段时间才能启动。

模块不断重启或一联网就掉线

优先检查供电能力和电源线压降。蜂窝模块的瞬时电流明显高于空闲状态，万用表看到的平均电压正常并不能排除电源问题。

MQTT 打不开

先确认 CEREG 和 CGATT 正常，再检查 APN、Broker 地址、端口以及服务器是否允许匿名连接。如果使用 TLS，还需要额外配置证书和 SSL 上下文。

收到 OK 但没有消息

OK 只表示 AT 命令格式被接受。继续查看 +QMT... 异步返回码，并确认发布和订阅使用的是同一个 Broker、主题及 QoS 设置。

参考资料

• 项目完整代码：esp32-ec800k-mqtt
• 移远通信下载中心
• PlatformIO：Espressif ESP32 Dev Module

简介

Arduino是一个能够用来感应和控制现实物理世界的一套工具。 它由一个基于单片机并且开放源码的硬件平台，和一套为Arduino板编写程序的开发环境组成。
ESP32是一种由Espressif乐鑫信息科技推出的WiFi芯片，专为移动设备、可穿戴电子产品和物联网应用而设计。它具有低功耗性能、双核32位MCU、2.4GHz双模Wi-Fi和蓝牙芯片等特点，适用于物联网和嵌入式系统开发.

为什么要使用Arduino？

有很多的单片机和单片机平台都适合用做交互式系统的设计。例如：Parallax Basic Stamp， Netmedia’s BX-24，Phidgets，MIT’s Handyboard 和其它等等提供类似功能的。 所有这些工具，你都不需要去关心单片机编程繁琐的细节，提供给你的是一套容易使用的工具包。 Arduino同样也简化了同单片机工作的流程，但同其它系统相比Arduino在很多地方更具有优越性， 特别适合老师，学生和一些业余爱好者们使用：

• 便宜 － 和其它平台相比，Arduino板算是相当便宜了。最便宜的Arduino版本可以自己动手制作，即使是组装好的成品，其价格也不会超过200元。
• 跨平台 － Arduino软件可以运行在Windows，Macintosh OSX，和Linux操作系统。大部分其它的单片机系统都只能运行在Windows上。
• 简易的编程环境 － 初学者很容易就能学会使用Arduino编程环境，同时它又能为高级用户提供足够多的高级应用。对于老师们来说，一般都能很方便的使用Processing 编程环境，所以如果学生学习过使用Processing 编程环境的话，那他们在使用Arduino开发环境的时候就会觉得很相似很熟悉。
• 软件开源并可扩展 － Arduino软件是开源的，对于有经验的程序员可以对其进行扩展。Arduino编程语言可以通过C++库进行扩展，如果有人想去了解技术上的细节，可以跳过Arduino语言而直接使用AVR C 编程语言（因为Arduino语言实际上是基于AVR C的）。类似的，如果你需要的话，你也可以直接往你的Arduino程序中添加AVR-C 代码。
• 硬件开源并可扩展 － Arduino板基于 Atmel 的ATMEGA8 和ATMEGA168/328 单片机。Arduino基于Creative Commons 许可协议，所以有经验的电路设计师能够根据需求设计自己的模块，可以对其扩展或改进。甚至是对于一些相对没有什么经验的用户，也可以通过制作试验板来理解Arduino是怎么工作的，省钱又省事。
• Arduino基于AVR平台，对AVR库进行了二次编译封装，把端口都打包好了，寄存器啦、地址指针之类的基本不用管。大大降低了软件开发难度，适宜非专业爱好者使用。优点和缺点并存，因为是二次编译封装，代码不如直接使用AVR代码编写精练，代码执行效率与代码体积都弱于AVR直接编译。

为什么要使用esp32

1. 功能强大

自带wifi+蓝牙是最大亮点！一起来看看ESP32的规格，就知道它强在哪里了。

• 内置WiFi和蓝牙，就不需要额外的以太网模块或wifi模块了，集成度高；
• 双核 CPU，可以主频为 80、160 或 240MHz。对于一个体积小巧的芯片中是相当多的计算了；
• 高级外设接口：I2C, SPI, CAN等，可以实现很多应用，不仅仅是个Wi-Fi MCU；
• 大量内存：ESP32包括 512KB 的片上 SRAM 存储器，还支持外部存储器，具体取决于主板，可能高达 4 到 8MB。这意味着ESP32 适用于一些较重的任务，例如连接摄像头、识别语音、从互联网流式传输数据等。

2. 价格亲民

• ESP32性价比非常高, 不仅功能强大，而且价格便宜。

3. IoT上近乎无敌

stm32是通用芯片，应用更全面；而ESP 32是物联网专用芯片，其算力性能，启动速度，稳定性，耐久度，可操作io数量及类型，啥都够，实在是太好用了。
首先，ESP32的片上资源和引脚接口特别丰富，打造出各种物联网场景智能设备绰绰有余了。现在物联网产品协议使用的最多的还是Wi-Fi，这两年BLE和BLE Mesh也发展的很快，Zigbee反而日渐势微，而ESP32同时支持Wi-Fi和蓝牙，加上其超高的性价比，前景不可限量。
其次，在嵌入式开发者中，ESP系列芯片深入人心，在国内某宝/B站以及国外youtube等上面都能找到大量有意思的开发者作品。ESP8266资源太少，而且只支持Wi-Fi，加上现在ESP32的价格也已经非常便宜了，如果想打造一个智能设备，首选ESP32完全OK。
再次，现在已经是物联网的时代了，开发出的智能设备也不能只停留在开发台上，希望能远程控制，访问。但是想要同时做好智能设备开发、连接云端服务、手机设备程序等全链路开发难度还是不小的。而ESP32有云端一体的全链路开发框架，开发远程硬件应用就很方便，比如做个家里燃气/火焰/甲醛检测设备，发现危险就推送消息到手机。

使用arduino自带IDE

可以在 Arduino 官网 下载安装 Arduino IDE。安装后打开设置，在“附加开发板管理器网址”中加入 ESP32 稳定版索引：

1

https://espressif.github.io/arduino-esp32/package_esp32_index.json

然后打开开发板管理器，搜索并安装 esp32，再从“工具 → 开发板”选择自己的型号。国内网络环境也可以使用 Espressif 官方文档中提供的镜像索引。

上传前需要确认两个选项：

• 端口选择了 ESP32 实际对应的串口；
• 开发板型号、Flash 大小和分区方案与手中硬件一致。

下面是一个最小串口示例，上传后打开 115200 波特率的串口监视器即可验证开发环境：

1
2
3
4
5
6
7
8
9
10
11
12

#include <Arduino.h>

void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println("ESP32 Arduino is ready");
}

void loop() {
  Serial.printf("millis: %lu\n", millis());
  delay(1000);
}

在VScode上使用PlatformIO IDE用Arduino开发Esp32

强烈推荐这个方式，使用起来非常方便。
在VScode上安装PlatformIO拓展
使用PlatformIO创建新的project，Board选择Espressif esp32 Dev Module，然后选择Arduino框架（建议使用自己的目录而不是默认目录）。

这时候就可以在VScode上编写代码，编译，上传了。常用的 platformio.ini 如下：

1
2
3
4
5

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200

PlatformIO 项目的主要目录包括：

1
2
3
4
5

项目目录/
├─ include/        # 头文件
├─ lib/            # 项目私有库
├─ src/main.cpp    # 程序入口
└─ platformio.ini  # 开发板、框架和依赖配置

需要第三方库时，可以在 PlatformIO 的 Library 页面安装，也可以写入 lib_deps，这样换一台电脑后仍能自动还原依赖：

1
2

lib_deps =
  bblanchon/ArduinoJson

常见问题

找不到串口

先检查 USB 线是否支持数据传输，再检查 CP210x、CH340 等 USB 转串口驱动。Windows 下也可以在设备管理器中确认端口号。

一直停在 Connecting...

部分开发板无法自动进入下载模式。可以在出现 Connecting... 时按住 BOOT，开始写入后松开；必要时按一下 EN/RESET 再重试。

程序上传成功但没有串口输出

确认 Serial.begin() 与串口监视器的波特率一致，并检查程序是否在初始化阶段阻塞或反复重启。ESP32 启动日志通常使用 115200 波特率。

引脚输出异常

不同 ESP32、ESP32-S2、ESP32-C3 和 ESP32-S3 开发板的可用 GPIO 不完全相同。使用启动配置脚、仅输入引脚或板载 Flash 占用引脚前，应先查看对应开发板的引脚图。

下一步

完成最小程序后，可以依次练习 GPIO、PWM、ADC、I2C、SPI、UART、Wi-Fi 和蓝牙。建议每增加一个模块先写独立测试程序，确认硬件和库工作正常，再合并到完整项目中，排错会简单很多。

参考资料

[1]ESP32使用Arduino环境，安装、编译、下载、安装库_arduino esp32-CSDN博客
[2]使用PlatformIO IDE在VScode上开发Arduino Esp32_platformio 删除库-CSDN博客
[3]Arduino ESP32：Installing
[4]PlatformIO：Espressif ESP32 Dev Module

Docker是什么

Docker 是一个用于开发、交付和运行应用程序的容器平台。它可以把程序、运行时和依赖打包成镜像，再从镜像启动相对隔离的容器，从而减少“在我电脑上明明可以运行”的环境差异。

容器不是简化版虚拟机。虚拟机通常包含完整操作系统和独立内核，而容器更接近一个被隔离的进程：它有自己的文件系统、网络和进程空间，但通常与其他容器共享宿主机内核。因此容器启动更快、占用资源更少，不过隔离边界和虚拟机也不完全相同。

Docker 主要解决以下问题：

• 固定应用及依赖版本，让开发、测试和生产环境尽量一致；
• 快速创建和销毁隔离环境；
• 使用镜像仓库分发应用；
• 通过 Docker Compose 管理由多个容器组成的服务。

Docker的架构

Docker 使用客户端—服务端架构：

• Docker Client：也就是平时使用的 docker 命令；
• Docker Daemon：后台的 dockerd，负责构建镜像、运行容器以及管理网络和存储；
• Registry：保存镜像的仓库，例如 Docker Hub；
• Docker Compose：使用 YAML 文件描述和管理一组相关容器。

执行 docker run nginx 时，客户端会向 Daemon 发出请求。如果本地没有 nginx 镜像，Daemon 先从镜像仓库拉取它，再创建并启动容器。

基本概念

镜像与容器

镜像（Image）是创建容器的只读模板，容器（Container）是镜像的运行实例。同一个镜像可以启动多个互不影响的容器。

可以将镜像理解为程序安装包加运行环境，但容器运行时会额外增加一个可写层。删除容器时，这个可写层中的数据也会消失，因此数据库和用户文件需要放在 Volume 或挂载目录中。

Volume 与 Bind Mount

• Volume 由 Docker 管理，适合数据库等需要长期保存的数据；
• Bind Mount 把宿主机指定目录映射到容器，适合开发时同步源码和配置文件。

Network

容器默认运行在隔离网络中。端口映射让宿主机能够访问容器服务，自定义网络则允许多个容器通过容器名互相访问。

安装与验证

Windows 和 macOS 可以安装 Docker Desktop，Linux 建议按照对应发行版的 Docker Engine 官方安装说明 操作。不要长期沿用来源不明的一键安装脚本。

安装完成后检查版本：

1
2

docker version
docker compose version

运行官方测试容器：

1

docker run --rm hello-world

--rm 表示容器停止后自动删除。能够看到 Hello from Docker 的输出，就说明客户端、Daemon 和镜像拉取均正常。

运行第一个服务

下面使用 Nginx 启动一个 Web 服务：

1
2
3
4

docker run -d \
  --name my-nginx \
  -p 8080:80 \
  nginx:alpine

参数含义：

• -d：后台运行；
• --name my-nginx：指定容器名称；
• -p 8080:80：把宿主机的 8080 端口映射到容器的 80 端口；
• nginx:alpine：使用 Nginx 的 Alpine 镜像标签。

打开 http://localhost:8080 即可看到 Nginx 页面。查看容器和日志：

1
2

docker ps
docker logs -f my-nginx

停止、再次启动和删除容器：

1
2
3

docker stop my-nginx
docker start my-nginx
docker rm -f my-nginx

常用命令

镜像

1
2
3
4

docker pull nginx:alpine       # 拉取镜像
docker images                  # 查看本地镜像
docker image inspect nginx:alpine
docker rmi nginx:alpine        # 删除未使用的镜像

容器

1
2
3
4
5
6

docker ps                      # 查看运行中的容器
docker ps -a                   # 查看全部容器
docker inspect my-nginx        # 查看容器详细信息
docker stats                   # 实时查看资源占用
docker exec -it my-nginx sh    # 进入运行中的容器
docker cp my-nginx:/etc/nginx/nginx.conf ./nginx.conf

容器的主进程结束后，容器也会停止。如果容器一启动就退出，可以先使用 docker ps -a 找到它，再用 docker logs 容器名 查看原因。

环境变量与端口

很多镜像使用环境变量接收配置：

1
2
3
4

docker run --rm \
  -e APP_ENV=production \
  -e TZ=Asia/Shanghai \
  my-app:latest

端口写法是 宿主机端口:容器端口：

1

docker run -d -p 127.0.0.1:8080:80 nginx:alpine

上面的服务只监听宿主机回环地址。如果写成 -p 8080:80，可能会向局域网或公网暴露端口，具体取决于宿主机防火墙和网络环境。

数据持久化

使用 Volume

1
2
3
4
5
6
7
8
9

docker volume create app-data

docker run -d \
  --name app \
  -v app-data:/var/lib/app \
  my-app:latest

docker volume ls
docker volume inspect app-data

删除容器不会自动删除命名 Volume，因此重新创建容器后仍可以挂载原来的数据。

挂载宿主机目录

1
2
3
4
5

docker run -d \
  --name static-site \
  -p 8080:80 \
  --mount type=bind,source="$(pwd)/html",target=/usr/share/nginx/html,readonly \
  nginx:alpine

Windows PowerShell 需要把 $(pwd)/html 换成实际目录，例如 D:/Web/html。只读配置或静态文件建议加上 readonly，避免容器意外修改宿主机文件。

使用 Dockerfile 构建镜像

假设当前目录有一个 Hexo 生成的 public 文件夹，可以编写以下 Dockerfile：

1
2
3
4
5

FROM nginx:alpine

COPY public/ /usr/share/nginx/html/

EXPOSE 80

构建并运行：

1
2

docker build -t my-blog:1.0 .
docker run -d --name my-blog -p 8080:80 my-blog:1.0

建议同时创建 .dockerignore，避免把无关内容发送给构建器：

1
2
3
4

.git
node_modules
.deploy_git
*.log

镜像标签最好使用明确版本，例如 my-blog:1.0，不要在生产环境只依赖会变化的 latest。

使用 Docker Compose

当项目包含 Web、数据库、缓存等多个服务时，逐个执行 docker run 会比较麻烦。可以使用 compose.yaml 统一描述：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html:ro
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    volumes:
      - redis-data:/data
    restart: unless-stopped

volumes:
  redis-data:

常用 Compose 命令：

1
2
3
4
5
6

docker compose up -d              # 创建并启动服务
docker compose ps                 # 查看服务状态
docker compose logs -f web        # 跟踪指定服务日志
docker compose pull               # 拉取更新后的镜像
docker compose up -d              # 按新配置重建发生变化的服务
docker compose down               # 停止并删除容器和默认网络

docker compose down 默认不会删除命名 Volume；使用 docker compose down -v 会同时删除数据卷，执行前必须确认数据已经备份。

网络

创建自定义网络并启动两个容器：

1
2
3

docker network create app-net
docker run -d --name redis --network app-net redis:7-alpine
docker run -it --rm --network app-net redis:7-alpine redis-cli -h redis ping

同一自定义网络中的容器可以通过容器名 redis 访问，不需要固定容器 IP。Compose 会为项目自动创建网络，服务之间直接使用服务名通信。

清理资源

先查看磁盘占用：

1

docker system df

按类型清理未使用资源：

1
2
3
4

docker container prune
docker image prune
docker network prune
docker volume prune

docker system prune 会一次清理多种未使用资源；带 --volumes 时还会清理未使用的数据卷。Volume 可能保存数据库数据，不要在不了解影响时使用 docker system prune --volumes。

常见问题

容器名称冲突

如果出现 container name is already in use，说明同名容器仍然存在。使用 docker ps -a 找到它，然后选择继续使用、改名或删除。

端口已被占用

修改端口映射左侧的宿主机端口，例如把 8080:80 改为 8081:80，或者先停止占用该端口的程序。

Linux 下没有权限访问 Docker

默认情况下 Docker Socket 需要 root 权限。可以暂时使用 sudo docker ...，或按照官方安装后的说明配置用户组。加入 docker 用户组相当于授予较高的系统权限，不应把不可信用户加入该组。

镜像架构不匹配

Apple Silicon、ARM 服务器和部分开发板可能遇到 platform does not match。优先选择支持当前架构的多平台镜像；模拟其他架构虽然可行，但性能会下降。

容器里修改的内容重建后消失

容器可写层不是可靠的数据保存位置。需要长期保存的内容应使用 Volume、Bind Mount，或者写入 Dockerfile 重新构建镜像。

使用建议

• 为基础镜像指定版本，并定期重新构建以获取安全修复；
• 不要把密码、Token 和私钥直接写进 Dockerfile 或提交到仓库；
• 尽量让容器使用非 root 用户运行；
• 一个容器只承担清晰的职责，多个服务使用 Compose 组织；
• 为重要数据卷制定备份和恢复方案；
• 通过日志、健康检查和资源限制观察容器状态。

参考文献

1. Docker Docs
2. Docker overview
3. What is a container?
4. Docker Compose Quickstart

残血归来

简介

Mosqitto 是一款实现了消息推送协议 MQTT v3.1 的开源消息代理软件, 提供轻量级的, 支持可发布/可订阅的的消息推送模式, 使设备对设备之间的短消息通信变得简单, 比如现在应用广泛的低功耗传感器, 手机, 嵌入式计算机, 微型控制器等移动设备.

而消息推送协议 MQTT 是物联网(loT)常用的一种协议, 它的特点有:

1. 使用发布/订阅消息模式, 提供一对多的消息发布, 解除应用程序耦合.
2. 小型传输, 开销很小(固定长度的头部是2字节), 协议交换最小化, 以降低网络流量. 这也是它在物联网领域广泛应用的主要原因之一.
3. 支持三种QoS(Quality of Service，服务质量)：
   • “至多一次”, 消息发布完全依赖底层TCP/IP网络. 会发生消息丢失或重复. 这一级别可用于如下情况, 环境传感器数据, 丢失一次读记录无所谓, 因为不久后还会有第二次发送. 这一种方式主要普通APP的推送, 倘若你的智能设备在消息推送时未联网, 推送过去没收到, 再次联网也就收不到了.
   • “至少一次”, 确保消息到达, 但消息重复可能会发生.
   • “只有一次”, 确保消息到达一次. 在一些要求比较严格的计费系统中, 可以使用此级别. 在计费系统中, 消息重复或丢失会导致不正确的结果. 这种最高质量的消息发布服务还可以用于即时通讯类的APP的推送, 确保用户收到且只会收到一次.

下载安装

这里我用的Ubuntu系统, 首先将mosquitto添加到储存库列表

sudo apt-add-repository ppa:mosquitto-dev/mosquitto-ppa

再更新软件包

sudo apt-get update

然后安装mosquitto:

sudo apt-get install mosquitto

根据需要确定是否安装命令行客户端(因为mqtt已经有非常多的gui客户端了, 命令行客户端反而显得没那么好用了, 这里我推荐一个 MATTX , 各个平台都能用, 倒是挺方便的):

sudo apt-get install mosquitto-clients

mosquitto详解

mosquitto主要分为几个部分, 分别为 mosquitto(运行服务器), mosquitto.conf(配置文件), mosquitto_passwd(用户配置), aclfile(用户权限配置).``

mosquitto

命令

mosquitto [-c config file] [ -d | –daemon ] [-p port number] [-v]

参数:

• -c config file: 从config文件加载配置. 如果没有给出, 则使用配置文件的默认值.
• -d 或者 –daemon: 将mosquitto在后台以守护进程的身份运行.
• -p port number: 指定监听的端口, 默认的端口是1883. 也可以指定监听多个端口.
• -v: 使用详细日志记录, 也可以在配置文件中设置.

关于重启mosquitto

一般来说, mosquitto是默认开机自动启动的, 可以通过删除/etc/init.d/mosquitto来关闭开机自启.

通常可以用 ps -aux | grep mosquitto 查找 mosquitto 运行的进程, 再用 kill -9 进程号 来关闭mosquitto, 但这很多时候会出现各种问题, 以至于无法关闭. 这时可以用 ‘/etc/init.d/mosquitto stop’来关闭, 或者用’/etc/init.d/mosquitto restart’来实现重启.

mosquitto.conf

主要的设置

• acl_file file path: 设置访问控制列表文件的路径. 如果定义了该文件，则使用该文件的内容来控制客户端对代理上的主题的访问. 如果定义了此参数，则只有列出的主题才能访问.主题访问权限添加的行格式为：

  topic [read|write|readwrite]
  访问类型由”Read”, “Write” 或 “ReadWrite” 控制. 此参数是可选的, 如果未指定, 则访问权限为读/写. 与订阅中一样, 可以包含 + 或 # 通配符.
  如果允许匿名的话, 第一组主题将应用于匿名客户端.

  user
  指定要控制访问的用户名

  pattern [read|write|readwrite]
  可以使用正则来控制访问的话题, 其中 %c 是匹配客户端的 client id, %u 是匹配客户端的 username.

例如:

1
2
3
4
5
6
7

# 第一行是匿名客户端可以访问的topic, 所有匿名用户都可以订阅话题 topic/anonymous.
topic read topic/anonymous
# 下面是用户admin可以访问的topic, admin可以订阅和发布 topic/ 下所有话题的信息.
user admin
topic readwirte topic/#
# 正则限制, 所有用户都可以在话题 topic/username/data 发布消息.
pattern write topic/%u/data

• password_file: 用户/密码文件, 默认格式: username:password

• include_dir /etc/mosquitto/conf.d: 自己的配置可以放到以下目录中

• allow_anonymous [ true | false ]: 是否允许匿名, 默认是true.

• allow_duplicate_messages [ true | false ]: 是否允许重复/重叠订阅, 默认是true.

• allow_zero_length_clientid [ true | false ]: 是否允许零长度客户端id, 默认为true.

• use_username_as_clientid [ true | false ]: 使用用户名为客户端id, 默认为false.

• pid_file /var/run/mosquitto.pid: 服务进程的PID.

• user username: 服务进程的系统用户.

• port port number: 服务绑定的端口, 默认的是1883

• retry_interval: 当QoS为1或2的消息已经被发送后, mosquitto在一段时间内仍未接收到客户端的反馈消息, 将重新发送消息. 默认为20秒.

• max_connections -1: 最大连接数, -1代表不限制.

• require_certificate false: 必须提供证书以保证数据安全性.

• cafile: CA证书文件.

• capath: CA证书目录.

• certfile: PEM证书文件.

• keyfile: PEM密钥文件.

• autosave_interval 1800: 消息自动保存的间隔时间

• autosave_on_changes false: 消息自动保存功能的开关

• persistence true: 持久化功能的开关

• persistence_file mosquitto.db: 持久化DB文件

• persistence_location /var/lib/mosquitto/: 持久化DB文件目录

• log_dest none: 4种日志模式: stdout, stderr, syslog, topic, none 则表示不记日志, 此配置可以提升些许性能.

• log_type error: 选择日志的级别(可设置多项), 包括error, warning, notice, information.

• connection_messages true: 是否记录客户端连接信息.

• log_timestamp true: 是否记录日志时间

推荐的配置

1
2
3
4
5
6
7
8
9
10
11
12
13

pid_file /var/run/mosquitto.pid

persistence true

persistence_location /var/lib/mosquitto/

include_dir /etc/mosquitto/conf.d

allow_anonymous false

password_file /etc/mosquitto/pwfile

acl_file /etc/mosquitto/aclfile

mosquitto_passwd

mosquitto_passwd [ -c | -D ] passwordfile username
mosquitto_passwd -b passwordfile username password
mosquitto_passwd -U passwordfile

mosquitto_passwd用于管理mosquitto代理的mqtt服务器的密码文件, 其中username不能包含”:”.

参数:

• -b: 以批量模式运行. 这允许在命令行中提供密码, 这可以很方便, 但应小心使用, 因为密码将在命令行和命令历史记录中可见.
• -c: 创建新的密码文件. 如果文件已经存在, 它将被覆盖.
• -D: 从密码文件中删除指定的用户.
• -U: 此选项可用于升级/将带有纯文本密码的密码文件升级/转换为使用哈希密码的文件. 它将修改指定的文件, 它无法检测密码是否已经哈希，因此在已经包含哈希密码的密码文件中使用它将根据旧哈希生成新的哈希, 并使密码文件无法使用.
• passwordfile: 要修改密码的文件.
• username: 添加/更新/删除的用户名.
• password: 在批次模式下使用的密码.

例如:
将用户test添加到新的密码文件:
mosquitto_passwd -c /etc/mosquitto/passwd test

从密码文件中删除用户test:
mosquitto_passwd -D /etc/mosquitto/passwd test

aclfile

详见 主要的设置

参考资料

[1]mosquitto
[2]mosquitto.conf
[3]mosquitto_passwd
[4]mosquitto.conf配置参数详细说明

简介

在 Django 的学习过程中, 我们一直使用 Django 的 manage.py 的runserver 命令来运行 Django 应用, 这个命令启动的是 Django 自带的用于开发的简易服务器, 它是一个用纯 Python 写的轻量级的 Web 服务器. 这个服务器内置在 Django 中是为了方便开发, 并不适用于实际的生产环境. 当项目真正部署上线的时候我们就必须 Django 项目部署到特定的web服务器上了.

这里我们采用的是 Ubuntu + nginx + django 方式.

我的配置

• 系统: ubuntu-20.04.1-desktop-amd64
• Web服务器软件: nginx/1.18.0 (Ubuntu)
• uwsgi: uWSGI-2.0
• Django: Django-3.1.3

安装Nginx

Nginx是一款轻量级的Web服务器/反向代理服务器及电子邮件(IMAP/POP3)代理服务器, 并在一个BSD-like协议下发行. 其特点是占用内存少, 并发能力强, 事实上nginx的并发能力确实在同类型的网页服务器中表现较好.

打开Ubuntu终端, 利用Ubuntu的仓库安装, 运行命令sudo apt-get install nginx即可进行安装.

启动, 关闭, 重载nginx则可用以下命令

1
2
3

nginx
nginx -s stop
nginx -s reload

这里可以启动测试一下, 进入 http://127.0.0.1:80/ 页面应该会出现”Welcome to nginx!”界面, 这样就说明启动成功了.

这样安装的Nginx的配置文件放在/etc/nginx/nginx.conf位置, 后续我们要对配置进行修改.

安装uwsgi

是实现了uwsgi和WSGI两种协议的Web服务器, 但是并不全面, 所以我们后续还要配置nginx服务器

• uwsgi:https://pypi.python.org/pypi/uWSGI
• uwsgi 参数详解：http://uwsgi-docs.readthedocs.org/en/latest/Options.html

这里我们可以使用pip进行安装pip3 install uwsgi

配置Nginx和uwsgi

配置uwsgi需要我们在项目根目录创建一个ini或者xml文件, 项目目录如下

1
2
3
4
5
6
7
8

mysite/
├── manage.py
├── mysite/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── uwsgi.ini

在我们通过Django创建mysite项目时, 在子目录mysite下已经帮我们生成的 wsgi.py文件. 所以, 我们只需要再创建uwsgi的配置文件即可, uwsgi支持多种类型的配置文件, 如xml，ini等, 此处，使用ini类型的配置.

ini 文件内容如下：

1
2
3
4
5
6
7
8

[uwsgi]
# Django-related settings
socket = :8099
chdir           = /home/mysite  #这里写入你自己项目的地址
module          = mysite.wsgi
master          = true
processes       = 4
vacuum          = true

uwsgi的配置常用ini文件, 这里先列出一些参数:

• http: 协议类型和端口号
• processes: 开启的进程数量
• workers: 开启的进程数量，等同于processes（官网的说法是spawn the specified number ofworkers / processes）
• chdir: 指定运行目录（chdir to specified directory before apps loading）
• wsgi-file: 载入wsgi-file（load .wsgi file）
• stats: 在指定的地址上，开启状态服务（enable the stats server on the specified address）
• threads: 运行线程。由于GIL的存在，我觉得这个真心没啥用。（run each worker in prethreaded mode with the specified number of threads）
• master: 允许主进程存在（enable master process）
• daemonize: 使进程在后台运行，并将日志打到指定的日志文件或者udp服务器（daemonize uWSGI）。实际上最常用的，还是把运行记录输出到一个本地文件上。
• pidfile: 指定pid文件的位置，记录主进程的pid号。
• vacuum: 当服务器退出的时候自动清理环境，删除unix socket文件和pid文件（try to remove all of the generated file/sockets）

接下来, 进入mysite项目目录下, 通过uwsgi命令读取uwsgi.ini文件启动项目.
uwsgi --ini myweb_uwsgi.ini
注意查看uwsgi的启动信息, 如果有错, 就要检查配置文件的参数是否设置有误.

再接下来要做的就是修改nginx.conf配置文件. 打开/etc/nginx/nginx.conf文件, 编辑内容:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

events {
    worker_connections  1024;
}
http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    server {
        listen         80; 
        server_name    127.0.0.1; #这里一般填写网址, 没有的话就填写127.0.0.1
        charset UTF-8;
        access_log      /var/log/nginx/mysite_access.log;
        error_log       /var/log/nginx/mysite_error.log;
        client_max_body_size 75M;
        location / { 
            include uwsgi_params;
            uwsgi_pass 127.0.0.1:8099; # 该处端口要和uwsgi的ini文件中一样
            uwsgi_read_timeout 2;
        }   
        location /static {
            expires 30d;
            autoindex on; 
            add_header Cache-Control private;
            alias /home/mysite/static/;  # 静态文件地址
        }
   }
}

关于nginx.conf文件的配置, 可以参考 NGINX Docs | Configuration Guide

现在重新启动nginx，翻看上面重启动nginx的命令. 然后, 访问: http://127.0.0.1:80/ 即可.

参考资料

1. 通过Nginx部署Django（基于ubuntu) - 虫师 - 博客园
2. Django快速部署简约版 v3.0 - 简书

嵌套饼图

我们可以用嵌套饼图更直观地展示某些的类型数据, 下面是用一个例子详细介绍如何用python绘制嵌套饼图.

这里要绘制的是一个最内圈 6 个类别, 每个类别再细分为几个方向, 各个方向上再进行细分.

大致的效果如下:

下面我们来一步一步实现这个嵌套饼图.

绘制饼图

1
2
3
4
5
6
7
8
9
10
11
12
13
14

ax.pie( vals_first, radius=1-size-size,
        colors=inner_colors, labels=labels_first, 
        labeldistance=0.5, rotatelabels=True, 
        textprops={'fontsize': 11}, wedgeprops=dict(width=size, edgecolor='w'))

ax.pie( vals_second.flatten(), radius=1-size, 
        colors=outer_colors, labels=labels_seocnd, 
        labeldistance=0.7,  rotatelabels=True, 
        textprops={'fontsize': 11}, wedgeprops=dict(width=size, edgecolor='w'))

ax.pie( vals_third.flatten(), radius=1, 
        colors=outer_colors, labels=labels_third, 
        labeldistance=0.8,  rotatelabels=True, 
        textprops={'fontsize': 11}, wedgeprops=dict(width=size, edgecolor='w'))

这里是使用matplotlib绘制饼图的代码, 绘制了三层饼图, 对每一层饼图的半径和宽度进行了设置, 使得三层饼图可以一层一层套在一起.

这些参数中, 第一个参数为绘制饼图的数值, radius为饼图的半径, textprop为标签的属性, 设置rotatelabels为True, 使得标签自动旋转. wedgeprops中可以设置饼图的各项数据, 这里我们设置了饼图的宽度和边颜色, 使得饼图显示成嵌套饼图的样子.

这边数据, 颜色, 标签的设置会在后面慢慢细说.

数据设置

数据方面, 由于这次的数据差别太大, 若按照比例来绘制的话, 必然有一些数据显示不出来, 所以我选择将所有数据添加一个固定的数值, 再按照比例来绘制. 但是还有一个问题, 部分数据过大或过小, 会非常影响图形的观感, 这里我只能在绘制图形时手动设置该部分所占的大小.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

# 第二圈的数据
vals_b = np.array([
    [47.5,11.7,15.2,9.6],
    [0,44.8,7.5,0], 
    [9.2, 68.5 , 0, 0],
    [1.2, 7.2, 0, 0],
    [80,0, 0, 0],
    [1.7, 18.9, 0, 0]
])

# 第三圈的数据
vals_c = np.array([ 
    [47.5,11.7,15.2,9.6],
    [0,36.6,8.2,7.5], 
    [9.2,38.1,30.4, 0],
    [1.2, 5.8, 1.4, 0],
    [80,0, 0, 0],
    [1.7, 18.9, 0, 0]
])

# 第一圈的数据
vals_inner = vals_middle.sum(axis=1)

# 绘图时最内圈使用的数值为内圈各类数据加上base
vals_first = vals_inner + base

’‘’
绘图时第二圈使用的数值, 因为最内圈每个类别都加上了base, 所以为了确保第二圈的数值和内圈相匹配, 第二圈的各类别要按照各自所占的比例分配各类的总数值.
‘’‘
vals_second = np.zeros((6, 4))
for i in range(6):
    s_a = vals_first[i]
    s_b = vals_a[i].sum()
    # 如果第二圈某类总数值为0, 则分配base.
    if s_b == 0.0:
        vals_second[i][1] = base
        continue
    for j in range(4):
        vals_second[i][j] = (vals_mid[i][j] / s_b) * s_a
    
# 第三圈使用的数值, 和上方同理
vals_third = np.zeros((6, 4))
for i in range(6):
    s_a = vals_first[i]
    s_b = vals_outer[i].sum()
    if s_b == 0.0:
        vals_third[i][1] = base
        continue
    for j in range(4):
        vals_third[i][j] = (vals_outer[i][j] / s_b) * s_a

颜色设置

官方自带的 Colormaps, 这里我需要的是6×4共24种颜色, 于是我选择了colormap tab20c的全部色彩和 tab20b 中 5至8 颜色, 一共24种, 当然你也可以通过 rgba 自己定义颜色而不是选择colormap.

具体代码如下:

1
2
3
4
5
6
7
8
9
10
11
12

# 获取colormap tab20c和tab20b的颜色
cmap_c = plt.get_cmap("tab20c")
cmap_b = plt.get_cmap("tab20b")

# 使用tab20c的全部颜色和tab20b中的 5至8 颜色
cmap_1 = cmap_c(np.arange(20))
cmap_2 = cmap_b(np.array([4, 5, 6, 7]))

# 内圈的颜色是每4个颜色中色彩最深的那个. vstack是将两类颜色叠加在一起
inner_colors = np.vstack((cmap_1[::4], cmap_2[0]))
# 外圈的颜色是全部24种颜色
outer_colors = np.vstack((cmap_1, cmap_2))

标签设置

标签总共是三圈的标签, 内圈, 中圈和外圈, 这里内圈我为了更美观得显示数据, 更改了某些类别的占比, 所以不能直接从输入数据中获取到值, 只能手动输入数值.

中圈和外圈也是同理, 因为绘制的量不大, 中圈和外圈我全部采取了手动输入的方法, 事实上效率确实是大大下降了, 但是毕竟是为了图案美观, 不得已而为之. 如果数据允许的话, 这三种标签中的数据都可以采用输入的数据, 而非手动填写.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

labels_first=["餐厨废弃物\n{}万吨".format(vals_first[0]), 
        "农业秸秆\n{}万吨".format(vals_first[1]), 
        "水草\n151.2万吨", 
        "园林绿化\n废弃物\n{}万吨".format(vals_first[3]),
        "淤泥\n432.0万吨",
        "畜禽粪便\n21.6万吨"
        ]

labels_seocnd=[
    "未分类收集\n67.6万吨",
    "生物干化\n3.7万吨",
    "厌氧发酵\n10.2万吨",
    "油水分离\n2.6万吨",

    "",
    "粉碎\n46.8万吨",
    "好氧发酵\n3.5万吨",
    "",

    "未处理\n4.2万吨",
    "藻水分离\n147.0万吨",
    "",
    "",

    "未处理\n1.2万吨",
    "粉碎\n7.2万吨",
    "",
    "",

    "堆放\n432.0万吨",
    "",
    "",
    "",

    "未处理\n0.7万吨",
    "好氧发酵\n19.9万吨",
    "",
    "",
]

labels_third=[
    "未处理\n67.5万吨",
    "肥料化、发电\n3.7万吨",
    "沼气、沼渣发电\n10.2万吨",
    "焚烧\n2.6万吨",

    "",
    "还田\n42.6万吨",
    "燃料化\n4.2万吨",
    "肥料化\n3.5万吨",

    "未利用\n4.2万吨",
    "燃料化\n80.2万吨",
    "肥料化\n66.8万吨",
    "",

    "未利用\n1.2万吨",
    "肥料化\n5.8万吨",
    "燃料化\n1.4万吨",
    "",

    "未利用\n432.0万吨",
    "",
    "",
    "",

    "未利用\n0.7万吨",
    "肥料化\n19.9万吨",
    "",
    "",
]

图例

这里因为只需要内圈的图例, 所以我把内圈的handels单独拿了出来

1
2
3
4

handles, labels =  ax.pie(vals_first, radius=1-size-size, 
                labels=labels_first, 
                labeldistance=0.5,  rotatelabels=True, textprops={'fontsize': 11}, 
                colors=inner_colors, wedgeprops=dict(width=size, edgecolor='w'))

再绘制图例时不再简单使用plt.legend()而是使用:

1
2
3
4
5
6
7
8
9

plt.legend(handles=handles, labels=[
        "餐厨废弃物", 
        "农业秸秆", 
        "水草", 
        "园林绿化废弃物", 
        "淤泥",
        "畜禽粪便"],
        loc = 1
        )

这样出来的图中就只会显示最内层的图例了.

附全部代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174

from matplotlib import pyplot as plt
import numpy as np

size = 0.25
base = 50


plt.rcParams['font.family'] = 'SimHei'
fig, ax = plt.subplots(figsize = (10, 10))

vals_middle = np.array([
    [47.5,11.7,15.2,9.6],
    [0,44.8,7.5,0], 
    [9.2, 68.5 , 0, 0],
    [1.2, 7.2, 0, 0],
    [80,0, 0, 0],
    [1.7, 18.9, 0, 0]
])

vals_outer = np.array([ 
    [47.5,11.7,15.2,9.6],
    [0,36.6,8.2,7.5], 
    [9.2,38.1,30.4, 0],
    [1.2, 5.8, 1.4, 0],
    [80,0, 0, 0],
    [1.7, 18.9, 0, 0]
])

vals_inner = vals_middle.sum(axis=1)

# 最内圈使用的数值为内圈各类数据加上base
vals_first = vals_inner + base

'''
第二圈使用的数值, 因为最内圈每个类别都加上了base, 所以为了确保第二圈的数值和内圈相匹配, 第二圈的各类别要按照各自所占的比例分配各类的总数值.
'''
vals_second = np.zeros((6, 4))
for i in range(6):
    s_a = vals_first[i]
    s_b = vals_middle[i].sum()
    # 如果第二圈某类总数值为0, 则分配base.
    if s_b == 0.0:
        vals_second[i][1] = base
        continue
    for j in range(4):
        vals_second[i][j] = (vals_middle[i][j] / s_b) * s_a
    
# 第三圈使用的数值, 和上方同理
vals_third = np.zeros((6, 4))
for i in range(6):
    s_a = vals_first[i]
    s_b = vals_outer[i].sum()
    if s_b == 0.0:
        vals_third[i][1] = base
        continue
    for j in range(4):
        vals_third[i][j] = (vals_outer[i][j] / s_b) * s_a


# 获取colormap tab20c和tab20b的颜色
cmap_c = plt.get_cmap("tab20c")
cmap_b = plt.get_cmap("tab20b")

# 使用tab20c的全部颜色和tab20b中的 5至8 颜色
cmap_1 = cmap_c(np.arange(20))
cmap_2 = cmap_b(np.array([4, 5, 6, 7]))

# 内圈的颜色是每4个颜色中色彩最深的那个. vstack是将两类颜色叠加在一起
inner_colors = np.vstack((cmap_1[::4], cmap_2[0]))
# 外圈的颜色是全部24种颜色
outer_colors = np.vstack((cmap_1, cmap_2))



labels_first=["餐厨废弃物\n{}万吨".format(vals_inner[0]), 
        "农业秸秆\n{}万吨".format(vals_inner[1]), 
        "水草\n151.2万吨", 
        "园林绿化\n废弃物\n{}万吨".format(vals_inner[3]),
        "淤泥\n432.0万吨",
        "畜禽粪便\n21.6万吨"
        ]

labels_seocnd=[
    "未分类收集\n67.6万吨",
    "生物干化\n3.7万吨",
    "厌氧发酵\n10.2万吨",
    "油水分离\n2.6万吨",

    "",
    "粉碎\n46.8万吨",
    "好氧发酵\n3.5万吨",
    "",

    "未处理\n4.2万吨",
    "藻水分离\n147.0万吨",
    "",
    "",

    "未处理\n1.2万吨",
    "粉碎\n7.2万吨",
    "",
    "",

    "堆放\n432.0万吨",
    "",
    "",
    "",

    "未处理\n0.7万吨",
    "好氧发酵\n19.9万吨",
    "",
    "",
]

labels_third=[
    "未处理\n67.5万吨",
    "肥料化、发电\n3.7万吨",
    "沼气、沼渣发电\n10.2万吨",
    "焚烧\n2.6万吨",

    "",
    "还田\n42.6万吨",
    "燃料化\n4.2万吨",
    "肥料化\n3.5万吨",

    "未利用\n4.2万吨",
    "燃料化\n80.2万吨",
    "肥料化\n66.8万吨",
    "",

    "未利用\n1.2万吨",
    "肥料化\n5.8万吨",
    "燃料化\n1.4万吨",
    "",

    "未利用\n432.0万吨",
    "",
    "",
    "",

    "未利用\n0.7万吨",
    "肥料化\n19.9万吨",
    "",
    "",
]


handles, labels =  ax.pie(vals_first, radius=1-size-size, 
                labels=labels_first, 
                labeldistance=0.5,  rotatelabels=True, textprops={'fontsize': 11}, 
                colors=inner_colors, wedgeprops=dict(width=size, edgecolor='w'))

ax.pie(vals_second.flatten(),   radius=1-size, colors=outer_colors,
    labels=labels_seocnd, 
    labeldistance=0.7,  rotatelabels=True, textprops={'fontsize': 11}, 
    wedgeprops=dict(width=size, edgecolor='w'))

ax.pie(vals_third.flatten(), radius=1, colors=outer_colors,
    labels=labels_third, 
    labeldistance=0.8,  rotatelabels=True, textprops={'fontsize': 11},
    wedgeprops=dict(width=size, edgecolor='w'))


plt.title('某市有机废弃物产生、处理、利用情况', fontsize=25)
plt.legend(handles=handles, labels=[
        "餐厨废弃物", 
        "农业秸秆", 
        "水草", 
        "园林绿化废弃物", 
        "淤泥",
        "畜禽粪便"],
        loc = 1
        )
plt.show()

Seaborn库简介

Seborn是一个基于matplotlib的Python数据可视化库, 它提供了一个高度交互式界面, 用于绘制有吸引力和信息量的统计图形.

Seaborn其实是在matplotlib的基础上进行了更高级的API封装, 从而使得作图更加容易, 在大多数情况下使用seaborn就能做出很具有吸引力的图, 而使用matplotlib就能制作具有更多特色的图. 所以应该把Seaborn视为matplotlib的补充, 而不是替代物. 同时它能高度兼容numpy与pandas以及scipy与statsmodels等科学计算库. 掌握seaborn能很大程度帮助我们更高效的观察数据与图表, 并且更加深入了解它们.

Seaborn其有如下特点:

• 基于matplotlib aesthetics绘图风格, 增加了一些绘图模式;
• 增加调色板功能, 利用色彩丰富的图像揭示您数据中的模式;
• 运用数据子集绘制与比较单变量和双变量分布的功能;
• 运用聚类算法可视化矩阵数据;
• 灵活运用处理时间序列数据;
• 利用网格建立复杂图像集.

Seaborn绘制散点图

seaborn.scatterplot(x=None, y=None, hue=None, style=None, size=None, data=None, palette=None, hue_order=None, hue_norm=None, sizes=None, size_order=None, size_norm=None, markers=True, style_order=None, alpha=’auto’, legend=’brief’, ax=None, **kwargs)

参数:

• x, y (names of variables in data or vector data, optional): 输入的x, y 轴变量, 必须是数字. 可以直接传递数据, 或者引用data中的列.
• hue(name of variables in data or vector data, optional): 将输入的变量分组, 并分别给与不同的颜色, 可以是文字分类列也可以是数字列, 这两者的结果会有所不同.
• size(name of variables in data or vector data, optional): 将输入的变量分组, 并分别给与不同的大小, 可以是文字分类列也可以是数字列, 这两者的结果会有所不同.
• style(name of variables in data or vector data, optional): 将输入的变量分组, 并分别给与不同的标志, 可以是文字分类列也可以是数字列, 但是数字列始终是被认为是分类标志.
• data(DataFrame): 整齐数据框, 其中每一列都是变量, 每一行都是观察值.
• palette (palette name, list, or dict, optional): 调色板, 要应用于hue不同级别的色板, 具体使用可以参考color_palette()
• hue_order(list, optional): hue不同级别色彩出现的详细顺序, 不指定则由数据确定, 当hue变量为数字时不相关.
• hue_norm(tuple or Normalize object, optional): 当hue变量为数值时, 使其归一化以上色.
• sizes(list, dict, or tuple, optional): 当size已经给定了, 决定散点大小可选的list, 或者针对不同的size值给定不同的大小(dict), 当size值为数字时, 同样可以用元组(tuple)决定散点大小的范围.
• size_order(list, optional): 散点大小不同级别的详细顺序. 不指定则由数据确定, 当size变量为数字时不相关.
• size_norm(tuple or Normalize object, optional): 当size变量为数值时, 使其归一化以上色.
• markers(boolean, list, or dictionary, optional): 散点标志, 设置为True则使用默认设置, 或者你可以给定一个marker的list以供选择, 你也可以根据style参数对不同的类别给定不同的marker(dict).
• style_order(list, optional): marker不同级别出现的详细顺序, 不指定则由数据确定, 当style变量为数字时不相关.
• alpha(float): 散点的透明度.
• legend(“brief”, “full”, 或者 False, optional): 如何绘制图例, 如果是”brief”, 则数字的hue和size变量将以均匀的间隔表示(并不会把所有类别的图例都表示出来); 如果是”full”, 则每个类别都会在图例中表示出来; 如果是 False , 则不会绘制图例.
• ax(matplotlib Axes, optional): 在哪个axes上绘制该图, 不填写则使用当前axes.
• kwargs(key, value mappings): 其他关键字参数传递给 matplotlib.axes.Axes.scatter().

这边举几个例子:

这里我使用的是seaborn的官方数据集, 因为国内网络问题, 无法在线加载数据集, 我是下载后使用的, 数据集地址

绘制x为total_bill, y为tip的散点图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

tips = pd.read_csv("seaborn-data/tips.csv")
tips
"""输出结果:
total_billtipsexsmokerdaytimesize
016.991.01FemaleNoSunDinner2
110.341.66MaleNoSunDinner3
221.013.50MaleNoSunDinner3
323.683.31MaleNoSunDinner2
424.593.61FemaleNoSunDinner4
........................
23929.035.92MaleNoSatDinner3
24027.182.00FemaleYesSatDinner2
24122.672.00MaleYesSatDinner2
24217.821.75MaleNoSatDinner2
24318.783.00FemaleNoThurDinner2
244 rows × 7 columns
"""

sns.scatterplot(x="total_bill", y="tip", data=tips)

绘制出来的图形如下:

按照不同的性别绘制不同的颜色:

1

sns.scatterplot(x="total_bill", y="tip", data=tips, hue='sex')

绘制出来的图形如下:

按照不同的size绘制不同的颜色:

1

sns.scatterplot(x="total_bill", y="tip", data=tips, hue='sex', size='size', legend='full')

绘制出来的图形如下:

按照是否抽烟绘制不同的marker:

1

sns.scatterplot(x="total_bill", y="tip", data=tips, hue='sex', size='size', style='smoker')

绘制出来的图形如下:

Seaborn绘制折线图

seaborn.lineplot(x=None, y=None, hue=None, size=None, style=None, data=None, palette=None, hue_order=None, hue_norm=None, sizes=None, size_order=None, size_norm=None, dashes=True, markers=None, style_order=None, units=None, estimator=’mean’, ci=95, n_boot=1000, seed=None, sort=True, err_style=’band’, err_kws=None, legend=’brief’, ax=None, **kwargs)

参数基本和散点图一样, 但是还是多了一些可用的参数:

• dashes(boolean, list, or dictionary, optional): 确定为不同级别的style绘制什么样的marker. 设置为True将使用默认的dash codes, 或者你可以传递dash codes列表或style变量到dash codes的字典映射. 设置为False将对所有子集使用实线.
• units(long_form_var): 分组变量标识采样单位. 使用时, 将使用适当的方式为每个unit绘制一条单独的线, 但不会添加图例. 当不需要精确的线条身份时, 可用于显示实验重复的分布.
• estimator (name of pandas method or callable or None, optional): 在同一x级别上跨y变量的多个观测值进行聚合的方法. 如果为None, 将绘制所有观测值.
• ci(int or “sd” or None, optional): 与估计量进行汇总时要绘制的置信区间的大小. “sd”表示绘制数据的标准差. 设置为None将跳过引导程序.
• n_boot(int, optional): 用于计算置信区间的引导程序数.
• seed(int, numpy.random.Generator, or numpy.random.RandomState, optional): 种子或随机数生成器, 可重现自举.
• sort(boolean, optional): 如果为True, 则数据将按x和y变量排序, 否则线条将按照它们在数据集中出现的顺序出现.
• err_style(“band” or “bars”, optional): 是否绘制具有半透明误差带或离散误差线的置信区间.
• err_kws(dict of keyword arguments): 其他控制误差线外观的参数, 传递给matplotlib.axes.Axes.fill_between() 或者 matplotlib.axes.Axes.errorbar(), 取决于err_style.

举几个例子:

对于复杂的数据集, 如对相同的x变量值进行多次测量, seaborn中的默认行为是通过绘制平均值和围绕平均值的95%置信区间来聚合每个x值处的多个测量值.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

fmri = pd.read_csv("seaborn-data/fmri.csv")
fmri
"""输出结果:
subjecttimepointeventregionsignal
0s1318stimparietal-0.017552
1s514stimparietal-0.080883
2s1218stimparietal-0.081033
3s1118stimparietal-0.046134
4s1018stimparietal-0.037970
..................
1059s08cuefrontal0.018165
1060s137cuefrontal-0.029130
1061s127cuefrontal-0.004939
1062s117cuefrontal-0.025367
1063s00cueparietal-0.006899
1064 rows × 5 columns
"""

sns.lineplot(x="timepoint", y="signal", data=fmri)

绘制出来的图形如下:

使用自动计算置信区间, 对于较大的数据集, 可能会占用大量时间, 因此可以设置ci=None来禁用它.

参考资料

[1] Official seaborn tutorial - seaborn 0.10.1 documentation
[2] 10分钟python图表绘制 | seaborn入门（一）：distplot与kdeplot - 知乎

说在前面

这里重点介绍Django后端, 前端我用的是bootstrap5前端组件库, 水平不够就不进行过多介绍了.

开发环境搭建

• 使用的python版本为Python3.8;
• 使用的django版本为Django3.0;
• 使用的编辑器为vscode.

项目需求分析

这里我要搭建的是一个普通的blog, 需要的是blog的基础功能, 包括:

• 导航栏
• 横幅幻灯片
• 文章列表
• 文章分类
• 文章标签
• 文章内容
• 文章浏览量
• 文章搜索
• 热门排行

其实也没多少东西, 包含的页面主要有:

1. 博客首页
2. 文章分类页
3. 文章标签页
4. 文章搜索页
5. 文章内容页

数据库设计

文章表结构

幻灯片表结构

文章分类表

文章标签表

项目创建以及配置

创建项目

打开命令行, cd 到一个你想放置你代码的目录, 然后运行以下命令:
django-admin startproject myblog
这行代码将会在当前目录下创建一个 myblog 目录.
进入 myblog 目录,输入命令
python manage.py runserver
即可在 https://127.0.0.1:8000/ 中看到欢迎界面
创建应用时使用命令
python manage.py startapp blog
这将会创建一个名为blog的目录, 即为应用.

其它常用命令还有:
python manage.py makemigrations
Django 会检测你对模型文件的修改, 并且把修改的部分储存为一次迁移.
再使用命令
python manage.py migrate
进行迁移.

python manage.py shell
使用该命令可以在shell界面对django项目进行简单调试.

myblog/settings.py配置

设置语言和时区:

1
2
3
4

#settings
LANGUAGE_CODE = 'zh-hans'  # 修改语言为中文
TIME_ZONE = 'Asia/Shanghai'  # 修改时区为上海
USE_TZ = True  # 建议设置为True, 这样后端全局都会使用UTC时间, 但是在模板中渲染时会自动转换为当前时区 

在INSTALL_APPS中添加应用:

1
2
3
4

INSTALLED_APPS = [
    'blog.apps.BlogConfig',#注册APP应用
    ...
]

配置数据库：

这里我用的是mysql数据库(默认是使用sqlite3), 需要安装 MySQLdb 才能使用.
pip install MySQLdb
并在blog/__init__.py中添加 import MySQLdb.

1
2
3
4
5
6
7
8
9
10
11

# 修改成mysql如下
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql', 
        'NAME': 'myblog',  #  你的数据库名称
        'USER': 'name',  #  你的数据库用户名
        'PASSWORD': 'password',  #  你的数据库密码
        'HOST': 'localhost',  #  你的数据库主机，留空默认为localhost
        'PORT': '3306',  #  你的数据库端口
    }
}

注意要提前建好schema.

设置静态文件夹目录的路径:

1
2
3
4
5
6
7
8
9

# 设置静态文件目录
STATIC_URL = '/static/'
STATICFILES_DIRS = (
    os.path.join(BASE_DIR, "static"),
)

# 设置媒体文件上传目录
MEDIA_URL = '/media/'  
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')    # 

Django ORM创建

Django是通过Model操作数据库, Model准确且唯一的描述了数据. 它包含你储存的数据的重要字段和行为. 一般来说, 每一个模型都映射一张数据库表.

• 每个模型都是一个 Python 的类, 这些类继承 django.db.models.Model.
• 模型类的每个属性都相当于一个数据库的字段.
• 利用这些, Django 提供了一个自动生成访问数据库的 API.

根据我们数据库的设计, 可以很快写出这个Model(文章内容我是使用富文本保存的, 但是django并没有集成富文本, 这里使用的是django-ckeditor富文本编辑器, 可以使用pip install django-cheditor自行安装, 注意在INSTALL_APPS中注册ckeditor, 具体使用方法可以查看 Django搭建个人博客：使用django-ckeditor富文本编辑器):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

# myblog/blog/models.py

from django.db import models
from ckeditor.fields import RichTextField


class Category(models.Model):
    """分类表"""

    name = models.CharField(max_length=100, unique=True)
    index = models.IntegerField(default=999)

    def __str__(self):
        return self.name

    class Meta:
        # 排序方式按照index排序
        ordering = ["index"]
        verbose_name = 'category'
        verbose_name_plural = 'categorys'


class Tag(models.Model):
    """标签表"""

    name = models.CharField(max_length=100)

    def __str__(self):
        return self.name

    class Meta:
        verbose_name = 'tag'
        verbose_name_plural = 'tags'


class Article(models.Model):
    """文章表"""

    title = models.CharField(max_length=128)
    # 使用ckeditor的富文本保存.
    content = RichTextField(blank=True, null=True)
    abstract = models.TextField(max_length=500, blank=True, null=True)
    cover = models.ImageField(upload_to='article_cover/%Y/%m/%d/',
                              verbose_name='article_cover', blank=True, null=True)
    category = models.ForeignKey(
        Category, on_delete=models.DO_NOTHING, blank=True, null=True)
    tags = models.ManyToManyField(Tag, blank=True, null=True)
    views = models.PositiveIntegerField(default=0)
    created_time = models.DateTimeField(auto_now_add=True)
    modified_time = models.DateTimeField(auto_now=True)

    class Meta:
        ordering = ["-created_time"]
        verbose_name = 'article'
        verbose_name_plural = 'articles'

    def __str__(self):
        return self.title


class Banner(models.Model):
    """幻灯片表"""

    text_info = models.CharField(max_length=50, default='')
    img = models.ImageField(upload_to='banner/')
    link_url = models.URLField(max_length=100)
    is_active = models.BooleanField(default=False)

    def __str__(self):
        return self.text_info

    class Meta:
        verbose_name = 'banner'
        verbose_name_plural = 'banners'

各个参数我就不一一赘述了, 有需要的可以在官方文档查询.

ORM创建后, 要执行命令
python manage.py makemigrations
python manage.py migrate
进行检测和迁移.

Admin管理界面设计

先要创建一个管理员账号python manage.py createsuperuser按照指示注册账号密码.
启动服务器后, 打开浏览器, 转到你本地域名的 “/admin/“ 目录, – 比如 “http://127.0.0.1:8000/admin/“ .你应该会看见管理员登录界面.

需要在你的应用的admin.py文件中注册.
打开blog/admin.py, 键入以下代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

from django.contrib import admin
from .models import Article, Banner, Category, Tag


class TagAdmin(admin.ModelAdmin):
    fields = [
        'name'
    ]


class CategoryAdmin(admin.ModelAdmin):
    fields = [
        'name',
        'index'
    ]


class ArticleAdmin(admin.ModelAdmin):
    # 编辑时分为多个字段集
    fieldsets = [
        ('文章标题', {'fields': ['title']}),
        ('封面', {'fields': ['cover']}),
        ('文章内容', {'fields': ['abstract', 'content']}),
        ('阅读量', {'fields': ['views'], 'classes': ['collapse']}),
    ]

    # 文章列表里显示想要显示的字段
    list_display = ('id', 'title', 'category', 'views', 'created_time')

    # 满50条数据就自动分页
    list_per_page = 50

    # 后台数据列表排序方式
    ordering = ('-created_time',)

    # 设置哪些字段可以点击进入编辑界面
    list_display_links = ('id', 'title')

    # 设置后台查询时用的字段
    search_fields = ['title']

    # 用来过滤字段的过滤器
    list_filter = ['created_time', 'modified_time']


class ArticleInline(admin.StackedInline):
    model = Article
    extra = 2


class BannerAdmin(admin.ModelAdmin):
    # 编辑时的排列顺序
    fields = [
        'text_info',
        'img',
        'link_url',
        'is_active',
        'index'
    ]


admin.site.register(Article, ArticleAdmin)
admin.site.register(Category, CategoryAdmin)
admin.site.register(Tag, TagAdmin)
admin.site.register(Banner, BannerAdmin)

此时后台站点管理的界面是这样的:

添加文章界面是这样的:

URL设计

先打开myblog/urls.py, 键入以下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

from django.contrib import admin
from django.urls import path, re_path, include
from django.conf import settings
from django.views import static

urlpatterns = [
    # 后台站点管理的url
    path('admin/', admin.site.urls),
    # 获取储存图片的url
    re_path(r'^media/(?P<path>.*)$', static.serve,
            {'document_root': settings.MEDIA_ROOT}),
    # blog应用的url
    path('', include('blog.urls'))
]

再在blog应用文件夹中创建urls.py, 键入以下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# blog/urls.py
from django.urls import path

from . import views

app_name = 'blog'
urlpatterns = [
    # 首页的url
    path('', views.index, name='index'),
    # 文章内容的url, 并将文章id传给views
    path('articles/<int:id>/', views.article, name='articles),
    # 同分类文章列表的url, 并将category传给views
    path('categories/<str:category>/', views.category, name='categories'),
    # 同标签文章列表的url, 并将tag传给views
    path('tags/<str:tag>/', views.tag, name='tags'),
    # 搜索文章的url
    path('search/', views.search, name='search'),
]

Views视图函数

打开blog/views.py, 键入以下代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

from django.shortcuts import render
from django.core.paginator import Paginator
from .models import Article, Banner, Category, Tag


# 获取全部页面都有的一些参数, 包括所有分类, 标签和热门文章
def getGlobalParameter():
    categories = Category.objects.all()
    tags = Tag.objects.all()
    hot_articles = Article.objects.order_by('-views')[:5]
    result = {'categories': categories, 'category_link': '/categories/',
              'tags': tags, 'tag_link': '/tags/',
              'hot_articles': hot_articles, 'article_link': '/articles/'}
    return result


# 获取给定文章的基本信息
def getArticlesInfo(articles, has_content=False):
    articles_info = []
    # 所有文章的除内容外的信息
    for article in articles:
        info = {'id': article.id, 'title': article.title, 'cover': article.cover,
                'abstract': article.abstract, 'views': article.views,
                'category': article.category, 'tags': article.tags.all(),
                'created_time': article.created_time,
                'link': '/articles/{}'.format(article.id)
                }
        if has_content:
            info.update({'content': article.content})
        articles_info.append(info)

    return articles_info


# 获取给定文章的分页信息和当前页面的文章
def getPageInfoAndArticles(articles, current_page=1, pages_num=5):
    paginator = Paginator(articles, pages_num)
    if current_page < 0 or current_page > paginator.num_pages:
        current_page = 1
    current_articles = paginator.page(current_page)
    page_info = {'pages': paginator.page_range, 'current': current_page,
                 'has_next': current_articles.has_next(), 'has_previous': current_articles.has_previous}
    return page_info, current_articles


# 首页
def index(request):
    # 获取当前请求的页面
    try:
        current_page = int(request.GET.get(
            "page")) if request.GET.get("page") else 1
    except:
        current_page = 1
    # 获取页面信息和当前页面的文章
    page_info, articles = getPageInfoAndArticles(
        Article.objects.all(), current_page=current_page, pages_num=5)
    # 获取幻灯片
    banners = Banner.objects.filter(is_active=True)
    # 将所有内容传递给模板
    content = {'page_info': page_info,
               'banners': banners, 'articles': getArticlesInfo(articles)}
    content.update(getGlobalParameter())
    return render(request, 'blog/index.html', content)


# 文章内容页
def article(request, id):
    article = Article.objects.get(id=id)
    # 更新该文章阅读数
    article.views += 1
    article.save()
    # 获取包括内容在内的文章信息, 并将文章信息加入content传递给模板
    content = {'article': getArticlesInfo([article], has_content=True)[0]}
    content.update(getGlobalParameter())
    return render(request, 'blog/article.html', content)


def category(request, category):
    # 获取当前请求的页面
    try:
        current_page = int(request.GET.get(
            "page")) if request.GET.get("page") else 1
    except:
        current_page = 1
    # 获取页面信息和当前页面的同类文章
    page_info, articles = getPageInfoAndArticles(
        Article.objects.filter(category__name=category), current_page=current_page, pages_num=5)
    content = {'page_info': page_info, 'articles': getArticlesInfo(articles)}
    content.update(getGlobalParameter())
    return render(request, 'blog/category.html', content)


def tag(request, tag):
    # 获取当前请求的页面
    try:
        current_page = int(request.GET.get(
            "page")) if request.GET.get("page") else 1
    except:
        current_page = 1
    # 获取页面信息和当前页面的同类文章
    page_info, articles = getPageInfoAndArticles(
        Article.objects.filter(tags__name=tag), current_page=current_page, pages_num=5)
    content = {'page_info': page_info, 'articles': getArticlesInfo(articles)}
    content.update(getGlobalParameter())
    return render(request, 'blog/tag.html', content)


def search(request):
    q = request.GET.get('q')  # 获取搜索的关键词q
    try:
        current_page = int(request.GET.get(
            "page")) if request.GET.get("page") else 1
    except:
        current_page = 1
    content = {}
    if q != None:
        # 获取到搜索关键词通过标题进行匹配
        page_info, articles = getPageInfoAndArticles(
            Article.objects.filter(title__icontains=q), current_page=current_page, pages_num=5)
        content = {'q': q,
                   'page_info': page_info,
                   'articles': getArticlesInfo(articles)}
    content.update(getGlobalParameter())
    return render(request, 'blog/search.html', content)

模板搭建

前端模板我是使用的bootstrap前端框架, 技术不够成熟, 只能做个简单演示.

将各个功能分成多个HTML, 最终将其组合起来, 这样有利于修改.
最终首页HTML的实现就非常简单了:

1
2
3
4
5
6
7
8
9
10
11
12
13

{% extends "blog\includes\base.html" %}

{% block banner %}
{% include "blog\includes\banner.html" %}
{% endblock banner %}

{% block article_list %}
{% include "blog\includes\article_list.html" %}
{% endblock article_list%}

{% block pagination %}
{% include "blog\includes\pagination.html" %}
{% endblock pagination %}

其中所有页面都有的界面, 如分类, 热门文章, 标签, 页脚, 都放在了base.html, 其他所有页面都继承自base.html, 并在其界面基础上进行修改, 比如搜索界面, 就加入了搜索框, 并重写了pagination(分页)界面.

各个页面的实现

最终各个页面的成果也出来了:

首页:

分类页面:

标签页面:

文章页面:

搜索页面:

最后再说两句

该博客我已上传到 github , 有需要可以自取 myblog.
关于很多细节方便我没过多说明, 参考文献中的三个文档都有详细说明, 可以在那里面找到.

参考文献

[1] Django3.0官方文档
[2] Django Django教程 Django视频 Django实战 Django开发 - 刘江的Django教程
[3] Django中文网,Django中国,Django中文社区,django教程,Django！

stack()和unstack()

pandas行转列, 列转行, 以及一行生成多行中, 我们主要要用到 stack() 和 unstack() 操作.

DataFrame.stack(self, level=- 1)
stack是将DataFram变为Series, DataFrame的列变成具有多级索引Series的最后一级索引, DataFrame的索引变成具有多级索引Series的其他索引.

DataFrame.unstack(self, level=- 1) / Series.unstack(self, level=- 1)
对于Series来说, unstack()是把最后一级索引变成对应DataFrame的列, 其他索引变成对应DataFrame的索引; 对于DataFrame来说, unstack()是将DataFram变为Series, DataFrame的列变成具有多级索引Series的一级索引, DataFrame的索引变成具有多级索引Series的其他索引.

例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

import pandas as pd


df0 = pd.DataFrame([[80, 85], [92, 90], [88, 78]], index=['小红', '小华', '小明'], columns=['数学', '语文'])
'''df0:
数学语文
小红8085
小华9290
小明8878
'''

# =========================分割线=========================

se1 = df0.unstack(level=-1)
'''se1:
数学    小红    80
        小华    92
        小明    88
语文    小红    85
        小华    90
        小明    78
dtype: int64
'''
# 可以看到df1的列学科变成了se1的一级索引, 索引则会变成se1的其他索引.

df1 = se1.unstack(level=-1)
'''df1
    小红小华小明
数学809288
语文859078
'''
# 可以看到se1的最后一级索引姓名变成了df1的列, 其它索引则会变成df1的索引.

# =========================分割线=========================

se2 = df0.stack(level=-1)
'''se2:
小红    数学    80
        语文    85
小华    数学    92
        语文    90
小明    数学    88
        语文    78
dtype: int64
'''
# 可以看到df1的列索引分数变成了se1的最后一级索引, 其它索引则会变成se1的索引.


df2 = se2.unstack(level=-1)
'''df2:
    数学语文
小红8085
小华9290
小明8878
'''
# 可以看到se2的最后一级索引学科变成了df2的列, 其它索引则会变成df2的索引.

pivot()

DataFrame.pivot(self, index=None, columns=None, values=None)
用来调整DataFrame的索引, 列, 值.

例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import pandas as pd


df = pd.DataFrame({ '姓名':['小红', '小红', '小华', '小华', '小明', '小明'],
                    '科目':['数学', '语文', '数学', '语文', '数学', '语文'],
                    '成绩':[88, 85, 92, 90, 88, 78] })
'''df:
姓名科目成绩
0小红数学88
1小红语文85
2小华数学92
3小华语文90
4小明数学88
5小明语文78
'''

df = df.pivot(index='姓名', columns)
'''df:
科目数学语文
姓名
小华9290
小明8878
小红8885
'''

# 将列名置空, rename_axis()方法是给坐标轴重命名
df = df.rename_axis(columns=None)
'''df:
    数学语文
姓名
小华9290
小明8878
小红8885
'''

# 重新设置索引, 若index变为空的话，那么在reset_index之后，列名会变成index
df = df.reset_index()
'''df:
姓名数学语文
0小华9290
1小明8878
2小红8885
'''

分割value问题

有这样一组数据:

我们想要把它变成下面这样:

先导入数据:

1
2
3
4
5
6
7
8
9

df = pd.DataFrame({ '姓名':['小红', '小华', '小明'],
                    '年龄':[16, 18, 20],
                    '爱好':['跳舞,唱歌,钢琴', '唱,跳,rap,篮球', '古筝,翻译'] })
'''df:
姓名年龄爱好
0小红16跳舞,唱歌,钢琴
1小华18唱,跳,rap,篮球
2小明20古筝,翻译
'''

第一种方法

首先将df的姓名和年龄设置为索引(当前为列名):

1
2
3
4
5
6
7
8

df = df.set_index(["姓名", "年龄"])
'''df:
            爱好
姓名年龄
小红16跳舞,唱歌,钢琴
小华18唱,跳,rap,篮球
小明20古筝,翻译
'''

此时df只有爱好这一列, 再将爱好这列分割:

1
2
3
4
5
6
7
8

df = df["爱好"].str.split(",", expand=True)
'''df:
            0123
姓名年龄
小红16跳舞唱歌钢琴None
小华18唱跳rap篮球
小明20古筝翻译NoneNone
'''

此时字段已经被分割开来, 我们需要将这多列变为一列, 此时我们可以调用 stack(), 将列转变为Series的最后一级索引:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

se = df.stack()
'''se:
姓名  年龄   
小红  16  0     跳舞
        1     唱歌
        2     钢琴
小华  18  0      唱
        1      跳
        2    rap
        3     篮球
小明  20  0     古筝
        1     翻译
dtype: object
'''

此时这个df已经转变为Series, 而此Series的最后一级索引一级没有了作用, 可以直接删掉:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

se = se.reset_index(drop=True, level=-1)
# 这个reset_index因为指定了删除level=-1, 所以只是删除了该Series的最后一级索引, 并没有将该Series转变为DataFrame
'''se:
姓名  年龄
小红  16     跳舞
    16     唱歌
    16     钢琴
小华  18      唱
    18      跳
    18    rap
    18     篮球
小明  20     古筝
    20     翻译
dtype: object
'''

我们再调用一次reset_index(), 将Series的索引转变为DataFrame的列:

1
2
3
4
5
6
7
8
9
10
11
12
13

df = se.reset_index()
'''df:
姓名年龄0
0小红16跳舞
1小红16唱歌
2小红16钢琴
3小华18唱
4小华18跳
5小华18rap
6小华18篮球
7小明20古筝
8小明20翻译
'''

最后再更改一下列名就完成了:

1
2
3
4
5
6
7
8
9
10
11
12
13

df = df.rename(columns={0: "爱好"})
'''python
姓名年龄爱好
0小红16跳舞
1小红16唱歌
2小红16钢琴
3小华18唱
4小华18跳
5小华18rap
6小华18篮球
7小明20古筝
8小明20翻译
'''

第二种方法

使用下面方法, 可以迅速使列表炸裂开.

DataFrame.explode(self, column)

首先我们将数据的”爱好”列转换为列表

1
2
3
4
5
6
7

df["爱好"] = df["爱好"].str.split(",")
'''df:
    姓名年龄爱好
0小红16[跳舞, 唱歌, 钢琴]
1小华18[唱, 跳, rap, 篮球]
2小明20[古筝, 翻译]
'''

再使用该方法, 并指定”爱好”列, 就完成了:

1
2
3
4
5
6
7
8
9
10
11
12
13

df = df.explode("爱好")
'''df:
姓名年龄爱好
0小红16跳舞
0小红16唱歌
0小红16钢琴
1小华18唱
1小华18跳
1小华18rap
1小华18篮球
2小明20古筝
2小明20翻译
'''

参考文献

[1] pandas行转列、列转行、以及一行生成多行 - 古明地盆 - 博客园

策略模式(Strategy Pattern)

什么是策略模式

策略模式定义了算法族, 分别封装起来, 让它们之间可以互相替换, 此模式让算法的变化独立于使用算法的客户.
将内部实现委托给了行为类, 自身并不了解是如何实现的.

tips: 多用组合, 少用继承

python实现策略模式

假设我们有一个订单, 平常是原价, 但是到了节假日有多种打折方式, 我们想要用一个price_after_discount()方法解决所有打折方式.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

class Order:

    def __init__(self, price, discount_strategy=None):
        # 建立订单时必须设定价格, 可以选择折扣方式, 若不选择则为原价
        self.price = price
        self.discount_strategy = discount_strategy

    def set_strategy(self, discount_strategy):
        # 临时更改折扣方式
        self.discount_strategy = discount_strategy

    def price_after_discount(self):
        # 计算价格, 若无折扣, 则按原价, 若有折扣则减去折扣
        if self.discount_strategy:
            discount = self.discount_strategy(self)
        else:
            discount = 0

        # 若折扣超过原价, 则返回0
        return self.price - discount if self.price > discount else 0

    def __str__(self):
        # 格式化tostring()方法
        fmt = "<Price: {}, price after discount: {}>"
        return fmt.format(self.price, self.price_after_discount())


def ten_percent_discount(order):
    # 打九折, 即减去原价的10%
    return order.price * 0.10


def on_sale_discount(order):
    # 打75折再加20的优惠券
    return order.price * 0.25 + 20


print(Order(100))
# 输出结果: <Price: 100, price after discount: 100>
print(Order(100, discount_strategy=ten_percent_discount))
# 输出结果: <Price: 100, price after discount: 90.0>
print(Order(100, discount_strategy=on_sale_discount))
# 输出结果: <Price: 100, price after discount: 55.0>

tips: 针对接口编程, 而不是针对实现编程.

观察者模式(Observer Pattern)

什么是观察者模式

观察者模式–在对象之间定义一对多的依赖, 这样一来, 当一个对象改变状态, 依赖它的对象都会收到通知并自动更新.

python实现观察者模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122