小马哥博客

01-为什么学Docker？告别"在我电脑上能运行"的魔咒

Sat, 21 Feb 2026 00:00:00 +0000

别再被"环境配置"折磨了

说实话，你是不是也有过这些瞬间：

开发环境运行好好的，部署到服务器就崩了
换台电脑重新配置环境要花一整天
团队开发时，每个人环境都不一样，bug复现都困难
服务器上同时运行多个项目，依赖包冲突到爆炸

别再假装这些问题是"正常"的了，用Docker吧！

为什么是Docker？不是虚拟机？

先说说虚拟机（Virtual Machine, VM）：

模拟一整台电脑，有自己的操作系统
启动慢，占用资源多（几个G的内存）
性能损耗大，毕竟是"虚拟"出来的

而Docker容器：

共享宿主机的操作系统内核，不需要完整的系统
启动快（秒级启动），占用资源少（几MB）
性能接近原生应用

打个比方：

虚拟机就像租一整栋房子，虽然自由但太浪费
Docker就像住精装公寓，该有的都有还省空间

Docker能帮你解决什么问题？

痛点	Docker解决方案	效果
环境不一致	镜像打包环境	任何地方都能运行
依赖包冲突	容器隔离	每个项目独立环境
部署复杂	一键启动	30秒部署完成
资源浪费	共享内核	节省80%内存
版本管理	镜像标签	轻松切换版本

Docker的核心概念（先混个脸熟）

别被这些术语吓到，它们其实很好理解：

1. 镜像（Image）

镜像就是一个"打包好的程序包"，包含了：

运行程序需要的所有文件（代码、依赖、配置）
运行环境（操作系统、运行时库）

类比：镜像就像一个"模板"或者"食谱"，根据这个模板可以创建出很多相同的实例。

2. 容器（Container）

容器就是镜像运行起来的实例，一个镜像可以启动多个容器。

类比：镜像是"蛋糕模子"，容器是"做出来的蛋糕"。同一个模子可以做多个蛋糕，每个蛋糕都是独立的。

3. 仓库（Registry）

仓库就是存放镜像的地方，官方仓库叫Docker Hub。

类比：仓库就像"菜市场"或者"应用商店"，里面有各种现成的镜像供你下载使用。

Docker的工作原理

技术原理大白话版本：

Linux容器技术（LXC）：Docker利用Linux内核的特性（namespaces、cgroups）实现进程隔离
- Namespace：给进程创建独立的"视野"，让它以为自己独占系统
- Cgroups：限制进程能用的资源（CPU、内存、磁盘）
分层存储：镜像采用分层结构，每层都是只读的
- 多个镜像可以共享相同的层，节省空间
- 容器启动时在镜像最上层添加一个可写层
UnionFS（联合文件系统）：把多个目录"联合"成一个文件系统
- 看起来是一个完整的系统，实际上是由多个层叠加而成

简单理解：Docker用Linux内核的能力，让程序以为自己运行在一个独立的系统里，但实际上共享了宿主机的资源。

Docker vs 虚拟机对比

特性	Docker容器	虚拟机
启动时间	秒级	分钟级
内存占用	几MB	几GB
磁盘占用	几十MB	几GB
隔离性	进程级隔离	系统级隔离
性能	接近原生	有损耗
安全性	相对较低	较高

真实场景示例

场景1：Python项目部署

传统方式：

1. 安装Python 3.9
2. pip install 各种依赖包
3. 配置环境变量
4. 遇到版本冲突，各种排查
5. 换台电脑重来一遍...

Docker方式：

docker run -d -p 8000:8000 my-python-app
# 完成！

场景2：多版本共存

问题：项目A需要Python 3.8，项目B需要Python 3.11

传统方式：安装多个Python版本，用虚拟环境隔离，容易混乱

Docker方式：

# 项目A
docker run -d python:3.8 python app_a.py

# 项目B
docker run -d python:3.11 python app_b.py
# 互不干扰！

场景3：团队协作

问题：新同事入职，配置环境要花一天

02-Docker快速入门-10分钟理解容器

Sat, 21 Feb 2026 00:00:00 +0000

10分钟看懂Docker核心概念

别急着想复杂的概念，我们先通过一个简单的例子理解Docker。

一个最简单的例子

想象你要开一家咖啡店：

传统部署方式

每开一家分店都要：

找房子（服务器）
装修（安装操作系统、依赖环境）
买设备（安装软件）
招人培训（配置环境）
开业（部署应用）

每家店都要从头开始，而且每家店的装修、设备可能都不一样，导致咖啡品质不一致。

Docker方式

先在一个地方把一切都准备好：

做一个标准化的"店铺模板"（镜像）
包含所有的装修、设备、配方
要开新店时，直接复制这个模板（容器）
瞬间开业

每家店都一模一样，品质完全一致。

Docker的三大核心概念

1. 镜像（Image）

镜像是一个只读的"模板"，包含：

应用程序代码
运行环境（操作系统、运行时库）
依赖文件
配置参数

镜像的特点：

只读：创建后不能修改
分层：由多层叠加而成
可复用：可以基于已有镜像创建新镜像

常见镜像：

nginx：Web服务器
python：Python运行环境
mysql：MySQL数据库
redis：缓存服务

2. 容器（Container）

容器是镜像运行起来的"实例"。

容器的特点：

可以启动、停止、删除
相互隔离，互不影响
可以访问宿主机资源（需要配置）
容器内部修改不会影响镜像

类比：

镜像 = 类（Class）
容器 = 对象（Object）
一个类可以创建多个对象，一个镜像可以启动多个容器

3. 仓库（Registry）

仓库是存放镜像的地方，类似代码仓库（如GitHub）。

常见仓库：

Docker Hub：官方公共仓库（https://hub.docker.com）
阿里云镜像加速器：国内访问更快
私有仓库：企业内部使用

镜像命名规范：

仓库地址/组织名/镜像名:标签

例如：
docker.io/library/nginx:latest
registry.cn-hangzhou.aliyuncs.com/library/nginx:latest
nginx:latest  # 省略仓库地址，默认用Docker Hub

Docker的工作流程

┌─────────────┐    拉取/构建    ┌──────────────┐
│  Dockerfile │ ────────────> │    镜像      │
└─────────────┘              └──────────────┘
                                  │
                            启动容器
                                  ↓
                            ┌──────────────┐
                            │    容器      │
                            │ (运行中的应用)│
                            └──────────────┘

流程说明：

编写Dockerfile：定义如何构建镜像
构建镜像：根据Dockerfile创建镜像
推送/拉取：把镜像推送到仓库或从仓库拉取
启动容器：基于镜像运行容器

第一个Docker容器

让我们运行一个真正的容器：

# 运行一个nginx容器
docker run -d -p 80:80 --name my-web nginx

命令解析：

docker run：运行容器的命令
-d：后台运行（detach）
-p 80:80：端口映射（宿主机80 -> 容器80）
--name my-web：给容器起个名字
nginx：使用的镜像名称

验证：

打开浏览器访问 http://localhost
你会看到nginx的欢迎页面！

查看容器：

# 查看运行中的容器
docker ps

# 查看所有容器（包括停止的）
docker ps -a

容器的生命周期

创建 ──> 启动 ──> 运行中 ──> 停止 ──> 删除
   ↑        ↓        ↓        ↓        ↓
   └────────────────┴────────────────┘
         任意状态都可以重启

常用操作：

03-Docker安装配置-30分钟搞定

Sat, 21 Feb 2026 00:00:00 +0000

第一次装Docker别翻车

很多人第一步就放弃了，因为装软件装崩了。别慌，我带你一步步来，保证你30分钟内搞定。

Windows用户看这里

方案1：Docker Desktop（推荐）

下载地址：https://www.docker.com/products/docker-desktop

Docker Desktop是最方便的方式，包含了：

Docker Engine
Docker Compose
图形化管理界面

安装步骤：

下载安装包并双击运行
勾选"Use WSL 2 instead of Hyper-V"（推荐）
点击"OK"开始安装
安装完成后重启电脑

验证安装：

打开PowerShell，输入：

docker --version

如果看到类似 Docker version 24.0.x，恭喜你，安装成功！

再输入：

docker run hello-world

看到 “Hello from Docker!” 就说明Docker能正常工作了。

方案2：使用WSL 2（进阶）

如果你用WSL 2开发，可以直接在WSL里安装Docker：

确保WSL 2已启用
在WSL 2中执行：

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

启动Docker服务：

sudo service docker start

配置国内镜像加速器

重要：Docker Hub在国外，不配置镜像加速器会很慢。

打开Docker Desktop
进入设置（Settings）-> Docker Engine
添加以下配置：

{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "https://hub-mirror.c.163.com"
  ]
}

点击"Apply & Restart"

Mac用户看这里

方案1：Docker Desktop for Mac（推荐）

下载地址：https://www.docker.com/products/docker-desktop

安装步骤：

下载.dmg文件并双击
把Docker拖到Applications文件夹
打开Docker Desktop
输入管理员密码

验证安装：

docker --version
docker run hello-world

方案2：Homebrew安装（开发者首选）

# 安装Docker Desktop
brew install --cask docker

或者直接用命令行安装Docker Engine：

brew install docker
brew install docker-compose

配置国内镜像加速器

打开Docker Desktop
进入Preferences -> Docker Engine
添加镜像配置：

{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "https://hub-mirror.c.163.com"
  ]
}

点击"Apply & Restart"

Linux用户看这里

Ubuntu/Debian系统

# 1. 更新软件包索引
sudo apt-get update

# 2. 安装依赖
sudo apt-get install \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

# 3. 添加Docker的官方GPG密钥
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

# 4. 设置仓库
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 5. 安装Docker Engine
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# 6. 验证安装
sudo docker run hello-world

CentOS/RHEL系统

# 1. 安装yum-utils
sudo yum install -y yum-utils

# 2. 添加Docker仓库
sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

# 3. 安装Docker
sudo yum install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# 4. 启动Docker
sudo systemctl start docker

# 5. 设置开机自启
sudo systemctl enable docker

# 6. 验证安装
sudo docker run hello-world

配置国内镜像加速器

编辑 /etc/docker/daemon.json：

04-镜像操作-理解Docker的"蓝图"

Sat, 21 Feb 2026 00:00:00 +0000

镜像是Docker的核心

前几章我们说镜像是一个"模板"，现在深入理解一下：镜像是Docker的核心，没有镜像就没有容器。

镜像的基本操作

1. 拉取镜像

从仓库下载镜像到本地：

# 基本用法
docker pull 镜像名

# 示例
docker pull nginx
docker pull python:3.11
docker pull mysql:8.0

镜像标签（Tag）：

nginx：默认使用latest标签
nginx:1.24：指定版本1.24
python:3.11-alpine：使用alpine基础镜像（体积更小）

常用镜像源：

Docker Hub（默认）：nginx
阿里云：registry.cn-hangzhou.aliyuncs.com/library/nginx

2. 查看本地镜像

# 列出所有镜像
docker images

# 只显示镜像ID
docker images -q

# 显示完整的镜像信息（包括层信息）
docker images --digests

输出说明：

REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
nginx         latest    123456789abc   2 weeks ago    142MB
python        3.11      abcdef123456   3 days ago     1GB
mysql         8.0       123abc456def   1 month ago    542MB

REPOSITORY：镜像名称
TAG：标签（版本）
IMAGE ID：镜像唯一标识
CREATED：创建时间
SIZE：镜像大小

3. 删除镜像

# 删除指定镜像
docker rmi 镜像名

# 删除多个镜像
docker rmi nginx nginx:1.24 python:3.11

# 删除所有镜像（慎用）
docker rmi $(docker images -q)

# 强制删除镜像（即使有容器在使用）
docker rmi -f nginx

注意：删除镜像前要先删除基于这个镜像的容器。

4. 查看镜像详细信息

# 查看镜像详细信息
docker inspect 镜像名

# 查看镜像的层信息
docker history 镜像名

镜像的分层原理

什么是分层？

Docker镜像由多个只读层叠加而成，每层代表镜像构建的一个步骤：

┌────────────────────┐
│  应用层（你的代码）  │  ← 这层最小
├────────────────────┤
│   依赖包层         │
├────────────────────┤
│   运行环境层       │
├────────────────────┤
│   基础系统层       │  ← 这层最大
└────────────────────┘

分层的好处

1. 节省空间： 多个镜像可以共享相同的层，例如：

05-容器操作-运行你的第一个程序

Sat, 21 Feb 2026 00:00:00 +0000

容器是镜像的运行实例

前几章我们说镜像是"模板"，容器就是"根据模板做出来的实例"。今天深入学习容器的操作。

容器的生命周期

┌─────────┐   create    ┌─────────┐
│   创建   │ ────────>  │  启动   │
└─────────┘            └────┬────┘
                            │
                         start
                            ↓
┌─────────┐   restart   ┌────┴────┐
│  停止   │ <────────── │  运行中  │
└────┬────┘             └─────────┘
     │
  kill/stop
     ↓
┌─────────┐   rm       ┌─────────┐
│  删除   │ ────────>  │  已结束  │
└─────────┘            └─────────┘

创建和启动容器

docker run 详解

docker run 是最常用的命令，它包含了创建和启动两个步骤：

docker run [选项] 镜像 [命令] [参数]

常用选项

后台运行

# -d, --detach
docker run -d nginx

端口映射

# -p 宿主机端口:容器端口
docker run -d -p 8080:80 nginx

# 多个端口
docker run -d -p 80:80 -p 443:443 nginx

# 随机端口
docker run -d -P nginx

容器名称

# --name 给容器起名
docker run -d --name my-nginx nginx

为什么建议给容器起名？

方便管理（不用记容器ID）
容器重启后名称不变
其他容器可以通过名称访问

环境变量

# -e, --env 设置环境变量
docker run -d -e MYSQL_ROOT_PASSWORD=123456 mysql

# 多个环境变量
docker run -d -e TZ=Asia/Shanghai -e LANG=C.UTF-8 nginx

# 从文件读取
cat > env.txt << 'EOF'
TZ=Asia/Shanghai
LANG=C.UTF-8
EOF
docker run -d --env-file env.txt nginx

数据卷挂载

# -v 宿主机路径:容器路径
docker run -d -v /data/nginx:/usr/share/nginx/html nginx

# 只读挂载
docker run -d -v /data:/data:ro nginx

# 命名卷
docker run -d -v mydata:/data nginx

工作目录

# -w, --workdir 设置工作目录
docker run -d -w /app python:3.11 python app.py

用户

# -u, --user 指定运行用户
docker run -d -u 1000:1000 nginx

资源限制

# 限制内存
docker run -d -m 512m nginx

# 限制CPU（使用0.5个核心）
docker run -d --cpus 0.5 nginx

# 组合限制
docker run -d -m 512m --cpus 1 nginx

自动重启

# --restart=always 容器退出后自动重启
docker run -d --restart=always nginx

# --restart=on-failure 只在失败时重启
docker run -d --restart=on-failure:3 nginx

# --restart=unless-stopped 除非手动停止，否则自动重启
docker run -d --restart=unless-stopped nginx

交互式运行

# -i, --interactive 保持标准输入打开
# -t, --tty 分配一个伪终端
docker run -it ubuntu bash

# 示例：进入Python交互环境
docker run -it python:3.11 python

清理容器

# --rm 容器退出后自动删除
docker run --rm nginx

查看容器

查看运行中的容器

docker ps

# 只显示容器ID
docker ps -q

# 显示完整信息（包括停止的）
docker ps -a

# 显示最后创建的容器
docker ps -l

# 显示最近N个容器
docker ps -n 5

输出说明：

06-Dockerfile-编写自己的镜像

Sat, 21 Feb 2026 00:00:00 +0000

Dockerfile是镜像的"配方"

前几章我们用现成的镜像，今天学习如何编写Dockerfile，创建自己的镜像。

什么是Dockerfile？

Dockerfile是一个文本文件，包含一系列指令，用于构建Docker镜像。

类比：

Dockerfile = 烹饪食谱
镜像 = 做好的菜
容器 = 端上桌的菜

Dockerfile基础语法

基本结构

# 注释以#开头
FROM ubuntu:20.04
RUN apt-get update
CMD ["echo", "Hello, Docker!"]

指令执行顺序

Docker会按照从上到下的顺序执行指令，每执行一条指令就会创建一个新的镜像层。

常用指令详解

1. FROM - 基础镜像

# 基本用法
FROM python:3.11
FROM ubuntu:20.04

# 多阶段构建的第一阶段
FROM python:3.11 AS builder

选择基础镜像的原则：

官方镜像优先：python、node、nginx等
版本明确：python:3.11.7 比 python:3.11 更明确
体积要小：使用alpine或slim版本
安全可靠：优先使用经过安全审计的镜像

常用基础镜像：

alpine：最轻量（5MB）
slim：比完整版小很多
latest：最新版（生产环境不推荐）

2. LABEL - 镜像元数据

LABEL maintainer="yourname@example.com"
LABEL version="1.0"
LABEL description="My awesome application"

查看镜像标签：

docker inspect myapp | grep Labels

3. RUN - 执行命令

# Shell形式（默认）
RUN apt-get update && apt-get install -y curl

# Exec形式（推荐）
RUN ["apt-get", "update"]
RUN ["apt-get", "install", "-y", "curl"]

# 组合多个命令（减少层数）
RUN apt-get update && \
    apt-get install -y \
    curl \
    wget \
    vim && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

优化建议：

合并RUN指令（减少层数）
清理缓存（减小镜像体积）
使用 --no-cache-dir（Python）
使用 && 连接命令

4. COPY - 复制文件

# 复制文件
COPY requirements.txt /app/

# 复制目录
COPY . /app/

# 使用--from从其他阶段复制（多阶段构建）
COPY --from=builder /app/dist /app/

COPY vs ADD的区别：

07-数据持久化-容器里数据不丢失

Sat, 21 Feb 2026 00:00:00 +0000

容器删除，数据还在吗？

问题：容器默认的文件系统是临时的，容器删除后，所有数据都会丢失。

场景：

运行一个MySQL数据库，插入了大量数据
删除容器重新创建
数据全部丢失！

解决：使用数据卷（Volume）实现数据持久化。

数据卷（Volume）

什么是数据卷？

数据卷是Docker管理的数据存储机制，独立于容器生命周期。

特点：

独立于容器，容器删除后数据还在
可以在容器之间共享
性能好（直接读写宿主机文件系统）
备份和迁移方便

基本操作

1. 创建数据卷

# 创建数据卷
docker volume create my-data

# 查看数据卷
docker volume ls

# 查看数据卷详细信息
docker volume inspect my-data

输出示例：

[
    {
        "CreatedAt": "2023-01-01T00:00:00Z",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/my-data/_data",
        "Name": "my-data",
        "Options": {},
        "Scope": "local"
    }
]

Mountpoint：数据卷在宿主机的实际路径

2. 使用数据卷运行容器

# 挂载数据卷
docker run -d -v my-data:/data nginx

# 多个数据卷
docker run -d \
  -v mysql-data:/var/lib/mysql \
  -v mysql-logs:/var/log/mysql \
  mysql:8.0

3. 查看数据卷

# 列出所有数据卷
docker volume ls

# 查看数据卷详细信息
docker volume inspect my-data

# 查看数据卷内容
sudo ls /var/lib/docker/volumes/my-data/_data

4. 删除数据卷

# 删除未使用的数据卷
docker volume prune

# 删除指定数据卷
docker volume rm my-data

# 删除容器时同时删除数据卷（慎用）
docker rm -v my-container

注意：删除数据卷会永久删除数据，无法恢复！

绑定挂载（Bind Mount）

什么是绑定挂载？

将宿主机的目录或文件挂载到容器中。

特点：

直接映射宿主机文件系统
适合开发环境（实时同步代码）
需要处理权限问题

基本用法

# 挂载宿主机目录到容器
docker run -d -v /path/on/host:/path/in/container nginx

# 相对路径（相对于当前目录）
docker run -d -v $(pwd)/html:/usr/share/nginx/html nginx

# 挂载单个文件
docker run -d -v $(pwd)/nginx.conf:/etc/nginx/nginx.conf nginx

读写权限

# 读写（默认）
docker run -d -v /data:/app nginx

# 只读
docker run -d -v /data:/app:ro nginx

# 读写+指定用户
docker run -d -v /data:/app:ro -u 1000:1000 nginx

实战：同步开发代码

# 项目目录
cd my-flask-app

# 挂载当前目录到容器
docker run -d -p 8000:8000 -v $(pwd):/app python:3.11 \
  python -u /app/app.py

修改代码后，容器内立即生效！

08-网络管理-让容器之间互相通信

Sat, 21 Feb 2026 00:00:00 +0000

容器之间怎么通信？

问题：默认情况下，容器之间是隔离的，无法直接访问。

场景：

Web应用容器需要访问数据库容器
多个微服务容器需要互相调用
外部需要访问容器内的服务

解决：使用Docker网络实现容器间通信。

Docker网络基础

网络类型

1. bridge（桥接网络，默认）

特点：

默认网络类型
每个容器分配独立IP
容器通过bridge互相通信
通过端口映射对外暴露服务

原理：

宿主机
    │
    ├── docker0（虚拟网桥）
    │       │
    │       ├── 容器A (172.17.0.2)
    │       ├── 容器B (172.17.0.3)
    │       └── 容器C (172.17.0.4)

2. host（主机网络）

特点：

容器使用宿主机网络栈
没有网络隔离
性能最好
不需要端口映射

使用场景：

高性能应用
需要直接访问宿主机网络

docker run --network=host nginx

3. none（无网络）

特点：

容器没有网络
完全隔离
适合不需要网络的应用

docker run --network=none alpine sleep 3600

4. overlay（覆盖网络）

特点：

跨主机容器通信
需要Swarm或Kubernetes
生产环境常用

使用场景：

分布式应用
微服务架构

网络基本操作

1. 查看网络

# 列出所有网络
docker network ls

# 查看网络详细信息
docker network inspect bridge

# 查看网络中的容器
docker network inspect bridge | grep -A 10 Containers

输出示例：

NETWORK ID     NAME      DRIVER    SCOPE
a1b2c3d4e5f6   bridge    bridge    local
abc123def456   host      host      local
123abc456def   none      null      local

2. 创建网络

# 创建bridge网络
docker network create my-network

# 创建自定义bridge网络（指定子网）
docker network create \
  --driver=bridge \
  --subnet=172.20.0.0/16 \
  --ip-range=172.20.10.0/24 \
  --gateway=172.20.10.1 \
  my-custom-network

# 创建overlay网络（Swarm集群）
docker network create --driver=overlay my-overlay-network

3. 删除网络

# 删除网络
docker network rm my-network

# 删除未使用的网络
docker network prune

4. 连接容器到网络

# 运行容器时指定网络
docker run -d --network=bridge --name myapp nginx

# 将已有容器连接到网络
docker network connect my-network myapp

# 断开容器与网络的连接
docker network disconnect my-network myapp

# 连接时指定别名
docker network connect --alias web my-network myapp

容器间通信

场景1：同一网络中的容器通信

# 1. 创建网络
docker network create app-network

# 2. 运行Web应用容器
docker run -d \
  --network=app-network \
  --name webapp \
  nginx

# 3. 运行数据库容器
docker run -d \
  --network=app-network \
  --name db \
  -e MYSQL_ROOT_PASSWORD=123456 \
  mysql:8.0

# 4. Web应用可以直接通过名称访问数据库
docker exec webapp ping db
docker exec webapp nc -zv db 3306

关键点：

09-Docker Compose-一键启动多个服务

Sat, 21 Feb 2026 00:00:00 +0000

一个命令启动整个项目？

问题：一个完整的Web应用通常需要多个服务：

Web服务器
数据库
缓存
消息队列

传统方式：

docker run -d --name web -p 80:80 nginx
docker run -d --name db -e MYSQL_ROOT_PASSWORD=123456 mysql:8.0
docker run -d --name cache redis
...

Docker Compose方式：

docker-compose up -d
# 一键启动所有服务！

什么是Docker Compose？

定义：Docker Compose是用于定义和运行多容器Docker应用的工具。

特点：

使用YAML文件定义服务
一条命令启动/停止所有服务
自动创建和管理网络
服务之间通过名称互相访问
支持环境变量和配置文件

安装：

# Linux安装
sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

# Docker Desktop自带
# Windows和Mac用户无需单独安装

验证安装：

docker-compose --version

docker-compose.yml基本结构

最简单的示例

version: '3.8'

services:
  web:
    image: nginx
    ports:
      - "80:80"

解释：

version：Compose文件版本
services：定义服务
web：服务名称
image：使用的镜像
ports：端口映射

完整示例

version: '3.8'

services:
  web:
    image: nginx:latest
    container_name: my-web
    ports:
      - "8080:80"
    volumes:
      - ./html:/usr/share/nginx/html
      - ./nginx.conf:/etc/nginx/nginx.conf
    networks:
      - app-network
    environment:
      - TZ=Asia/Shanghai
    restart: unless-stopped

  db:
    image: mysql:8.0
    container_name: my-db
    environment:
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: mydb
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - app-network
    restart: unless-stopped

  cache:
    image: redis:alpine
    container_name: my-cache
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
    networks:
      - app-network
    restart: unless-stopped

networks:
  app-network:
    driver: bridge

volumes:
  mysql-data:
  redis-data:

常用配置项

1. image - 镜像

services:
  web:
    image: nginx:latest
  app:
    image: myapp:v1.0

2. build - 构建镜像

services:
  app:
    build: .
    # 或
    build:
      context: .
      dockerfile: Dockerfile
      args:
        VERSION: 1.0

3. ports - 端口映射

services:
  web:
    ports:
      - "80:80"              # 宿主机80映射到容器80
      - "443:443"
      - "8000-8010:8000-8010"  # 端口范围
      - "127.0.0.1:8080:80"    # 只绑定localhost

4. volumes - 数据卷

services:
  db:
    volumes:
      - db-data:/var/lib/mysql      # 命名卷
      - ./data:/data                 # 绑定挂载
      - /etc/localtime:/etc/localtime:ro  # 只读挂载

volumes:
  db-data:

5. environment - 环境变量

services:
  db:
    environment:
      - MYSQL_ROOT_PASSWORD=123456
      - MYSQL_DATABASE=mydb
      # 或
      MYSQL_ROOT_PASSWORD: 123456
      MYSQL_DATABASE: mydb

6. env_file - 环境变量文件

services:
  app:
    env_file:
      - .env
      - .env.prod

.env文件内容：

10-实战项目1-Python项目打包部署

Sat, 21 Feb 2026 00:00:00 +0000

用Docker部署Python项目

今天我们来做第一个实战项目：把一个Python Web应用打包成Docker镜像并部署。

项目背景

假设我们有一个Flask Web应用：

提供RESTful API
使用MySQL数据库
使用Redis缓存
需要持久化数据

项目结构

my-flask-app/
├── app.py              # Flask应用主文件
├── requirements.txt    # Python依赖
├── Dockerfile         # Docker镜像定义
├── docker-compose.yml # 多容器编排
├── .env              # 环境变量
├── .dockerignore     # Docker忽略文件
└── data/            # 本地数据目录（可选）

1. 创建Flask应用

app.py

from flask import Flask, jsonify, request
from flask_cors import CORS
import os
import mysql.connector
import redis
import datetime

app = Flask(__name__)
CORS(app)

# 数据库配置
db_config = {
    'host': os.getenv('DB_HOST', 'localhost'),
    'user': os.getenv('DB_USER', 'root'),
    'password': os.getenv('DB_PASSWORD', '123456'),
    'database': os.getenv('DB_NAME', 'mydb')
}

# Redis配置
redis_config = {
    'host': os.getenv('REDIS_HOST', 'localhost'),
    'port': int(os.getenv('REDIS_PORT', 6379)),
    'db': 0
}

def get_db_connection():
    """获取数据库连接"""
    return mysql.connector.connect(**db_config)

def get_redis_connection():
    """获取Redis连接"""
    return redis.Redis(**redis_config)

@app.route('/')
def index():
    """首页"""
    return jsonify({
        'message': 'Welcome to Flask API',
        'version': '1.0',
        'timestamp': datetime.datetime.now().isoformat()
    })

@app.route('/health')
def health():
    """健康检查"""
    try:
        # 检查数据库
        conn = get_db_connection()
        cursor = conn.cursor()
        cursor.execute("SELECT 1")
        cursor.close()
        conn.close()

        # 检查Redis
        r = get_redis_connection()
        r.ping()

        return jsonify({'status': 'healthy', 'checks': {'db': 'ok', 'redis': 'ok'}})
    except Exception as e:
        return jsonify({'status': 'unhealthy', 'error': str(e)}), 500

@app.route('/users', methods=['GET'])
def get_users():
    """获取所有用户"""
    try:
        # 先从Redis缓存获取
        r = get_redis_connection()
        cached = r.get('users')

        if cached:
            return jsonify({'source': 'cache', 'data': eval(cached)})

        # 缓存未命中，从数据库获取
        conn = get_db_connection()
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT * FROM users")
        users = cursor.fetchall()
        cursor.close()
        conn.close()

        # 写入缓存，有效期300秒
        r.setex('users', 300, str(users))

        return jsonify({'source': 'database', 'data': users})

    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/users', methods=['POST'])
def create_user():
    """创建用户"""
    try:
        data = request.json
        name = data.get('name')
        email = data.get('email')

        if not name or not email:
            return jsonify({'error': 'Name and email are required'}), 400

        conn = get_db_connection()
        cursor = conn.cursor()
        cursor.execute(
            "INSERT INTO users (name, email) VALUES (%s, %s)",
            (name, email)
        )
        conn.commit()
        user_id = cursor.lastrowid
        cursor.close()
        conn.close()

        # 清除缓存
        r = get_redis_connection()
        r.delete('users')

        return jsonify({'id': user_id, 'name': name, 'email': email}), 201

    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    """获取单个用户"""
    try:
        conn = get_db_connection()
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
        user = cursor.fetchone()
        cursor.close()
        conn.close()

        if not user:
            return jsonify({'error': 'User not found'}), 404

        return jsonify(user)

    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8000, debug=os.getenv('DEBUG', 'False') == 'True')

2. 依赖文件

requirements.txt

flask==2.3.0
flask-cors==4.0.0
mysql-connector-python==8.1.0
redis==4.6.0
gunicorn==21.2.0

3. Docker镜像定义

Dockerfile

# 多阶段构建

# 构建阶段
FROM python:3.11-slim AS builder

WORKDIR /app

# 安装系统依赖
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
    gcc \
    default-libmysqlclient-dev \
    pkg-config \
    && rm -rf /var/lib/apt/lists/*

# 只复制依赖文件（利用构建缓存）
COPY requirements.txt .

# 安装Python依赖
RUN pip install --no-cache-dir -r requirements.txt

# 运行阶段
FROM python:3.11-slim

WORKDIR /app

# 复制依赖
COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
COPY --from=builder /usr/local/bin /usr/local/bin

# 复制应用代码
COPY . .

# 创建非root用户
RUN groupadd -r appuser && useradd -r -g appuser appuser
RUN chown -R appuser:appuser /app
USER appuser

# 设置环境变量
ENV PYTHONUNBUFFERED=1
ENV TZ=Asia/Shanghai

# 暴露端口
EXPOSE 8000

# 健康检查
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
    CMD python -c "import requests; requests.get('http://localhost:8000/health')" || exit 1

# 启动命令
CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:8000", "--timeout", "120", "app:app"]

.dockerignore

# Git文件
.git
.gitignore

# Python缓存
__pycache__
*.py[cod]
*$py.class
*.so
.Python

# 虚拟环境
venv/
env/
ENV/
.venv

# IDE配置
.vscode/
.idea/
*.swp
*.swo

# 日志文件
*.log
logs/

# 环境变量
.env

# 测试文件
tests/
.pytest_cache/
.coverage

# 文档
docs/
*.md

4. 多容器编排

docker-compose.yml

version: '3.8'

services:
  # Flask应用
  app:
    build: .
    container_name: flask-app
    ports:
      - "${APP_PORT:-8000}:8000"
    environment:
      - DB_HOST=db
      - DB_USER=root
      - DB_PASSWORD=${DB_PASSWORD:-123456}
      - DB_NAME=${DB_NAME:-mydb}
      - REDIS_HOST=redis
      - REDIS_PORT=6379
      - DEBUG=${DEBUG:-False}
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - app-network
    restart: unless-stopped

  # MySQL数据库
  db:
    image: mysql:8.0
    container_name: mysql-db
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD:-123456}
      MYSQL_DATABASE: ${DB_NAME:-mydb}
    volumes:
      - mysql-data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "${DB_PORT:-3306}:3306"
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-uroot", "-p${DB_PASSWORD:-123456}"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s
    restart: unless-stopped

  # Redis缓存
  redis:
    image: redis:7-alpine
    container_name: redis-cache
    ports:
      - "${REDIS_PORT:-6379}:6379"
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 3
    restart: unless-stopped

networks:
  app-network:
    driver: bridge

volumes:
  mysql-data:
  redis-data:

init.sql（数据库初始化脚本）

-- 创建用户表
CREATE TABLE IF NOT EXISTS users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 插入测试数据
INSERT INTO users (name, email) VALUES
('Alice', 'alice@example.com'),
('Bob', 'bob@example.com'),
('Charlie', 'charlie@example.com');

.env（环境变量文件）

# 应用配置
APP_PORT=8000
DEBUG=False

# 数据库配置
DB_PASSWORD=123456
DB_NAME=mydb
DB_PORT=3306

# Redis配置
REDIS_PORT=6379

5. 技术原理解释

为什么用Docker？

问题1：环境一致性

11-实战项目2-Web应用完整部署

Sat, 21 Feb 2026 00:00:00 +0000

完整的Web应用部署方案

上一章我们部署了Python后端API，今天我们来做前后端分离的完整Web应用部署。

项目架构

┌─────────────────────────────────────────────────────────┐
│                        Nginx                             │
│                    (反向代理 + SSL)                      │
│                     ┌────────┬────────┐                 │
│                     │        │        │                 │
│                     ↓        ↓        ↓                 │
│                  React    Flask     Admin              │
│                  (前端)   (API)   (后台)                │
│                     │        │        │                 │
│                     └────────┴────────┘                 │
│                              ↓                          │
│                    ┌──────────────────┐                 │
│                    │   MySQL + Redis   │                 │
│                    └──────────────────┘                 │
└─────────────────────────────────────────────────────────┘

1. 前端项目（React）

项目结构

frontend/
├── package.json
├── Dockerfile
├── nginx.conf
└── src/
    ├── App.js
    └── index.js

Dockerfile

# 构建阶段
FROM node:18-alpine AS builder

WORKDIR /app

# 复制依赖文件
COPY package.json package-lock.json ./

# 安装依赖
RUN npm ci --only=production

# 复制源代码
COPY . .

# 构建应用
RUN npm run build

# 运行阶段
FROM nginx:alpine

# 复制构建产物
COPY --from=builder /app/build /usr/share/nginx/html

# 复制nginx配置
COPY nginx.conf /etc/nginx/conf.d/default.conf

# 暴露端口
EXPOSE 80

# 启动nginx
CMD ["nginx", "-g", "daemon off;"]

nginx.conf

server {
    listen 80;
    server_name localhost;

    root /usr/share/nginx/html;
    index index.html;

    # Gzip压缩
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_types text/plain text/css text/xml text/javascript application/x-javascript application/xml+rss application/json;

    # 路由配置（React Router）
    location / {
        try_files $uri $uri/ /index.html;
    }

    # API代理
    location /api/ {
        proxy_pass http://api:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    # 静态资源缓存
    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg)$ {
        expires 30d;
        add_header Cache-Control "public, immutable";
    }
}

package.json

{
  "name": "frontend",
  "version": "1.0.0",
  "scripts": {
    "start": "react-scripts start",
    "build": "react-scripts build",
    "test": "react-scripts test"
  },
  "dependencies": {
    "react": "^18.2.0",
    "react-dom": "^18.2.0",
    "react-router-dom": "^6.14.0",
    "axios": "^1.4.0"
  },
  "devDependencies": {
    "react-scripts": "5.0.1"
  }
}

2. 后端API（Flask）

项目结构

backend/
├── app.py
├── requirements.txt
└── Dockerfile

Dockerfile

FROM python:3.11-slim

WORKDIR /app

# 安装系统依赖
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
    gcc \
    default-libmysqlclient-dev \
    pkg-config \
    && rm -rf /var/lib/apt/lists/*

# 复制依赖文件
COPY requirements.txt .

# 安装Python依赖
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 创建非root用户
RUN groupadd -r appuser && useradd -r -g appuser appuser
RUN chown -R appuser:appuser /app
USER appuser

# 环境变量
ENV PYTHONUNBUFFERED=1

# 暴露端口
EXPOSE 8000

# 启动命令
CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:8000", "--timeout", "120", "app:app"]

requirements.txt

flask==2.3.0
flask-cors==4.0.0
mysql-connector-python==8.1.0
redis==4.6.0
gunicorn==21.2.0

3. 管理后台（Flask Admin）

项目结构

admin/
├── app.py
├── requirements.txt
└── Dockerfile

Dockerfile

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

RUN groupadd -r admin && useradd -r -g admin admin
RUN chown -R admin:admin /app
USER admin

ENV PYTHONUNBUFFERED=1

EXPOSE 8001

CMD ["gunicorn", "-w", "2", "-b", "0.0.0.0:8001", "app:app"]

requirements.txt

flask==2.3.0
flask-admin==1.6.1
flask-sqlalchemy==3.0.5
mysql-connector-python==8.1.0
gunicorn==21.2.0

4. Nginx反向代理

nginx/nginx.conf

events {
    worker_connections 1024;
}

http {
    # 前端
    upstream frontend {
        server frontend:80;
    }

    # 后端API
    upstream api {
        server api:8000;
    }

    # 管理后台
    upstream admin {
        server admin:8001;
    }

    # 限流配置
    limit_req_zone $binary_remote_addr zone=api_limit:10m rate=10r/s;

    server {
        listen 80;
        server_name example.com www.example.com;

        # SSL重定向
        return 301 https://$server_name$request_uri;
    }

    server {
        listen 443 ssl http2;
        server_name example.com www.example.com;

        # SSL证书配置
        ssl_certificate /etc/nginx/ssl/cert.pem;
        ssl_certificate_key /etc/nginx/ssl/key.pem;

        # SSL优化
        ssl_protocols TLSv1.2 TLSv1.3;
        ssl_ciphers HIGH:!aNULL:!MD5;
        ssl_prefer_server_ciphers on;
        ssl_session_cache shared:SSL:10m;
        ssl_session_timeout 10m;

        # Gzip压缩
        gzip on;
        gzip_vary on;
        gzip_min_length 1024;
        gzip_types text/plain text/css text/xml text/javascript application/x-javascript application/xml+rss application/json;

        # 前端
        location / {
            proxy_pass http://frontend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }

        # API限流
        location /api/ {
            limit_req zone=api_limit burst=20 nodelay;

            proxy_pass http://api;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;

            # 超时配置
            proxy_connect_timeout 60s;
            proxy_send_timeout 60s;
            proxy_read_timeout 60s;
        }

        # 管理后台
        location /admin/ {
            proxy_pass http://admin/;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;

            # IP白名单（可选）
            # allow 192.168.1.0/24;
            # deny all;
        }

        # 日志配置
        access_log /var/log/nginx/access.log;
        error_log /var/log/nginx/error.log;
    }
}

5. Docker Compose编排

docker-compose.yml

version: '3.8'

services:
  # Nginx反向代理
  nginx:
    image: nginx:alpine
    container_name: nginx-proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/ssl:/etc/nginx/ssl
      - nginx-logs:/var/log/nginx
    depends_on:
      - frontend
      - api
      - admin
    networks:
      - app-network
    restart: unless-stopped

  # 前端
  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile
    container_name: frontend-app
    networks:
      - app-network
    restart: unless-stopped

  # 后端API
  api:
    build:
      context: ./backend
      dockerfile: Dockerfile
    container_name: api-server
    environment:
      - DB_HOST=db
      - DB_USER=root
      - DB_PASSWORD=${DB_PASSWORD:-123456}
      - DB_NAME=${DB_NAME:-mydb}
      - REDIS_HOST=redis
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_healthy
    networks:
      - app-network
    restart: unless-stopped

  # 管理后台
  admin:
    build:
      context: ./admin
      dockerfile: Dockerfile
    container_name: admin-panel
    environment:
      - DB_HOST=db
      - DB_USER=root
      - DB_PASSWORD=${DB_PASSWORD:-123456}
      - DB_NAME=${DB_NAME:-mydb}
    depends_on:
      db:
        condition: service_healthy
    networks:
      - app-network
    restart: unless-stopped

  # MySQL数据库
  db:
    image: mysql:8.0
    container_name: mysql-db
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_PASSWORD:-123456}
      MYSQL_DATABASE: ${DB_NAME:-mydb}
    volumes:
      - mysql-data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "${DB_PORT:-3306}:3306"
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-uroot", "-p${DB_PASSWORD:-123456}"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s
    restart: unless-stopped

  # Redis缓存
  redis:
    image: redis:7-alpine
    container_name: redis-cache
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes --requirepass ${REDIS_PASSWORD:-123456}
    ports:
      - "${REDIS_PORT:-6379}:6379"
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD:-123456}", "ping"]
      interval: 10s
      timeout: 5s
      retries: 3
    restart: unless-stopped

networks:
  app-network:
    driver: bridge

volumes:
  mysql-data:
  redis-data:
  nginx-logs:

6. 数据库初始化

init.sql

-- 创建数据库表
USE mydb;

-- 用户表
CREATE TABLE IF NOT EXISTS users (
    id INT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL UNIQUE,
    email VARCHAR(100) NOT NULL UNIQUE,
    password VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 文章表
CREATE TABLE IF NOT EXISTS articles (
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(200) NOT NULL,
    content TEXT,
    author_id INT,
    status ENUM('draft', 'published') DEFAULT 'draft',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (author_id) REFERENCES users(id) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 评论表
CREATE TABLE IF NOT EXISTS comments (
    id INT AUTO_INCREMENT PRIMARY KEY,
    article_id INT,
    user_id INT,
    content TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (article_id) REFERENCES articles(id) ON DELETE CASCADE,
    FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- 插入测试数据
INSERT INTO users (username, email, password) VALUES
('admin', 'admin@example.com', '$2b$12$LQv3c1yqBWVHxkd0LHAkCOYz6TtxMQJqhN8/LewY5GyY6X7yGKJ2i'),
('user1', 'user1@example.com', '$2b$12$LQv3c1yqBWVHxkd0LHAkCOYz6TtxMQJqhN8/LewY5GyY6X7yGKJ2i');

INSERT INTO articles (title, content, author_id, status) VALUES
('第一篇文章', '这是第一篇文章的内容', 1, 'published'),
('第二篇文章', '这是第二篇文章的内容', 1, 'published'),
('草稿文章', '这是一篇草稿', 1, 'draft');

7. 部署和测试

构建和启动

# 构建所有镜像
docker-compose build

# 启动所有服务
docker-compose up -d

# 查看状态
docker-compose ps

# 查看日志
docker-compose logs -f

测试各服务

# 测试前端
curl http://localhost

# 测试API健康检查
curl http://localhost/api/health

# 测试管理后台
curl http://localhost/admin/

# 查看数据库
docker exec -it mysql-db mysql -uroot -p123456 -e "USE mydb; SELECT * FROM users;"

性能测试

# 使用ab进行压力测试
ab -n 1000 -c 100 http://localhost/api/health

# 查看Nginx日志
docker exec nginx-proxy tail -f /var/log/nginx/access.log

8. 监控和日志

安装监控工具

# 添加到docker-compose.yml
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus-data:/prometheus
    ports:
      - "9090:9090"
    networks:
      - app-network

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    volumes:
      - grafana-data:/var/lib/grafana
    ports:
      - "3000:3000"
    networks:
      - app-network

volumes:
  prometheus-data:
  grafana-data:

日志聚合

# 查看所有服务日志
docker-compose logs

# 查看特定服务日志
docker-compose logs -f api

# 导出日志
docker-compose logs --since 24h > logs.txt

9. 备份和恢复

数据库备份

# 备份数据库
docker exec mysql-db mysqldump -uroot -p123456 mydb > backup_$(date +%Y%m%d).sql

# 恢复数据库
docker exec -i mysql-db mysql -uroot -p123456 mydb < backup_20231201.sql

定时备份

# 添加到crontab
0 2 * * * /path/to/backup.sh

# backup.sh内容
#!/bin/bash
BACKUP_DIR="/data/backups"
DATE=$(date +%Y%m%d)
docker exec mysql-db mysqldump -uroot -p123456 mydb > ${BACKUP_DIR}/backup_${DATE}.sql
find ${BACKUP_DIR} -name "backup_*.sql" -mtime +7 -delete

10. SSL证书配置

使用Let’s Encrypt

# 安装certbot
sudo apt-get install certbot

# 获取证书
sudo certbot certonly --standalone -d example.com -d www.example.com

# 复制证书到项目
sudo cp /etc/letsencrypt/live/example.com/fullchain.pem ./nginx/ssl/cert.pem
sudo cp /etc/letsencrypt/live/example.com/privkey.pem ./nginx/ssl/key.pem

本章小结

完整架构：前端 + 后端 + 后台 + 数据库 + 缓存
反向代理：Nginx + SSL + 负载均衡 + 限流
部署方案：Docker Compose一键部署
监控日志：Prometheus + Grafana + 日志聚合
备份恢复：数据库备份 + 定时任务

现在已经掌握了完整Web应用部署，下一章我们来实战微服务架构！

12-实战项目3-多容器微服务部署

Sat, 21 Feb 2026 00:00:00 +0000

微服务架构部署

今天我们实战部署一个微服务架构的应用，包含API网关、多个微服务、数据库、缓存、消息队列等。

微服务架构设计

┌─────────────────────────────────────────────────────────────┐
│                      API Gateway (Nginx)                      │
│              (反向代理 + 负载均衡 + 限流)                     │
│                    ┌─────────┬─────────┬─────────┐            │
│                    │         │         │         │            │
│              ┌─────┴────┐ ┌──┴────┐ ┌──┴────┐ ┌──┴────┐     │
│              │   用户   │ │  订单 │ │ 商品 │ │ 支付 │     │
│              │  服务    │ │ 服务 │ │ 服务 │ │ 服务 │     │
│              └─────┬────┘ └──┬────┘ └──┬────┘ └──┬────┘     │
│                    │         │         │         │            │
│                    └─────────┴─────────┴─────────┘            │
│                              │                               │
│              ┌───────────────┼───────────────┐              │
│              ↓               ↓               ↓              │
│      ┌──────────────┐ ┌──────────────┐ ┌──────────────┐     │
│      │   MySQL      │ │    Redis     │ │   RabbitMQ   │     │
│      │  (主+从)     │ │    集群       │ │  (消息队列)   │     │
│      └──────────────┘ └──────────────┘ └──────────────┘     │
└─────────────────────────────────────────────────────────────┘

1. API网关

nginx/nginx.conf

events {
    worker_connections 2048;
}

http {
    # 限流配置
    limit_req_zone $binary_remote_addr zone=api_limit:10m rate=100r/s;
    limit_conn_zone $binary_remote_addr zone=conn_limit:10m;

    # 负载均衡
    upstream user_service {
        least_conn;
        server user-service-1:8001;
        server user-service-2:8002;
        server user-service-3:8003;
    }

    upstream order_service {
        least_conn;
        server order-service-1:8001;
        server order-service-2:8002;
    }

    upstream product_service {
        least_conn;
        server product-service-1:8001;
        server product-service-2:8002;
    }

    upstream payment_service {
        least_conn;
        server payment-service-1:8001;
    }

    server {
        listen 80;
        server_name api.example.com;

        # 用户服务
        location /api/users {
            limit_req zone=api_limit burst=200 nodelay;
            limit_conn conn_limit 10;

            proxy_pass http://user_service;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Service-Name "user-service";

            # 超时配置
            proxy_connect_timeout 30s;
            proxy_send_timeout 30s;
            proxy_read_timeout 30s;
        }

        # 订单服务
        location /api/orders {
            limit_req zone=api_limit burst=100 nodelay;

            proxy_pass http://order_service;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Service-Name "order-service";
        }

        # 商品服务
        location /api/products {
            limit_req zone=api_limit burst=200 nodelay;

            proxy_pass http://product_service;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Service-Name "product-service";
        }

        # 支付服务
        location /api/payments {
            limit_req zone=api_limit burst=50 nodelay;

            proxy_pass http://payment_service;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Service-Name "payment-service";
        }

        # 健康检查
        location /health {
            access_log off;
            return 200 "OK\n";
            add_header Content-Type text/plain;
        }

        # 日志格式
        access_log /var/log/nginx/access.log combined;
        error_log /var/log/nginx/error.log warn;
    }
}

2. 用户服务

services/user-service/Dockerfile

FROM python:3.11-slim

WORKDIR /app

# 安装依赖
RUN apt-get update && \
    apt-get install -y --no-install-recommends \
    gcc \
    default-libmysqlclient-dev \
    pkg-config \
    && rm -rf /var/lib/apt/lists/*

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

# 创建用户
RUN groupadd -r appuser && useradd -r -g appuser appuser
RUN chown -R appuser:appuser /app
USER appuser

ENV PYTHONUNBUFFERED=1
ENV SERVICE_NAME=user-service

EXPOSE 8001

CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:8001", "app:app"]

services/user-service/app.py

from flask import Flask, jsonify, request
from flask_cors import CORS
import mysql.connector
import redis
import os

app = Flask(__name__)
CORS(app)

# 配置
db_config = {
    'host': os.getenv('DB_HOST', 'mysql-master'),
    'user': os.getenv('DB_USER', 'root'),
    'password': os.getenv('DB_PASSWORD', '123456'),
    'database': os.getenv('DB_NAME', 'users_db')
}

redis_config = {
    'host': os.getenv('REDIS_HOST', 'redis'),
    'port': int(os.getenv('REDIS_PORT', 6379)),
    'db': 0
}

@app.route('/health')
def health():
    return jsonify({'status': 'healthy', 'service': 'user-service'})

@app.route('/users', methods=['GET'])
def get_users():
    try:
        # Redis缓存
        r = redis.Redis(**redis_config)
        cached = r.get('users')
        if cached:
            return jsonify({'source': 'cache', 'data': eval(cached)})

        # 数据库查询
        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT id, username, email FROM users")
        users = cursor.fetchall()
        cursor.close()
        conn.close()

        # 写入缓存
        r.setex('users', 300, str(users))

        return jsonify({'source': 'database', 'data': users})
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/users/<int:user_id>', methods=['GET'])
def get_user(user_id):
    try:
        r = redis.Redis(**redis_config)
        cache_key = f'user:{user_id}'
        cached = r.get(cache_key)

        if cached:
            return jsonify({'source': 'cache', 'data': eval(cached)})

        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
        user = cursor.fetchone()
        cursor.close()
        conn.close()

        if not user:
            return jsonify({'error': 'User not found'}), 404

        r.setex(cache_key, 3600, str(user))

        return jsonify(user)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8001)

3. 订单服务

services/order-service/app.py

from flask import Flask, jsonify, request
import pika
import mysql.connector
import json
import os

app = Flask(__name__)

# 配置
db_config = {
    'host': os.getenv('DB_HOST', 'mysql-master'),
    'user': os.getenv('DB_USER', 'root'),
    'password': os.getenv('DB_PASSWORD', '123456'),
    'database': 'orders_db'
}

# RabbitMQ连接
rabbitmq_config = {
    'host': os.getenv('RABBITMQ_HOST', 'rabbitmq'),
    'port': int(os.getenv('RABBITMQ_PORT', 5672)),
    'user': os.getenv('RABBITMQ_USER', 'guest'),
    'password': os.getenv('RABBITMQ_PASSWORD', 'guest')
}

def send_to_queue(message):
    """发送消息到队列"""
    connection = pika.BlockingConnection(
        pika.ConnectionParameters(**rabbitmq_config)
    )
    channel = connection.channel()
    channel.queue_declare(queue='order_events', durable=True)
    channel.basic_publish(
        exchange='',
        routing_key='order_events',
        body=json.dumps(message),
        properties=pika.BasicProperties(delivery_mode=2)
    )
    connection.close()

@app.route('/health')
def health():
    return jsonify({'status': 'healthy', 'service': 'order-service'})

@app.route('/orders', methods=['GET'])
def get_orders():
    try:
        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT * FROM orders ORDER BY created_at DESC LIMIT 100")
        orders = cursor.fetchall()
        cursor.close()
        conn.close()

        return jsonify(orders)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/orders', methods=['POST'])
def create_order():
    try:
        data = request.json
        user_id = data.get('user_id')
        product_id = data.get('product_id')
        quantity = data.get('quantity', 1)

        # 创建订单
        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor()
        cursor.execute(
            "INSERT INTO orders (user_id, product_id, quantity, status) VALUES (%s, %s, %s, %s)",
            (user_id, product_id, quantity, 'pending')
        )
        conn.commit()
        order_id = cursor.lastrowid
        cursor.close()
        conn.close()

        # 发送消息到队列
        message = {
            'event': 'order_created',
            'order_id': order_id,
            'user_id': user_id,
            'product_id': product_id,
            'quantity': quantity
        }
        send_to_queue(message)

        return jsonify({'order_id': order_id, 'status': 'pending'}), 201
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8001)

4. 商品服务

services/product-service/app.py

from flask import Flask, jsonify
import mysql.connector
import os

app = Flask(__name__)

db_config = {
    'host': os.getenv('DB_HOST', 'mysql-master'),
    'user': os.getenv('DB_USER', 'root'),
    'password': os.getenv('DB_PASSWORD', '123456'),
    'database': 'products_db'
}

@app.route('/health')
def health():
    return jsonify({'status': 'healthy', 'service': 'product-service'})

@app.route('/products', methods=['GET'])
def get_products():
    try:
        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT * FROM products WHERE status = 'active'")
        products = cursor.fetchall()
        cursor.close()
        conn.close()

        return jsonify(products)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@app.route('/products/<int:product_id>', methods=['GET'])
def get_product(product_id):
    try:
        conn = mysql.connector.connect(**db_config)
        cursor = conn.cursor(dictionary=True)
        cursor.execute("SELECT * FROM products WHERE id = %s", (product_id,))
        product = cursor.fetchone()
        cursor.close()
        conn.close()

        if not product:
            return jsonify({'error': 'Product not found'}), 404

        return jsonify(product)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8001)

5. Docker Compose编排

docker-compose.yml

version: '3.8'

services:
  # API网关
  gateway:
    image: nginx:alpine
    container_name: api-gateway
    ports:
      - "80:80"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - nginx-logs:/var/log/nginx
    depends_on:
      - user-service-1
      - user-service-2
      - user-service-3
      - order-service-1
      - order-service-2
      - product-service-1
      - product-service-2
    networks:
      - microservices
    restart: unless-stopped

  # 用户服务（3个实例）
  user-service-1:
    build:
      context: ./services/user-service
      dockerfile: Dockerfile
    container_name: user-service-1
    ports:
      - "8001:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=users_db
      - REDIS_HOST=redis
      - INSTANCE_ID=1
    depends_on:
      - mysql-master
      - redis
    networks:
      - microservices
    restart: unless-stopped

  user-service-2:
    build:
      context: ./services/user-service
      dockerfile: Dockerfile
    container_name: user-service-2
    ports:
      - "8002:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=users_db
      - REDIS_HOST=redis
      - INSTANCE_ID=2
    depends_on:
      - mysql-master
      - redis
    networks:
      - microservices
    restart: unless-stopped

  user-service-3:
    build:
      context: ./services/user-service
      dockerfile: Dockerfile
    container_name: user-service-3
    ports:
      - "8003:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=users_db
      - REDIS_HOST=redis
      - INSTANCE_ID=3
    depends_on:
      - mysql-master
      - redis
    networks:
      - microservices
    restart: unless-stopped

  # 订单服务（2个实例）
  order-service-1:
    build:
      context: ./services/order-service
      dockerfile: Dockerfile
    container_name: order-service-1
    ports:
      - "8011:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=orders_db
      - RABBITMQ_HOST=rabbitmq
    depends_on:
      - mysql-master
      - rabbitmq
    networks:
      - microservices
    restart: unless-stopped

  order-service-2:
    build:
      context: ./services/order-service
      dockerfile: Dockerfile
    container_name: order-service-2
    ports:
      - "8012:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=orders_db
      - RABBITMQ_HOST=rabbitmq
    depends_on:
      - mysql-master
      - rabbitmq
    networks:
      - microservices
    restart: unless-stopped

  # 商品服务（2个实例）
  product-service-1:
    build:
      context: ./services/product-service
      dockerfile: Dockerfile
    container_name: product-service-1
    ports:
      - "8021:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=products_db
    depends_on:
      - mysql-master
    networks:
      - microservices
    restart: unless-stopped

  product-service-2:
    build:
      context: ./services/product-service
      dockerfile: Dockerfile
    container_name: product-service-2
    ports:
      - "8022:8001"
    environment:
      - DB_HOST=mysql-master
      - DB_PASSWORD=123456
      - DB_NAME=products_db
    depends_on:
      - mysql-master
    networks:
      - microservices
    restart: unless-stopped

  # MySQL主库
  mysql-master:
    image: mysql:8.0
    container_name: mysql-master
    environment:
      MYSQL_ROOT_PASSWORD: 123456
    volumes:
      - mysql-master-data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    networks:
      - microservices
    restart: unless-stopped

  # MySQL从库
  mysql-slave:
    image: mysql:8.0
    container_name: mysql-slave
    environment:
      MYSQL_ROOT_PASSWORD: 123456
    networks:
      - microservices
    restart: unless-stopped

  # Redis集群
  redis:
    image: redis:7-alpine
    container_name: redis-cache
    command: redis-server --appendonly yes
    volumes:
      - redis-data:/data
    ports:
      - "6379:6379"
    networks:
      - microservices
    restart: unless-stopped

  # RabbitMQ消息队列
  rabbitmq:
    image: rabbitmq:3-management
    container_name: rabbitmq
    ports:
      - "5672:5672"
      - "15672:15672"
    volumes:
      - rabbitmq-data:/var/lib/rabbitmq
    networks:
      - microservices
    restart: unless-stopped

networks:
  microservices:
    driver: bridge

volumes:
  mysql-master-data:
  redis-data:
  rabbitmq-data:
  nginx-logs:

6. 服务发现和负载均衡

技术原理

1. 负载均衡策略

13-Docker进阶-镜像优化与最佳实践

Sat, 21 Feb 2026 00:00:00 +0000

Docker进阶技巧

前面我们已经学习了Docker的基础知识和实战项目，今天我们深入探讨镜像优化、安全加固、性能调优等高级话题。

1. 镜像体积优化

多阶段构建

问题：传统构建方式镜像体积大（包含构建工具）

# 不好：镜像包含gcc、make等构建工具
FROM python:3.11
RUN apt-get update && apt-get install -y gcc
COPY . .
RUN pip install -r requirements.txt
CMD ["python", "app.py"]
# 镜像大小：900MB

解决方案：多阶段构建

# 好：分离构建和运行环境
FROM python:3.11-slim AS builder
RUN apt-get update && apt-get install -y gcc
COPY requirements.txt .
RUN pip install --user -r requirements.txt

FROM python:3.11-slim
COPY --from=builder /root/.local /root/.local
COPY . .
ENV PATH=/root/.local/bin:$PATH
CMD ["python", "app.py"]
# 镜像大小：150MB

使用alpine基础镜像

对比：

python:3.11：900MB（完整版）
python:3.11-slim：120MB（瘦身版）
python:3.11-alpine：50MB（Alpine版）

# 使用alpine
FROM python:3.11-alpine

# 注意：alpine使用musl libc，某些C扩展可能不兼容
# 如果遇到兼容性问题，用slim版本

合并RUN指令

不好：

RUN apt-get update
RUN apt-get install -y curl
RUN apt-get install -y wget
RUN apt-get clean
# 创建4层，每层都有缓存

好：

RUN apt-get update && \
    apt-get install -y curl wget && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*
# 只创建1层

清理缓存

# Python：使用--no-cache-dir
RUN pip install --no-cache-dir -r requirements.txt

# apt：清理apt缓存
RUN apt-get update && \
    apt-get install -y curl && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

# npm：清理npm缓存
RUN npm install && npm cache clean --force

利用构建缓存

原理：如果Dockerfile指令和文件没变化，Docker复用缓存。

01-为什么学Python？因为你值得更轻松的生活

Tue, 03 Feb 2026 00:00:00 +0000

别再假装你不需要学编程了

说实话，你是不是也有过这些瞬间：

每天在10个微信群里找文件，翻了半小时还没找到
需要从100个Excel表格里汇总数据，复制粘贴到天荒地老
想批量处理1000张图片，只能一个一个打开PS

别再假装你会看完那些PPT了，直接动手学点实用的！

为什么是Python？不是其他编程语言？

实话实说，Python不是最高效的，但它是最贴近人类语言的。用起来就像呼吸一样自然。

你可以用Python做什么？

具体来说，Python能帮你解决这些问题：

痛点	Python解决方案	每天节省时间
复制粘贴Excel	3行代码自动处理	2小时
整理文件夹里的文件	一句话搞定	30分钟
批量重命名文件	5行代码	1小时
自动发邮件提醒	设置一次，终身受益	15分钟
爬取网页数据	不用手动复制	无限
分析销售数据	一键生成图表	3小时

每天节省2小时，一年就是730小时，相当于多了一个月的空闲时间！

Python有多简单？

看看这个对比：

# 想把一个文件夹里的所有图片从.jpg改成.png
# 用Python，只需要2行：
import os
[os.rename(f, f.replace('.jpg', '.png')) for f in os.listdir() if f.endswith('.jpg')]

这就是Python的魅力，代码写出来就像英语句子一样。

学习前别被这些谣言吓到

谣言1：“我没有计算机基础，学不会”

真相： 我教过很多人，有会计、有销售、有HR，甚至有60岁的退休阿姨，他们都学会了。你只需要会打字就行。

谣言2：“学编程太枯燥了”

真相： Python的学习过程就像玩游戏，写完代码运行的那一刻，那种爽快感比刷短视频还上瘾！

谣言3：“学完用不上”

真相： Python可以自动化你工作中的大部分重复劳动。你每天都在重复做的那些事，就是最适合用Python来解决的！

学习路径（全程干货，不废话）

我们接下来的文章会按这个顺序来：

环境配置 - 30分钟搞定，别再装各种软件装到崩溃
变量和数据 - 理解这些，你就掌握了编程的一半
条件判断 - 让电脑学会思考
循环 - 一次做1000件事
函数 - 把代码打包成工具
字符串操作 - 处理文字，像处理Excel一样简单
列表和字典 - 存储和管理数据
文件操作 - 读写Excel、Word、PDF
实战项目1 - 自动整理文件夹，告别混乱
实战项目2 - 批量处理Excel，再也不加班
实战项目3 - 自动发邮件，装X利器
实战项目4 - 爬取网页数据，信息差就是钱

下一步准备什么？

不用准备什么，只需要：

一台电脑（Windows/Mac都行）
会打字
别给自己找借口，就开始学！

下一章我们就来安装Python，准备好了吗？

02-环境配置-30分钟搞定Python

Tue, 03 Feb 2026 00:00:00 +0000

第一次装软件别翻车

很多人第一步就放弃了，因为装软件装崩了。别慌，我带你一步步来，保证你30分钟内搞定。

为什么不推荐在线编译器？

你可能看过一些教程说"在线编译器多方便，不用安装"。

我实话实说：在线编译器就是个坑！

网速慢的时候卡成狗
本地文件没法直接操作
做实际项目根本用不上
学的时候图省事，到时候还得重装，这不是浪费时间吗？

所以，直接装个正版的，一步到位！

Windows用户看这里

1. 下载Python（别下错了）

直接去官网下：https://www.python.org/downloads/

打开网站你会看到两个大按钮：

Download Python 3.x.x（推荐这个，最新的稳定版）
Download Python 3.x.x（如果上面那个不好用，再用这个）

点Download就行了，别想太多！

2. 安装的关键一步（99%的人这里出错）

双击安装包后，在第一个界面上，一定要勾选"Add Python to PATH"！

这一步非常重要！ 不勾选的话，你后面用Python会各种报错，到时候又要重装。

然后点击"Install Now"，等几分钟就装好了。

3. 验证安装成功

按Win + R，输入cmd，回车。

在黑框框里输入：

python --version

如果你看到类似Python 3.12.0，恭喜你，装成功了！

再输入：

pip --version

如果也能看到版本号，完美！

Mac用户看这里

1. Mac其实已经自带Python了（但版本太老）

打开终端，输入python3 --version，你可能看到的是Python 3.9.x或者更老的版本。

别直接用这个！ 版本太老，很多新功能用不了。

2. 用Homebrew安装（最推荐）

如果你没有Homebrew，先安装它：

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

然后安装Python：

brew install python

等它安装完，就搞定了。

3. 验证安装

python3 --version
pip3 --version

看到版本号就成功了。

安装代码编辑器（别用记事本！）

记事本写Python就是给自己找罪受！ 没有语法高亮，没有代码提示，写错都没发现。

或者用PyCharm Community（免费版）

下载地址：https://www.jetbrains.com/pycharm/download/

PyCharm是专门为Python设计的，功能更强大，但对新手来说可能有点复杂。

我的建议：先用VS Code，熟悉了再考虑PyCharm。

第一次运行Python代码

1. 交互式模式（玩玩而已）

打开终端（Windows是cmd，Mac是Terminal），输入：

python

你会看到类似这样的提示符：

>>>

在里面输入：

print("Hello, 世界!")

按回车，屏幕上就会显示：Hello, 世界!

输入exit()退出。

2. 脚本模式（以后都用这个）

用VS Code新建一个文件，保存为hello.py，写入：

print("Hello, 世界!")

然后在终端里运行：

python hello.py

看到输出就成功了！

常见坑及解决方案

坑1：输入python提示找不到命令

原因： Windows没勾选"Add Python to PATH"

解决： 卸载Python，重新安装，这次记得勾选！

坑2：Mac上输入python没反应

原因： Mac默认没有python命令，只有python3

解决： 以后都用python3和pip3

坑3：VS Code运行Python时报错

原因： VS Code没找到Python解释器

解决：

按Ctrl+Shift+P
输入"Python: Select Interpreter"
选择你安装的Python版本

环境配置检查清单

安装完对照这个检查一遍：

03-变量和数据-编程就这两件事

Tue, 03 Feb 2026 00:00:00 +0000

编程其实就做两件事

说实话，编程没那么复杂，归根结底就两件事：

存数据（用变量）
操作数据（用各种运算）

今天我们先把第一件事搞定：怎么存数据。

什么是变量？

变量就是一个装东西的盒子。

你可以把它想象成一个标签，贴在某个数据上，方便你后面找到它。

name = "小明"
age = 25
height = 1.75

这三个变量就像三个盒子：

name这个盒子里装了字符串"小明"
age这个盒子里装了整数25
height这个盒子里装了小数1.75

以后要用到这些数据，直接用变量名就行了，不用记住数据本身。

变量命名的黄金规则（别乱来！）

能用什么字符？

只能用字母、数字、下划线
不能用数字开头
不能用空格
不能用中文（虽然Python支持，但不推荐）

# 正确的命名
name = "小明"
user_name = "小红"
age1 = 20
age_2 = 25

# 错误的命名
1name = "小明"    # 数字开头
user name = "小红" # 有空格
class = 20        # class是Python关键字

命名规范（让代码看起来专业点）

# 不推荐（太丑）
x = "小明"
n = 25
a = 1.75

# 推荐（一看就知道是什么）
name = "小明"
age = 25
height = 1.75

# 多个单词用下划线连接
user_name = "小红"
total_score = 100

原则：变量名要能说明存的是什么数据。

Python的六种数据类型（记住这几个就够了）

1. 整数（int）

就是整数，没小数点的。

age = 25
count = 100
num_people = 50

2. 浮点数（float）

带小数点的。

height = 1.75
price = 99.99
temperature = 36.5

注意： Python里用小数点分隔小数，不是逗号！

3. 字符串（str）

用引号包起来的文字。

name = "小明"      # 双引号
message = '你好'   # 单引号也行
long_text = """
这是一段很长的文字，
可以换行写。
"""               # 三引号可以换行

引号的选择：

文字里有单引号，就用双引号："It's a dog"
文字里有双引号，就用单引号：'他叫我"大帅哥"'

4. 布尔值（bool）

就两个值：True和False（注意大小写！）。

is_student = True
is_married = False
has_job = True

布尔值就像开关，要么开要么关。

5. 列表（list）

可以存多个数据，用方括号包起来。

names = ["小明", "小红", "小刚"]
numbers = [1, 2, 3, 4, 5]
mixed = ["张三", 25, True, 1.75]  # 什么类型都能放

列表就像个购物袋，什么都能往里装。

6. 字典（dict）

键值对的形式存储数据，用花括号包起来。

person = {
    "name": "小明",
    "age": 25,
    "height": 1.75
}

# 也可以一行写
product = {"name": "手机", "price": 2999, "stock": 100}

字典就像一本字典，你查"小明"，就能找到他的所有信息。

变量的赋值和修改

赋值

name = "小明"  # 创建一个变量，赋值为"小明"
age = 25       # 创建一个变量，赋值为25

修改

name = "小明"
name = "小红"  # 重新赋值，原来的"小明"就没了

age = 25
age = age + 1  # 年龄加1，变成26
age += 1       # 同样是加1，简写形式

删除

name = "小明"
del name  # 删除变量，后面再用name会报错

查看变量类型

不知道变量是什么类型？用type()函数：

04-条件判断-让电脑学会思考

Tue, 03 Feb 2026 00:00:00 +0000

电脑也会做决定？

你可能会想，电脑不就是按指令执行吗？它怎么"思考"？

条件判断就是让电脑根据不同情况做不同的事情。

就像你每天出门前会想：

下雨了？带伞
没下雨？带太阳镜

电脑也能做这样的判断！

if语句的基本语法

if 条件:
    # 条件成立时执行的代码
    pass

注意冒号和缩进！ 这是Python最重要的两个语法：

冒号：表示条件判断的开始
缩进（4个空格）表示属于这个if的代码块

age = 18

if age >= 18:
    print("你已经成年了！")
    print("可以办身份证了！")

运行结果：

你已经成年了！
可以办身份证了！

if-else：二选一

if 条件:
    # 条件成立时执行
else:
    # 条件不成立时执行

age = 16

if age >= 18:
    print("你已经成年了！")
else:
    print("你还没成年！")

运行结果：

你还没成年！

if-elif-else：多选一

if 条件1:
    # 条件1成立时执行
elif 条件2:
    # 条件2成立时执行
elif 条件3:
    # 条件3成立时执行
else:
    # 以上条件都不成立时执行

score = 85

if score >= 90:
    print("优秀！")
elif score >= 80:
    print("良好！")
elif score >= 60:
    print("及格！")
else:
    print("不及格！")

运行结果：

良好！

比较运算符（记住这些就够了）

运算符	说明	例子
`>`	大于	`age > 18`
`<`	小于	`age < 18`
`>=`	大于等于	`age >= 18`
`<=`	小于等于	`age <= 18`
`==`	等于（注意是两个等号！）	`age == 18`
`!=`	不等于	`age != 18`

重点注意：=是赋值，==是判断相等！

# 错误写法
if age = 18:  # 报错！=是赋值，不能用在if里

# 正确写法
if age == 18:  # 判断age是否等于18
    print("你刚好18岁！")

逻辑运算符（组合条件）

and：并且

两个条件都要成立。

age = 25
has_job = True

if age >= 18 and has_job:
    print("你已经成年，而且有工作！")

or：或者

只要有一个条件成立就行。

05-循环-一次做1000件事

Tue, 03 Feb 2026 00:00:00 +0000

重复劳动交给电脑！

你有没有过这样的经历：

要给1000个文件重命名，一个一个改到吐血
要从100个Excel表格里提取数据，复制粘贴到天荒地老
要给1000个人发邮件，手动发到崩溃

别再假装你会手动完成这些事了，交给Python吧！

循环就是让电脑重复做某件事，一次做1000次、10000次，几秒钟搞定。

for循环：遍历一个序列

基本语法

for 变量 in 序列:
    # 重复执行的代码
    pass

遍历列表

names = ["小明", "小红", "小刚", "小李"]

for name in names:
    print("你好，" + name + "！")

运行结果：

你好，小明！
你好，小红！
你好，小刚！
你好，小李！

遍历字符串

word = "Python"

for letter in word:
    print(letter)

运行结果：

P
y
t
h
o
n

range()函数：生成数字序列

# range(5)生成0, 1, 2, 3, 4
for i in range(5):
    print(i)

运行结果：

注意： range(5)是从0开始，到4结束（不包含5）！

# range(1, 6)生成1, 2, 3, 4, 5
for i in range(1, 6):
    print(i)

# range(1, 10, 2)生成1, 3, 5, 7, 9（步长为2）
for i in range(1, 10, 2):
    print(i)

while循环：条件满足就一直循环

基本语法

while 条件:
    # 条件成立时重复执行的代码
    pass

简单例子

count = 0

while count < 5:
    print("现在是第" + str(count + 1) + "次")
    count = count + 1  # 或者写成 count += 1

运行结果：

现在是第1次
现在是第2次
现在是第3次
现在是第4次
现在是第5次

一定要有退出条件！

count = 0

while count < 5:
    print("循环中...")
    # count += 1  # 如果注释掉这行，会无限循环！

无限循环就像停不下来的跑步机，电脑会卡死！

break和continue：控制循环

break：跳出循环

for i in range(10):
    if i == 5:
        break  # 到5就跳出循环
    print(i)

运行结果：

06-函数-把代码打包成工具

Tue, 03 Feb 2026 00:00:00 +0000

别再复制粘贴代码了！

你有没有过这样的经历：

写了一段代码，过几天又需要用，复制粘贴改半天
同样的逻辑写了5遍，后来发现有个bug，要改5个地方
代码写到几百行，自己都看不懂是干嘛的

别再假装你能记住所有代码了，用函数吧！

函数就是把你的一段代码打包成一个工具，以后直接调用，不用重复写。

函数的基本语法

def 函数名(参数1, 参数2, ...):
    # 函数体：要执行的代码
    pass
    return 返回值

无参无返回值

def say_hello():
    print("你好！")
    print("欢迎学习Python！")

# 调用函数
say_hello()
say_hello()  # 可以调用多次

有参无返回值

def say_hi(name):
    print("你好，" + name + "！")

say_hi("小明")  # 输出：你好，小明！
say_hi("小红")  # 输出：你好，小红！

有参有返回值

def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # 输出：8

# 也可以直接用
print(add(10, 20))  # 输出：30

函数的优点

1. 代码复用

# 不用函数，代码重复
print("小明")
print("小红")
print("小刚")

# 用函数，一次写好，重复调用
def print_names(name):
    print(name)

print_names("小明")
print_names("小红")
print_names("小刚")

2. 便于修改

# 原来打印名字
def show_info(name):
    print("姓名：" + name)

show_info("小明")

# 现在要改成显示更多信息，只需要改一个地方
def show_info(name, age, job):
    print(f"姓名：{name}")
    print(f"年龄：{age}")
    print(f"职业：{job}")

show_info("小明", 25, "程序员")

3. 代码清晰

# 不用函数，一坨代码
num1 = float(input("输入第一个数字："))
num2 = float(input("输入第二个数字："))
operator = input("输入运算符：")
if operator == "+":
    result = num1 + num2
    print(f"{num1} + {num2} = {result}")
elif operator == "-":
    result = num1 - num2
    print(f"{num1} - {num2} = {result}")
elif operator == "*":
    result = num1 * num2
    print(f"{num1} * {num2} = {result}")
elif operator == "/":
    if num2 == 0:
        print("除数不能为0！")
    else:
        result = num1 / num2
        print(f"{num1} / {num2} = {result}")
else:
    print("不支持的运算符！")

# 用函数，逻辑清晰
def calculate(num1, num2, operator):
    if operator == "+":
        return num1 + num2
    elif operator == "-":
        return num1 - num2
    elif operator == "*":
        return num1 * num2
    elif operator == "/":
        if num2 == 0:
            return None
        return num1 / num2
    else:
        return None

def main():
    num1 = float(input("输入第一个数字："))
    num2 = float(input("输入第二个数字："))
    operator = input("输入运算符：")

    result = calculate(num1, num2, operator)

    if result is not None:
        print(f"{num1} {operator} {num2} = {result}")
    elif num2 == 0:
        print("除数不能为0！")
    else:
        print("不支持的运算符！")

main()  # 主程序入口

函数的参数

必需参数

def greet(name, age):
    print(f"你好，{name}，你今年{age}岁了！")

# 必须按顺序传入所有参数
greet("小明", 25)  # 正确
greet("小明")  # 报错！缺少参数

默认参数

def greet(name, age=18):
    print(f"你好，{name}，你今年{age}岁了！")

greet("小明")        # 输出：你好，小明，你今年18岁了！
greet("小明", 25)    # 输出：你好，小明，你今年25岁了！

关键字参数

def greet(name, age):
    print(f"你好，{name}，你今年{age}岁了！")

# 可以不按顺序，用关键字指定
greet(age=25, name="小明")  # 输出：你好，小明，你今年25岁了！

可变参数（*args）

def sum_all(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_all(1, 2, 3))        # 输出：6
print(sum_all(1, 2, 3, 4, 5))  # 输出：15

函数的返回值

返回单个值

def square(x):
    return x * x

result = square(5)
print(result)  # 输出：25

返回多个值（返回元组）

def get_info(name):
    age = 25
    job = "程序员"
    return name, age, job

name, age, job = get_info("小明")
print(f"姓名：{name}，年龄：{age}，职业：{job}")

没有return语句

def say_hello():
    print("你好！")

result = say_hello()  # 返回None
print(result)  # 输出：None

变量的作用域

局部变量

def my_function():
    local_var = "我是局部变量"
    print(local_var)  # 可以访问

my_function()
# print(local_var)  # 报错！外部无法访问局部变量

全局变量

global_var = "我是全局变量"

def my_function():
    print(global_var)  # 可以访问全局变量

my_function()
print(global_var)  # 也可以在外部访问

在函数内修改全局变量（用global关键字）

count = 0

def increment():
    global count  # 声明要用全局变量
    count += 1

increment()
print(count)  # 输出：1

常用内置函数

# len()：计算长度
print(len("Python"))  # 输出：6
print(len([1, 2, 3]))  # 输出：3

# max()、min()：最大值和最小值
print(max(1, 5, 3))  # 输出：5
print(min(1, 5, 3))  # 输出：1

# sum()：求和
print(sum([1, 2, 3, 4, 5]))  # 输出：15

# type()：查看类型
print(type("Hello"))  # 输出：<class 'str'>

# int()、float()、str()：类型转换
print(int("123"))    # 输出：123
print(float("3.14"))  # 输出：3.14
print(str(123))       # 输出："123"

# input()：用户输入
name = input("请输入你的名字：")
print("你好，" + name)

实战小项目1：计算器

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        return "除数不能为0！"
    return a / b

def calculator():
    print("=== 简易计算器 ===")
    print("1. 加法")
    print("2. 减法")
    print("3. 乘法")
    print("4. 除法")

    choice = input("请选择操作（1-4）：")
    num1 = float(input("请输入第一个数字："))
    num2 = float(input("请输入第二个数字："))

    if choice == "1":
        result = add(num1, num2)
        print(f"{num1} + {num2} = {result}")
    elif choice == "2":
        result = subtract(num1, num2)
        print(f"{num1} - {num2} = {result}")
    elif choice == "3":
        result = multiply(num1, num2)
        print(f"{num1} * {num2} = {result}")
    elif choice == "4":
        result = divide(num1, num2)
        print(f"{num1} / {num2} = {result}")
    else:
        print("无效的选择！")

calculator()

实战小项目2：BMI计算器

def calculate_bmi(height, weight):
    """计算BMI"""
    return weight / (height * height)

def get_bmi_status(bmi):
    """根据BMI返回状态"""
    if bmi < 18.5:
        return "偏瘦"
    elif bmi < 24:
        return "正常"
    elif bmi < 28:
        return "偏胖"
    else:
        return "肥胖"

def bmi_calculator():
    print("=== BMI计算器 ===")
    height = float(input("请输入你的身高（米）："))
    weight = float(input("请输入你的体重（公斤）："))

    bmi = calculate_bmi(height, weight)
    status = get_bmi_status(bmi)

    print(f"\n你的BMI是：{bmi:.2f}")
    print(f"你的体重状态是：{status}")

bmi_calculator()

常见坑及解决方案

坑1：忘记return

def add(a, b):
    a + b  # 没有return，返回None

result = add(1, 2)
print(result)  # 输出：None

解决： 记得用return返回值！

07-字符串操作-处理文字像Excel一样简单

Tue, 03 Feb 2026 00:00:00 +0000

文字处理没那么难

你有没有过这样的经历：

需要从100个名字里提取出姓氏
要把1000个手机号码格式化（加空格或横线）
需要从文章里提取出所有邮箱地址
要把文字里的敏感词替换掉

别再假装你会手动处理这些文字了，用Python吧！

字符串操作就是Python处理文字的利器，比Excel还强大！

字符串的基本操作

创建字符串

# 用单引号
s1 = 'Hello'

# 用双引号
s2 = "Hello"

# 用三引号（可以换行）
s3 = """
这是一段
很长的文字
可以换行
"""

# 如果字符串里有引号，用另一种引号包起来
s4 = "It's a dog"
s5 = '他叫我"大帅哥"'

字符串拼接

# 用+号拼接
name = "小明"
age = 25
message = name + "今年" + str(age) + "岁"
print(message)  # 输出：小明今年25岁

# 用f-string（Python 3.6+，推荐！）
message = f"{name}今年{age}岁"
print(message)  # 输出：小明今年25岁

# 用format()方法
message = "{}今年{}岁".format(name, age)
print(message)  # 输出：小明今年25岁

f-string是最推荐的方式，代码最简洁！

字符串重复

s = "哈哈"
print(s * 3)  # 输出：哈哈哈哈哈哈

字符串的索引和切片

索引（从0开始）

s = "Python"

# 正向索引（从0开始）
print(s[0])  # 输出：P
print(s[1])  # 输出：y
print(s[5])  # 输出：n

# 反向索引（从-1开始）
print(s[-1])  # 输出：n
print(s[-2])  # 输出：o
print(s[-6])  # 输出：P

切片（提取子字符串）

s = "Python"

# [起始位置:结束位置]（不包括结束位置）
print(s[0:3])   # 输出：Pyt
print(s[1:4])   # 输出：yth
print(s[2:])    # 输出：thon（从第2个到结尾）
print(s[:3])    # 输出：Pyt（从开头到第3个）
print(s[:])     # 输出：Python（全部）

# 步长
print(s[::2])   # 输出：Pto（隔一个取一个）
print(s[::-1])  # 输出：nohtyP（反转字符串）

常用字符串方法

大小写转换

s = "Hello World"

# 全部大写
print(s.upper())  # 输出：HELLO WORLD

# 全部小写
print(s.lower())  # 输出：hello world

# 首字母大写
print(s.capitalize())  # 输出：Hello world

# 每个单词首字母大写
print(s.title())  # 输出：Hello World

# 大小写反转
print(s.swapcase())  # 输出：hELLO wORLD

去除空白

s = "  Hello World  "

# 去除首尾空白
print(s.strip())  # 输出：Hello World

# 去除左侧空白
print(s.lstrip())  # 输出：Hello World  

# 去除右侧空白
print(s.rstrip())  # 输出：  Hello World

# 去除指定字符
s = "xxxHello Worldxxx"
print(s.strip("x"))  # 输出：Hello World

查找和替换

s = "Hello World Hello Python"

# 查找子字符串（返回索引）
print(s.find("World"))    # 输出：6
print(s.find("xxx"))      # 输出：-1（没找到）

# 统计出现次数
print(s.count("Hello"))   # 输出：2

# 替换
print(s.replace("Hello", "Hi"))  # 输出：Hi World Hi Python
print(s.replace("Hello", "Hi", 1))  # 输出：Hi World Hello Python（只替换第一个）

判断字符串特征

s = "Python123"

# 是否以...开头
print(s.startswith("Py"))    # 输出：True
print(s.startswith("Pyt"))   # 输出：True
print(s.startswith("thon"))  # 输出：False

# 是否以...结尾
print(s.endswith("123"))     # 输出：True
print(s.endswith("23"))      # 输出：True
print(s.endswith("456"))     # 输出：False

# 是否全是数字
print("123".isdigit())       # 输出：True
print("abc".isdigit())       # 输出：False
print("123abc".isdigit())    # 输出：False

# 是否全是字母
print("abc".isalpha())       # 输出：True
print("123".isalpha())       # 输出：False
print("abc123".isalpha())    # 输出：False

# 是否全是数字或字母
print("abc123".isalnum())    # 输出：True
print("abc 123".isalnum())   # 输出：False（有空格）

分割和连接

# 分割字符串
s = "apple,banana,orange"

# 用逗号分割
fruits = s.split(",")
print(fruits)  # 输出：['apple', 'banana', 'orange']

# 用空格分割
s2 = "Hello World Python"
words = s2.split()
print(words)  # 输出：['Hello', 'World', 'Python']

# 限制分割次数
s3 = "a,b,c,d,e"
parts = s3.split(",", 2)
print(parts)  # 输出：['a', 'b', 'c,d,e']

# 连接字符串
fruits = ['apple', 'banana', 'orange']
result = ",".join(fruits)
print(result)  # 输出：apple,banana,orange

# 用空格连接
words = ['Hello', 'World', 'Python']
result = " ".join(words)
print(result)  # 输出：Hello World Python

对齐

s = "Python"

# 左对齐，宽度10，用空格填充
print(f"|{s.ljust(10)}|")  # 输出：|Python    |

# 右对齐，宽度10，用空格填充
print(f"|{s.rjust(10)}|")  # 输出：|    Python|

# 居中，宽度10，用空格填充
print(f"|{s.center(10)}|")  # 输出：|  Python  |

# 用指定字符填充
print(f"|{s.ljust(10, '*')}|")   # 输出：|Python****|
print(f"|{s.rjust(10, '*')}|")   # 输出：|****Python|
print(f"|{s.center(10, '*')}|")   # 输出：|**Python**|

实战小项目1：手机号码格式化

def format_phone_number(phone):
    """格式化手机号码：13812345678 -> 138-1234-5678"""
    phone = phone.replace("-", "").replace(" ", "")  # 先去掉横线和空格

    if len(phone) == 11 and phone.isdigit():
        return f"{phone[:3]}-{phone[3:7]}-{phone[7:]}"
    else:
        return "无效的手机号码！"

# 测试
print(format_phone_number("13812345678"))  # 输出：138-1234-5678
print(format_phone_number("138-1234-5678"))  # 输出：138-1234-5678
print(format_phone_number("138 1234 5678"))  # 输出：138-1234-5678
print(format_phone_number("123"))  # 输出：无效的手机号码！

实战小项目2：提取姓名的姓和名

def split_chinese_name(name):
    """分割中文姓名：假设前1-2个字是姓，后面是名"""
    name = name.strip()  # 去除首尾空白

    if len(name) >= 3:
        # 复姓
        surname = name[:2]
        given_name = name[2:]
    elif len(name) == 2:
        # 单姓
        surname = name[0]
        given_name = name[1]
    else:
        return "无效的姓名！"

    return f"姓：{surname}，名：{given_name}"

# 测试
print(split_chinese_name("张三"))     # 输出：姓：张，名：三
print(split_chinese_name("欧阳锋"))   # 输出：姓：欧阳，名：锋
print(split_chinese_name("诸葛亮"))   # 输出：姓：诸，名：葛亮（简化处理）

实战小项目3：提取邮箱地址

import re

def extract_emails(text):
    """从文本中提取所有邮箱地址"""
    pattern = r'[\w\.-]+@[\w\.-]+\.\w+'
    emails = re.findall(pattern, text)
    return emails

text = """
请联系我：xiaoming@example.com 或 zhangsan@qq.com
如果有问题也可以联系：lisi@163.com
"""

emails = extract_emails(text)
print("找到的邮箱地址：")
for email in emails:
    print(email)

# 输出：
# 找到的邮箱地址：
# xiaoming@example.com
# zhangsan@qq.com
# lisi@163.com

实战小项目4：敏感词替换

def replace_sensitive_words(text, sensitive_words, replacement="***"):
    """替换敏感词"""
    for word in sensitive_words:
        text = text.replace(word, replacement)
    return text

sensitive_words = ["笨蛋", "傻瓜", "白痴"]
text = "你这个笨蛋！你真是个傻瓜！"

result = replace_sensitive_words(text, sensitive_words)
print(result)  # 输出：你这个***！你真是个***！

常见坑及解决方案

坑1：字符串是不可变的

s = "Hello"
s[0] = "P"  # 报错！字符串不能修改

解决： 创建新字符串

08-列表和字典-存储和管理数据

Tue, 03 Feb 2026 00:00:00 +0000

数据存哪呢？

你有没有过这样的经历：

需要存储100个学生成绩，总不能声明100个变量吧
需要存储商品信息（名称、价格、库存），用什么存
需要频繁添加、删除数据，用什么结构最合适

别再假装你会用100个变量解决问题了，用列表和字典吧！

列表和字典是Python最重要的两个数据结构，理解了它们，你就掌握了存储数据的艺术。

列表（list）：有序的数据集合

创建列表

# 空列表
empty_list = []

# 包含多个元素的列表
numbers = [1, 2, 3, 4, 5]
names = ["小明", "小红", "小刚"]
mixed = [1, "Hello", True, 3.14]  # 什么类型都能放

访问元素

names = ["小明", "小红", "小刚", "小李"]

# 索引访问（从0开始）
print(names[0])   # 输出：小明
print(names[1])   # 输出：小红
print(names[-1])  # 输出：小李（最后一个）
print(names[-2])  # 输出：小刚（倒数第二个）

# 切片
print(names[0:2])    # 输出：['小明', '小红']
print(names[1:3])    # 输出：['小红', '小刚']
print(names[:2])     # 输出：['小明', '小红']
print(names[1:])     # 输出：['小红', '小刚', '小李']

添加元素

numbers = [1, 2, 3]

# append()：在末尾添加一个元素
numbers.append(4)
print(numbers)  # 输出：[1, 2, 3, 4]

# insert()：在指定位置插入元素
numbers.insert(1, 100)
print(numbers)  # 输出：[1, 100, 2, 3, 4]

# extend()：在末尾添加多个元素
numbers.extend([5, 6, 7])
print(numbers)  # 输出：[1, 100, 2, 3, 4, 5, 6, 7]

# 列表拼接（创建新列表）
new_list = numbers + [8, 9, 10]
print(new_list)  # 输出：[1, 100, 2, 3, 4, 5, 6, 7, 8, 9, 10]

删除元素

numbers = [1, 2, 3, 4, 5]

# del：根据索引删除
del numbers[1]
print(numbers)  # 输出：[1, 3, 4, 5]

# remove()：根据值删除（只删除第一个）
numbers.remove(3)
print(numbers)  # 输出：[1, 4, 5]

# pop()：删除并返回指定位置的元素
element = numbers.pop(1)
print(element)  # 输出：4
print(numbers)  # 输出：[1, 5]

# pop()：不指定索引，删除最后一个
element = numbers.pop()
print(element)  # 输出：5
print(numbers)  # 输出：[1]

修改元素

numbers = [1, 2, 3, 4, 5]

# 根据索引修改
numbers[0] = 100
print(numbers)  # 输出：[100, 2, 3, 4, 5]

# 修改多个元素
numbers[1:3] = [200, 300]
print(numbers)  # 输出：[100, 200, 300, 4, 5]

其他常用操作

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# len()：获取长度
print(len(numbers))  # 输出：8

# sort()：排序（升序）
numbers.sort()
print(numbers)  # 输出：[1, 1, 2, 3, 4, 5, 6, 9]

# sort(reverse=True)：降序
numbers.sort(reverse=True)
print(numbers)  # 输出：[9, 6, 5, 4, 3, 2, 1, 1]

# reverse()：反转
numbers.reverse()
print(numbers)  # 输出：[1, 1, 2, 3, 4, 5, 6, 9]

# count()：统计元素出现次数
print(numbers.count(1))  # 输出：2

# index()：查找元素的索引
print(numbers.index(5))  # 输出：4

# in：判断元素是否存在
print(5 in numbers)  # 输出：True
print(10 in numbers)  # 输出：False

列表推导式（优雅的创建列表）

# 传统方式
squares = []
for i in range(1, 6):
    squares.append(i * i)
print(squares)  # 输出：[1, 4, 9, 16, 25]

# 列表推导式
squares = [i * i for i in range(1, 6)]
print(squares)  # 输出：[1, 4, 9, 16, 25]

# 带条件的列表推导式
even_numbers = [i for i in range(1, 11) if i % 2 == 0]
print(even_numbers)  # 输出：[2, 4, 6, 8, 10]

字典（dict）：键值对的数据集合

创建字典

# 空字典
empty_dict = {}

# 包含多个键值对
person = {
    "name": "小明",
    "age": 25,
    "job": "程序员"
}

# 用dict()函数创建
person = dict(name="小明", age=25, job="程序员")

访问和修改

person = {
    "name": "小明",
    "age": 25,
    "job": "程序员"
}

# 访问值
print(person["name"])  # 输出：小明
print(person["age"])   # 输出：25

# get()方法（推荐，不会报错）
print(person.get("name"))      # 输出：小明
print(person.get("height"))    # 输出：None（键不存在时返回None）
print(person.get("height", 1.75))  # 输出：1.75（键不存在时返回默认值）

# 修改值
person["age"] = 26
print(person)  # 输出：{'name': '小明', 'age': 26, 'job': '程序员'}

# 添加键值对
person["height"] = 1.75
print(person)  # 输出：{'name': '小明', 'age': 26, 'job': '程序员', 'height': 1.75}

删除键值对

person = {
    "name": "小明",
    "age": 25,
    "job": "程序员"
}

# del：删除键值对
del person["job"]
print(person)  # 输出：{'name': '小明', 'age': 25}

# pop()：删除并返回值
age = person.pop("age")
print(age)    # 输出：25
print(person)  # 输出：{'name': '小明'}

常用操作

person = {
    "name": "小明",
    "age": 25,
    "job": "程序员"
}

# keys()：获取所有键
print(person.keys())  # 输出：dict_keys(['name', 'age', 'job'])

# values()：获取所有值
print(person.values())  # 输出：dict_values(['小明', 25, '程序员'])

# items()：获取所有键值对
print(person.items())  # 输出：dict_items([('name', '小明'), ('age', 25), ('job', '程序员')])

# 遍历字典
for key in person:
    print(key, person[key])

# 推荐：同时遍历键和值
for key, value in person.items():
    print(f"{key}: {value}")

# len()：获取键值对数量
print(len(person))  # 输出：3

# in：判断键是否存在
print("name" in person)  # 输出：True
print("height" in person)  # 输出：False

字典推导式

# 传统方式
squares = {}
for i in range(1, 6):
    squares[i] = i * i
print(squares)  # 输出：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 字典推导式
squares = {i: i * i for i in range(1, 6)}
print(squares)  # 输出：{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

列表 vs 字典：什么时候用哪个？

场景	推荐使用	原因
存储有序数据	列表	有索引，按顺序访问
存储无序但有关联的数据	字典	用键访问，语义清晰
需要频繁添加删除	列表	操作简单
需要按键查找	字典	查找速度快
数据有重复	列表	允许重复
数据唯一	字典	键唯一

实战小项目1：学生成绩管理系统

# 存储学生成绩
students = [
    {"name": "小明", "score": 85},
    {"name": "小红", "score": 92},
    {"name": "小刚", "score": 78},
    {"name": "小李", "score": 88}
]

# 计算平均分
total_score = sum(student["score"] for student in students)
average_score = total_score / len(students)
print(f"平均分：{average_score:.2f}")

# 找出最高分和最低分
max_score_student = max(students, key=lambda x: x["score"])
min_score_student = min(students, key=lambda x: x["score"])
print(f"最高分：{max_score_student['name']} - {max_score_student['score']}")
print(f"最低分：{min_score_student['name']} - {min_score_student['score']}")

# 排序（按分数降序）
students.sort(key=lambda x: x["score"], reverse=True)
print("\n排名：")
for i, student in enumerate(students, 1):
    print(f"第{i}名：{student['name']} - {student['score']}")

实战小项目2：商品库存管理

# 商品库存
inventory = {
    "苹果": 100,
    "香蕉": 80,
    "橙子": 60,
    "草莓": 40
}

# 查询库存
def check_inventory(product):
    if product in inventory:
        print(f"{product}还有{inventory[product]}个")
    else:
        print(f"没有{product}")

check_inventory("苹果")  # 输出：苹果还有100个
check_inventory("葡萄")  # 输出：没有葡萄

# 出库
def sell_product(product, quantity):
    if product not in inventory:
        print(f"没有{product}！")
        return

    if inventory[product] >= quantity:
        inventory[product] -= quantity
        print(f"卖出{quantity}个{product}，剩余{inventory[product]}个")
    else:
        print(f"{product}库存不足！只有{inventory[product]}个")

sell_product("苹果", 20)  # 输出：卖出20个苹果，剩余80个
sell_product("草莓", 50)  # 输出：草莓库存不足！只有40个

# 入库
def add_product(product, quantity):
    if product in inventory:
        inventory[product] += quantity
    else:
        inventory[product] = quantity
    print(f"{product}入库{quantity}个，当前库存：{inventory[product]}")

add_product("苹果", 30)  # 输出：苹果入库30个，当前库存：110
add_product("葡萄", 50)  # 输出：葡萄入库50个，当前库存：50

# 查看所有库存
def show_all_inventory():
    print("\n当前库存：")
    for product, quantity in inventory.items():
        print(f"{product}: {quantity}")

show_all_inventory()

实战小项目3：词频统计

def count_words(text):
    """统计词频"""
    # 去除标点符号，转小写
    text = text.replace(".", "").replace(",", "").replace("!", "").replace("?", "")
    text = text.lower()

    # 分割单词
    words = text.split()

    # 统计词频
    word_count = {}
    for word in words:
        if word in word_count:
            word_count[word] += 1
        else:
            word_count[word] = 1

    return word_count

text = """
Python is a great programming language. Python is easy to learn.
Python is powerful. I love Python!
"""

word_count = count_words(text)

# 按词频排序
sorted_word_count = sorted(word_count.items(), key=lambda x: x[1], reverse=True)

print("词频统计：")
for word, count in sorted_word_count:
    print(f"{word}: {count}")

常见坑及解决方案

坑1：修改循环中的列表

numbers = [1, 2, 3, 4, 5]

# 错误做法
for num in numbers:
    if num % 2 == 0:
        numbers.remove(num)  # 跳过了后面的元素
print(numbers)  # 输出：[1, 3, 5]（跳过了4）

# 正确做法1：用切片复制
for num in numbers[:]:
    if num % 2 == 0:
        numbers.remove(num)

# 正确做法2：用列表推导式
numbers = [num for num in numbers if num % 2 != 0]

坑2：列表作为默认参数

def add_item(item, items=[]):  # 危险！
    items.append(item)
    return items

print(add_item("apple"))  # 输出：['apple']
print(add_item("banana"))  # 输出：['apple', 'banana']（不是你想要的！）

# 正确做法
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

print(add_item("apple"))  # 输出：['apple']
print(add_item("banana"))  # 输出：['banana']

本章小结

列表：有序数据集合，用索引访问
字典：键值对数据集合，用键访问
列表操作：append()、insert()、extend()、remove()、pop()、sort()、列表推导式
字典操作：访问、添加、删除、keys()、values()、items()、字典推导式
实战项目：学生成绩管理、商品库存管理、词频统计

列表和字典让你能存储和管理各种数据。下一章我们学习文件操作，读写Excel、Word、PDF！

09-文件操作-读写Excel、Word、PDF

Tue, 03 Feb 2026 00:00:00 +0000

别再手动复制粘贴了！

你有没有过这样的经历：

需要从100个Excel表格里提取数据，复制粘贴到天荒地老
需要给1000个Word文档替换文字，打开一个改一个
需要把PDF表格里的数据提取出来，手动抄到Excel

别再假装你会手动完成这些事了，用Python吧！

文件操作是Python最实用的技能之一，让你几秒钟搞定几小时的工作。

文件的基本操作

读取文本文件

# 方法1：open() + close()
file = open("test.txt", "r", encoding="utf-8")  # r表示读取
content = file.read()
print(content)
file.close()

# 方法2：with语句（推荐，自动关闭文件）
with open("test.txt", "r", encoding="utf-8") as file:
    content = file.read()
    print(content)

# 逐行读取
with open("test.txt", "r", encoding="utf-8") as file:
    for line in file:
        line = line.strip()  # 去除换行符
        print(line)

写入文本文件

# 写入文件（覆盖）
with open("output.txt", "w", encoding="utf-8") as file:
    file.write("Hello, World!")
    file.write("Hello, Python!")

# 写入文件（追加）
with open("output.txt", "a", encoding="utf-8") as file:
    file.write("\n新的一行")

# 写入多行
lines = ["第一行", "第二行", "第三行"]
with open("output.txt", "w", encoding="utf-8") as file:
    file.write("\n".join(lines))

文件操作模式

模式	说明	如果文件不存在
`"r"`	只读	报错
`"w"`	只写（覆盖）	创建新文件
`"a"`	追加	创建新文件
`"r+"`	读写	报错
`"w+"`	读写（覆盖）	创建新文件
`"a+"`	读写（追加）	创建新文件

操作Excel

安装库

pip install openpyxl

读取Excel

from openpyxl import load_workbook

# 打开Excel文件
workbook = load_workbook("data.xlsx")

# 获取所有工作表名
print(workbook.sheetnames)  # 输出：['Sheet1', 'Sheet2']

# 选择工作表
sheet = workbook["Sheet1"]

# 读取单个单元格
print(sheet["A1"].value)  # 输出：A1的值
print(sheet.cell(row=1, column=1).value)  # 同上

# 读取多个单元格（行）
for row in sheet.iter_rows(min_row=1, max_row=3, values_only=True):
    print(row)

# 读取所有数据
for row in sheet.iter_rows(values_only=True):
    print(row)

# 读取指定范围
for row in sheet["A1:C3"]:
    for cell in row:
        print(cell.value, end="\t")
    print()

写入Excel

from openpyxl import Workbook

# 创建新的Excel文件
workbook = Workbook()
sheet = workbook.active

# 写入单个单元格
sheet["A1"] = "姓名"
sheet["B1"] = "年龄"
sheet["C1"] = "职业"

# 写入多个单元格
data = [
    ["小明", 25, "程序员"],
    ["小红", 23, "设计师"],
    ["小刚", 28, "产品经理"]
]

for row_data in data:
    sheet.append(row_data)

# 保存文件
workbook.save("output.xlsx")

# 向现有Excel文件添加数据
from openpyxl import load_workbook

workbook = load_workbook("output.xlsx")
sheet = workbook.active

sheet.append(["小李", 30, "运营"])
workbook.save("output.xlsx")

实战：合并多个Excel文件

from openpyxl import load_workbook, Workbook

def merge_excel_files(file_paths, output_path):
    """合并多个Excel文件"""
    # 创建新的Excel文件
    merged_workbook = Workbook()
    merged_sheet = merged_workbook.active
    header_written = False

    for file_path in file_paths:
        # 读取每个Excel文件
        workbook = load_workbook(file_path)
        sheet = workbook.active

        # 读取数据
        for row in sheet.iter_rows(values_only=True):
            if not header_written:
                merged_sheet.append(row)
                header_written = True
            else:
                # 跳过第一个文件后面的文件的表头
                if row[0] != sheet[1].value:
                    merged_sheet.append(row)

        workbook.close()

    # 保存合并后的文件
    merged_workbook.save(output_path)
    print(f"合并完成，保存到 {output_path}")

# 使用示例
file_paths = ["data1.xlsx", "data2.xlsx", "data3.xlsx"]
merge_excel_files(file_paths, "merged.xlsx")

操作Word

安装库

pip install python-docx

读取Word

from docx import Document

# 打开Word文档
doc = Document("document.docx")

# 读取所有段落
for paragraph in doc.paragraphs:
    print(paragraph.text)

# 读取所有表格
for table in doc.tables:
    for row in table.rows:
        for cell in row.cells:
            print(cell.text, end="\t")
        print()

写入Word

from docx import Document

# 创建新的Word文档
doc = Document()

# 添加标题
doc.add_heading('这是一级标题', level=1)
doc.add_heading('这是二级标题', level=2)

# 添加段落
doc.add_paragraph('这是一个普通的段落。')
doc.add_paragraph('这是另一个段落，包含一些文字。')

# 添加格式化文本
paragraph = doc.add_paragraph()
run = paragraph.add_run('这是粗体文字')
run.bold = True
run = paragraph.add_run('，这是斜体文字')
run.italic = True

# 添加列表
doc.add_paragraph('列表项1', style='List Bullet')
doc.add_paragraph('列表项2', style='List Bullet')
doc.add_paragraph('列表项3', style='List Bullet')

# 添加表格
table = doc.add_table(rows=3, cols=3)
table.style = 'Table Grid'

# 填充表格
for i in range(3):
    for j in range(3):
        table.cell(i, j).text = f"单元格{i+1}-{j+1}"

# 保存文档
doc.save("output.docx")

实战：批量替换Word文档中的文字

from docx import Document

def replace_in_word(input_path, output_path, replacements):
    """批量替换Word文档中的文字"""
    doc = Document(input_path)

    # 替换段落中的文字
    for paragraph in doc.paragraphs:
        for old_text, new_text in replacements.items():
            if old_text in paragraph.text:
                paragraph.text = paragraph.text.replace(old_text, new_text)

    # 替换表格中的文字
    for table in doc.tables:
        for row in table.rows:
            for cell in row.cells:
                for paragraph in cell.paragraphs:
                    for old_text, new_text in replacements.items():
                        if old_text in paragraph.text:
                            paragraph.text = paragraph.text.replace(old_text, new_text)

    # 保存文档
    doc.save(output_path)
    print(f"替换完成，保存到 {output_path}")

# 使用示例
replacements = {
    "旧公司名": "新公司名",
    "旧电话": "新电话",
    "旧地址": "新地址"
}

replace_in_word("contract.docx", "contract_new.docx", replacements)

操作PDF

安装库

pip install PyPDF2

读取PDF

from PyPDF2 import PdfReader

# 打开PDF文件
reader = PdfReader("document.pdf")

# 获取页数
print(f"总页数：{len(reader.pages)}")

# 读取第一页
page = reader.pages[0]
print(page.extract_text())

# 读取所有页面
for i, page in enumerate(reader.pages, 1):
    print(f"=== 第{i}页 ===")
    print(page.extract_text())

合并PDF文件

from PyPDF2 import PdfMerger

def merge_pdfs(file_paths, output_path):
    """合并多个PDF文件"""
    merger = PdfMerger()

    for file_path in file_paths:
        merger.append(file_path)

    merger.write(output_path)
    merger.close()
    print(f"合并完成，保存到 {output_path}")

# 使用示例
file_paths = ["file1.pdf", "file2.pdf", "file3.pdf"]
merge_pdfs(file_paths, "merged.pdf")

拆分PDF文件

from PyPDF2 import PdfReader, PdfWriter

def split_pdf(input_path, start_page, end_page, output_path):
    """拆分PDF文件"""
    reader = PdfReader(input_path)
    writer = PdfWriter()

    for page_num in range(start_page - 1, end_page):  # 页码从0开始
        writer.add_page(reader.pages[page_num])

    with open(output_path, "wb") as output_file:
        writer.write(output_file)

    print(f"拆分完成，保存到 {output_path}")

# 使用示例：提取第1-3页
split_pdf("document.pdf", 1, 3, "pages_1_3.pdf")

实战小项目1：自动化处理Excel数据

from openpyxl import load_workbook, Workbook

def process_sales_data(input_path, output_path):
    """处理销售数据，添加统计信息"""
    # 读取数据
    workbook = load_workbook(input_path)
    sheet = workbook.active

    # 获取所有数据
    data = []
    for row in sheet.iter_rows(values_only=True):
        data.append(row)

    # 假设数据格式：[商品名, 单价, 数量]
    # 添加计算列：金额 = 单价 * 数量
    # 跳过表头
    for i, row in enumerate(data[1:], start=2):  # 从第2行开始
        product_name = row[0]
        price = row[1]
        quantity = row[2]
        amount = price * quantity

        # 写入金额
        sheet.cell(row=i, column=4, value=amount)

    # 添加汇总信息
    total_amount = sum(row[3] for row in data[1:])
    last_row = len(data) + 1
    sheet.cell(row=last_row, column=3, value="总金额：")
    sheet.cell(row=last_row, column=4, value=total_amount)

    # 保存文件
    workbook.save(output_path)
    print(f"处理完成，保存到 {output_path}")

# 使用示例
process_sales_data("sales_data.xlsx", "sales_data_processed.xlsx")

实战小项目2：批量生成Word合同

from docx import Document

def generate_contract(template_path, output_path, data):
    """根据模板生成合同"""
    doc = Document(template_path)

    # 替换占位符
    for paragraph in doc.paragraphs:
        for key, value in data.items():
            placeholder = f"{{{key}}}"
            if placeholder in paragraph.text:
                paragraph.text = paragraph.text.replace(placeholder, str(value))

    # 替换表格中的占位符
    for table in doc.tables:
        for row in table.rows:
            for cell in row.cells:
                for paragraph in cell.paragraphs:
                    for key, value in data.items():
                        placeholder = f"{{{key}}}"
                        if placeholder in paragraph.text:
                            paragraph.text = paragraph.text.replace(placeholder, str(value))

    # 保存文档
    doc.save(output_path)
    print(f"合同生成完毕，保存到 {output_path}")

# 使用示例
contract_data = {
    "甲方": "张三",
    "乙方": "李四",
    "合同金额": "100000",
    "签订日期": "2026年2月3日",
    "有效期": "1年"
}

generate_contract("contract_template.docx", "contract_signed.docx", contract_data)

常见坑及解决方案

坑1：忘记关闭文件

# 错误做法
file = open("test.txt", "r")
content = file.read()
# 忘记关闭文件

# 正确做法：用with语句
with open("test.txt", "r") as file:
    content = file.read()
# 自动关闭文件

坑2：编码问题

# 错误做法：可能会报错
with open("test.txt", "r") as file:
    content = file.read()

# 正确做法：指定编码
with open("test.txt", "r", encoding="utf-8") as file:
    content = file.read()

坑3：Excel索引从1开始

from openpyxl import load_workbook

sheet = workbook.active

# 错误做法：索引从0开始
print(sheet[0][0])  # 报错！

# 正确做法：索引从1开始
print(sheet["A1"])  # 或 sheet.cell(row=1, column=1)

本章小结

文本文件：open()、with语句、read()、write()、逐行读取
Excel操作：openpyxl库、读取、写入、合并、处理数据
Word操作：python-docx库、读取、写入、批量替换
PDF操作：PyPDF2库、读取、合并、拆分
实战项目：处理销售数据、批量生成合同

文件操作让你自动化处理各种文档，几秒钟搞定几小时的工作。下一章我们来实战，把学到的知识结合起来做完整的项目！

10-实战项目1-自动整理文件夹

Tue, 03 Feb 2026 00:00:00 +0000

再也不用在10个群里找文件了！

你有没有过这样的经历：

下载文件夹里有几千个文件，找个东西要翻半天
图片、文档、视频混在一起，乱成一锅粥
想把照片按日期整理，一个一个移动累死

别再假装你会手动整理文件夹了，用Python吧！

今天我们做一个自动整理文件夹的工具，几秒钟就能把几千个文件分类整理好。

项目目标

实现一个自动整理文件夹的工具：

自动识别文件类型（图片、文档、视频、音乐等）
按类型把文件移动到对应的文件夹
支持自定义分类规则
支持预览将要执行的操作
可以回滚操作

完整代码

import os
import shutil
from datetime import datetime
import json

class FileOrganizer:
    """文件整理工具"""

    def __init__(self, folder_path):
        self.folder_path = folder_path
        self.operations = []  # 记录所有操作，用于回滚

        # 默认分类规则
        self.rules = {
            "图片": [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg", ".webp"],
            "文档": [".txt", ".doc", ".docx", ".pdf", ".xls", ".xlsx", ".ppt", ".pptx"],
            "视频": [".mp4", ".avi", ".mov", ".mkv", ".flv", ".wmv"],
            "音乐": [".mp3", ".wav", ".flac", ".aac", ".ogg"],
            "压缩包": [".zip", ".rar", ".7z", ".tar", ".gz"],
            "代码": [".py", ".js", ".html", ".css", ".java", ".c", ".cpp"]
        }

        # 加载自定义规则
        self.load_rules()

    def load_rules(self):
        """加载自定义分类规则"""
        rules_file = os.path.join(self.folder_path, "organizer_rules.json")
        if os.path.exists(rules_file):
            try:
                with open(rules_file, "r", encoding="utf-8") as f:
                    self.rules = json.load(f)
                print("已加载自定义分类规则")
            except Exception as e:
                print(f"加载规则失败：{e}")

    def save_rules(self):
        """保存自定义分类规则"""
        rules_file = os.path.join(self.folder_path, "organizer_rules.json")
        try:
            with open(rules_file, "w", encoding="utf-8") as f:
                json.dump(self.rules, f, ensure_ascii=False, indent=2)
            print("分类规则已保存")
        except Exception as e:
            print(f"保存规则失败：{e}")

    def get_file_type(self, filename):
        """根据文件名获取文件类型"""
        _, ext = os.path.splitext(filename.lower())

        for category, extensions in self.rules.items():
            if ext in extensions:
                return category

        return "其他"

    def scan_files(self):
        """扫描文件夹中的所有文件"""
        files_info = []

        for item in os.listdir(self.folder_path):
            item_path = os.path.join(self.folder_path, item)

            # 跳过文件夹
            if os.path.isdir(item_path):
                continue

            # 跳过隐藏文件和规则文件
            if item.startswith(".") or item == "organizer_rules.json":
                continue

            file_type = self.get_file_type(item)
            files_info.append({
                "name": item,
                "type": file_type,
                "path": item_path
            })

        return files_info

    def preview_operations(self, files_info):
        """预览将要执行的操作"""
        if not files_info:
            print("没有需要整理的文件！")
            return

        print("\n=== 预览操作 ===")
        print(f"共找到 {len(files_info)} 个文件需要整理\n")

        # 按类型分组
        type_groups = {}
        for file_info in files_info:
            file_type = file_info["type"]
            if file_type not in type_groups:
                type_groups[file_type] = []
            type_groups[file_type].append(file_info)

        # 显示每个类型的文件
        for file_type, files in type_groups.items():
            target_folder = os.path.join(self.folder_path, file_type)
            print(f"\n【{file_type}】 -> {target_folder}")
            for file_info in files:
                print(f"  - {file_info['name']}")

        return type_groups

    def organize(self, dry_run=False):
        """整理文件"""
        if not os.path.exists(self.folder_path):
            print(f"文件夹不存在：{self.folder_path}")
            return False

        # 扫描文件
        files_info = self.scan_files()
        if not files_info:
            print("没有需要整理的文件！")
            return False

        # 预览操作
        type_groups = self.preview_operations(files_info)

        if dry_run:
            print("\n【预览模式】不会实际执行操作")
            return True

        # 确认操作
        print("\n=== 开始整理 ===")
        confirm = input("确定要整理吗？（输入yes确认）：")
        if confirm.lower() != "yes":
            print("操作已取消")
            return False

        # 执行整理
        success_count = 0
        error_count = 0

        for file_type, files in type_groups.items():
            # 创建目标文件夹
            target_folder = os.path.join(self.folder_path, file_type)
            os.makedirs(target_folder, exist_ok=True)

            # 移动文件
            for file_info in files:
                try:
                    old_path = file_info["path"]
                    new_path = os.path.join(target_folder, file_info["name"])

                    # 检查文件是否已存在
                    if os.path.exists(new_path):
                        print(f"跳过（文件已存在）：{file_info['name']}")
                        continue

                    # 移动文件
                    shutil.move(old_path, new_path)

                    # 记录操作（用于回滚）
                    self.operations.append({
                        "old_path": old_path,
                        "new_path": new_path,
                        "timestamp": datetime.now().isoformat()
                    })

                    print(f"移动：{file_info['name']} -> {file_type}/")
                    success_count += 1

                except Exception as e:
                    print(f"移动失败 {file_info['name']}：{e}")
                    error_count += 1

        # 保存操作记录
        self.save_operations()

        print(f"\n整理完成！成功：{success_count}，失败：{error_count}")
        return True

    def save_operations(self):
        """保存操作记录"""
        if not self.operations:
            return

        record_file = os.path.join(self.folder_path, "organizer_record.json")
        try:
            with open(record_file, "w", encoding="utf-8") as f:
                json.dump(self.operations, f, ensure_ascii=False, indent=2)
            print(f"操作记录已保存到：{record_file}")
        except Exception as e:
            print(f"保存操作记录失败：{e}")

    def rollback(self):
        """回滚操作"""
        record_file = os.path.join(self.folder_path, "organizer_record.json")

        if not os.path.exists(record_file):
            print("没有找到操作记录，无法回滚")
            return

        try:
            with open(record_file, "r", encoding="utf-8") as f:
                operations = json.load(f)

            if not operations:
                print("没有可回滚的操作")
                return

            print(f"\n=== 回滚操作 ===")
            print(f"共找到 {len(operations)} 个操作需要回滚")

            confirm = input("确定要回滚吗？（输入yes确认）：")
            if confirm.lower() != "yes":
                print("回滚已取消")
                return

            success_count = 0
            error_count = 0

            for op in reversed(operations):
                try:
                    old_path = op["old_path"]
                    new_path = op["new_path"]

                    if os.path.exists(new_path):
                        shutil.move(new_path, old_path)
                        print(f"回滚：{os.path.basename(new_path)}")
                        success_count += 1
                    else:
                        print(f"跳过（文件不存在）：{os.path.basename(new_path)}")

                except Exception as e:
                    print(f"回滚失败：{e}")
                    error_count += 1

            print(f"\n回滚完成！成功：{success_count}，失败：{error_count}")

            # 删除操作记录
            os.remove(record_file)
            print("操作记录已删除")

        except Exception as e:
            print(f"回滚失败：{e}")

    def add_rule(self, category, extensions):
        """添加分类规则"""
        extensions = [ext if ext.startswith(".") else f".{ext}" for ext in extensions]

        if category not in self.rules:
            self.rules[category] = []

        for ext in extensions:
            if ext not in self.rules[category]:
                self.rules[category].append(ext)

        self.save_rules()
        print(f"已添加规则：【{category}】{extensions}")

    def remove_rule(self, category, extensions):
        """删除分类规则"""
        if category not in self.rules:
            print(f"分类【{category}】不存在")
            return

        for ext in extensions:
            ext = ext if ext.startswith(".") else f".{ext}"
            if ext in self.rules[category]:
                self.rules[category].remove(ext)

        # 如果分类下没有扩展名了，删除分类
        if not self.rules[category]:
            del self.rules[category]

        self.save_rules()
        print(f"已删除规则：【{category}】{extensions}")

    def show_rules(self):
        """显示所有分类规则"""
        print("\n=== 当前分类规则 ===")
        for category, extensions in self.rules.items():
            print(f"\n【{category}】")
            for ext in extensions:
                print(f"  - {ext}")


def main():
    """主函数"""
    print("=== 文件整理工具 ===\n")

    # 输入文件夹路径
    folder_path = input("请输入要整理的文件夹路径（直接回车使用当前目录）：")
    if not folder_path.strip():
        folder_path = os.getcwd()
        print(f"使用当前目录：{folder_path}")

    # 创建整理工具
    organizer = FileOrganizer(folder_path)

    while True:
        print("\n=== 主菜单 ===")
        print("1. 预览操作")
        print("2. 开始整理")
        print("3. 回滚操作")
        print("4. 查看分类规则")
        print("5. 添加分类规则")
        print("6. 删除分类规则")
        print("7. 退出")

        choice = input("\n请选择操作（1-7）：")

        if choice == "1":
            files_info = organizer.scan_files()
            organizer.preview_operations(files_info)

        elif choice == "2":
            dry_run = input("是否只预览不执行？（yes/no）：").lower() == "yes"
            organizer.organize(dry_run)

        elif choice == "3":
            organizer.rollback()

        elif choice == "4":
            organizer.show_rules()

        elif choice == "5":
            category = input("请输入分类名称：")
            extensions = input("请输入扩展名（用空格分隔，如 jpg png）：").split()
            organizer.add_rule(category, extensions)

        elif choice == "6":
            category = input("请输入分类名称：")
            extensions = input("请输入要删除的扩展名（用空格分隔）：").split()
            organizer.remove_rule(category, extensions)

        elif choice == "7":
            print("退出程序！")
            break

        else:
            print("无效的选择，请重新输入")


if __name__ == "__main__":
    main()

使用示例

1. 整理下载文件夹

# 简单使用
organizer = FileOrganizer("/Users/yourname/Downloads")
organizer.organize()

2. 预览操作

organizer = FileOrganizer("/Users/yourname/Downloads")
organizer.organize(dry_run=True)  # 只预览，不执行

3. 自定义分类规则

organizer = FileOrganizer("/Users/yourname/Downloads")

# 添加新的分类
organizer.add_rule("设计文件", ["psd", "ai", "sketch"])

# 删除规则
organizer.remove_rule("图片", ["bmp", "svg"])

4. 回滚操作

organizer = FileOrganizer("/Users/yourname/Downloads")
organizer.rollback()

进阶功能：按日期整理照片

import os
import shutil
from datetime import datetime

def organize_photos_by_date(folder_path):
    """按日期整理照片"""
    image_extensions = [".jpg", ".jpeg", ".png", ".heic"]

    for filename in os.listdir(folder_path):
        filepath = os.path.join(folder_path, filename)

        # 跳过文件夹
        if not os.path.isfile(filepath):
            continue

        # 只处理图片文件
        _, ext = os.path.splitext(filename.lower())
        if ext not in image_extensions:
            continue

        # 获取文件修改时间
        file_time = os.path.getmtime(filepath)
        date = datetime.fromtimestamp(file_time)
        date_folder = date.strftime("%Y-%m-%d")

        # 创建日期文件夹
        target_folder = os.path.join(folder_path, date_folder)
        os.makedirs(target_folder, exist_ok=True)

        # 移动文件
        target_path = os.path.join(target_folder, filename)
        shutil.move(filepath, target_path)

        print(f"移动：{filename} -> {date_folder}/")

    print("整理完成！")

# 使用示例
organize_photos_by_date("/Users/yourname/Photos")

本章小结

自动整理文件夹：识别文件类型、按分类移动文件
预览操作：查看将要执行的操作，避免误操作
回滚功能：支持撤销操作，不用担心整理错了
自定义规则：可以添加自己的分类规则
进阶功能：按日期整理照片

这个工具可以帮你每天节省30分钟整理文件的时间！下一章我们来批量处理Excel，再也不加班！

11-实战项目2-批量处理Excel

Tue, 03 Feb 2026 00:00:00 +0000

每天节省2小时重复劳动！

你有没有过这样的经历：

需要从10个Excel表格里汇总数据，复制粘贴到天荒地老
需要给100个Excel表格添加统一的格式，打开一个改一个
需要根据条件筛选数据，手动筛选到崩溃

别再假装你会手动处理Excel了，用Python吧！

今天我们做一个Excel批量处理工具，几秒钟搞定几小时的工作。

项目目标

实现一个Excel批量处理工具：

批量合并多个Excel文件
批量格式化Excel（设置列宽、字体、颜色等）
批量添加公式和计算列
批量筛选数据
生成数据统计报告

准备工作

安装所需库：

pip install openpyxl pandas

工具1：批量合并Excel文件

import os
from openpyxl import load_workbook, Workbook

def merge_excel_files(file_paths, output_path, skip_rows=0):
    """
    批量合并多个Excel文件

    Args:
        file_paths: Excel文件路径列表
        output_path: 输出文件路径
        skip_rows: 跳过每个文件的行数（用于跳过表头）
    """
    # 创建新的Excel文件
    merged_workbook = Workbook()
    merged_sheet = merged_workbook.active
    merged_sheet.title = "合并数据"

    row_index = 1

    for i, file_path in enumerate(file_paths):
        print(f"正在处理第{i+1}/{len(file_paths)}个文件：{os.path.basename(file_path)}")

        try:
            # 读取Excel文件
            workbook = load_workbook(file_path)
            sheet = workbook.active

            # 读取数据
            for row in sheet.iter_rows(min_row=skip_rows + 1, values_only=True):
                if row[0] is not None:  # 跳过空行
                    # 写入数据
                    for col_index, cell_value in enumerate(row, 1):
                        merged_sheet.cell(row=row_index, column=col_index, value=cell_value)
                    row_index += 1

            workbook.close()
            print(f"  - 成功读取 {sheet.max_row} 行数据")

        except Exception as e:
            print(f"  - 读取失败：{e}")

    # 保存文件
    merged_workbook.save(output_path)
    print(f"\n合并完成！共 {row_index - 1} 行数据")
    print(f"保存到：{output_path}")

def merge_folder_excel_files(folder_path, output_path, pattern="*.xlsx"):
    """
    合并文件夹下的所有Excel文件

    Args:
        folder_path: 文件夹路径
        output_path: 输出文件路径
        pattern: 文件匹配模式
    """
    import glob

    # 获取所有Excel文件
    file_paths = glob.glob(os.path.join(folder_path, pattern))

    if not file_paths:
        print("没有找到Excel文件！")
        return

    print(f"找到 {len(file_paths)} 个Excel文件")
    merge_excel_files(file_paths, output_path)

# 使用示例
if __name__ == "__main__":
    # 合并指定文件
    file_paths = [
        "data/sales_1月.xlsx",
        "data/sales_2月.xlsx",
        "data/sales_3月.xlsx"
    ]
    merge_excel_files(file_paths, "output/合并销售数据.xlsx", skip_rows=1)

    # 合并文件夹下的所有Excel
    # merge_folder_excel_files("data", "output/全部数据.xlsx")

工具2：批量格式化Excel

from openpyxl import load_workbook
from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
from openpyxl.utils import get_column_letter

def format_excel(input_path, output_path):
    """
    格式化Excel文件

    功能：
    - 设置标题行样式
    - 自动调整列宽
    - 添加边框
    - 设置对齐方式
    - 添加条件格式
    """
    # 读取Excel文件
    workbook = load_workbook(input_path)
    sheet = workbook.active

    # 定义样式
    header_font = Font(name="微软雅黑", size=12, bold=True, color="FFFFFF")
    header_fill = PatternFill(start_color="4472C4", end_color="4472C4", fill_type="solid")
    header_alignment = Alignment(horizontal="center", vertical="center")

    body_font = Font(name="微软雅黑", size=10)
    body_alignment = Alignment(horizontal="center", vertical="center")

    thin_border = Border(
        left=Side(style='thin', color='000000'),
        right=Side(style='thin', color='000000'),
        top=Side(style='thin', color='000000'),
        bottom=Side(style='thin', color='000000')
    )

    # 格式化标题行
    for cell in sheet[1]:
        cell.font = header_font
        cell.fill = header_fill
        cell.alignment = header_alignment
        cell.border = thin_border

    # 格式化数据行
    for row in sheet.iter_rows(min_row=2):
        for cell in row:
            cell.font = body_font
            cell.alignment = body_alignment
            cell.border = thin_border

    # 自动调整列宽
    for col in range(1, sheet.max_column + 1):
        max_length = 0
        column = get_column_letter(col)

        # 计算该列的最大宽度
        for row in range(1, sheet.max_row + 1):
            cell = sheet[f"{column}{row}"]
            try:
                if cell.value:
                    max_length = max(max_length, len(str(cell.value)))
            except:
                pass

        # 设置列宽（留一些余量）
        adjusted_width = min(max_length + 2, 50)
        sheet.column_dimensions[column].width = adjusted_width

    # 冻结首行
    sheet.freeze_panes = "A2"

    # 保存文件
    workbook.save(output_path)
    print(f"格式化完成！保存到：{output_path}")

# 使用示例
if __name__ == "__main__":
    format_excel("data/sales_data.xlsx", "output/销售数据_已格式化.xlsx")

工具3：批量添加计算列

from openpyxl import load_workbook

def add_calculated_column(input_path, output_path, formulas):
    """
    批量添加计算列

    Args:
        input_path: 输入文件路径
        output_path: 输出文件路径
        formulas: 计算列配置列表
            [
                {
                    "column": "D",  # 列名
                    "header": "金额",  # 表头名称
                    "formula": "=B*C"  # 公式（使用列号）
                }
            ]
    """
    workbook = load_workbook(input_path)
    sheet = workbook.active

    for config in formulas:
        column = config["column"]
        header = config["header"]
        formula = config["formula"]

        # 添加表头
        sheet[f"{column}1"] = header

        # 添加公式
        for row in range(2, sheet.max_row + 1):
            cell = sheet[f"{column}{row}"]
            cell.value = formula

        print(f"已添加列【{column}】：{header}")

    # 保存文件
    workbook.save(output_path)
    print(f"计算列添加完成！保存到：{output_path}")

# 使用示例
if __name__ == "__main__":
    formulas = [
        {
            "column": "D",
            "header": "金额",
            "formula": "=B2*C2"
        },
        {
            "column": "E",
            "header": "税率",
            "formula": "=D2*0.1"
        }
    ]

    # 注意：公式需要根据实际行号调整
    # 这里简化处理，实际应用中需要动态生成公式
    add_calculated_column(
        "data/product_list.xlsx",
        "output/product_list_计算.xlsx",
        formulas
    )

工具4：批量筛选数据

from openpyxl import load_workbook, Workbook

def filter_excel(input_path, output_path, filters):
    """
    批量筛选Excel数据

    Args:
        input_path: 输入文件路径
        output_path: 输出文件路径
        filters: 筛选条件列表
            [
                {
                    "column": "C",  # 列名
                    "operator": ">",  # 操作符：>, <, =, >=, <=, !=
                    "value": 100  # 值
                }
            ]
    """
    # 读取数据
    workbook = load_workbook(input_path)
    sheet = workbook.active

    # 读取表头
    headers = [cell.value for cell in sheet[1]]

    # 筛选数据
    filtered_rows = []

    for row in sheet.iter_rows(min_row=2, values_only=True):
        # 默认包含该行
        include = True

        # 检查所有筛选条件
        for filter_config in filters:
            column = filter_config["column"]
            operator = filter_config["operator"]
            value = filter_config["value"]

            # 获取列号
            col_index = ord(column.upper()) - ord("A")

            # 获取单元格值
            cell_value = row[col_index]

            # 执行筛选
            try:
                cell_value = float(cell_value) if cell_value is not None else 0
                value = float(value)

                if operator == ">" and not (cell_value > value):
                    include = False
                    break
                elif operator == "<" and not (cell_value < value):
                    include = False
                    break
                elif operator == "=" and not (cell_value == value):
                    include = False
                    break
                elif operator == ">=" and not (cell_value >= value):
                    include = False
                    break
                elif operator == "<=" and not (cell_value <= value):
                    include = False
                    break
                elif operator == "!=" and not (cell_value != value):
                    include = False
                    break
            except:
                include = False
                break

        if include:
            filtered_rows.append(row)

    # 创建新文件
    filtered_workbook = Workbook()
    filtered_sheet = filtered_workbook.active

    # 写入表头
    for col, header in enumerate(headers, 1):
        filtered_sheet.cell(row=1, column=col, value=header)

    # 写入筛选后的数据
    for row_index, row_data in enumerate(filtered_rows, 2):
        for col, value in enumerate(row_data, 1):
            filtered_sheet.cell(row=row_index, column=col, value=value)

    # 保存文件
    filtered_workbook.save(output_path)
    print(f"筛选完成！保留 {len(filtered_rows)} 行数据")
    print(f"保存到：{output_path}")

# 使用示例
if __name__ == "__main__":
    filters = [
        {
            "column": "D",  # D列（金额）
            "operator": ">",
            "value": 1000  # 金额大于1000
        }
    ]

    filter_excel(
        "data/sales_data.xlsx",
        "output/销售数据_筛选.xlsx",
        filters
    )

工具5：生成数据统计报告

from openpyxl import load_workbook, Workbook
from openpyxl.styles import Font, PatternFill, Alignment
import statistics

def generate_statistics(input_path, output_path):
    """生成数据统计报告"""
    # 读取数据
    workbook = load_workbook(input_path)
    sheet = workbook.active

    # 读取所有数据
    data = list(sheet.iter_rows(values_only=True))
    headers = data[0]  # 第一行是表头
    rows = data[1:]  # 其他是数据

    # 创建报告
    report_workbook = Workbook()
    report_sheet = report_workbook.active
    report_sheet.title = "统计报告"

    # 设置标题样式
    title_font = Font(name="微软雅黑", size=16, bold=True)
    header_font = Font(name="微软雅黑", size=12, bold=True)
    header_fill = PatternFill(start_color="4472C4", end_color="4472C4", fill_type="solid")
    header_alignment = Alignment(horizontal="center", vertical="center")

    # 写入标题
    report_sheet["A1"] = "数据统计报告"
    report_sheet["A1"].font = title_font
    report_sheet.merge_cells("A1:E1")

    # 写入基本信息
    report_sheet["A3"] = "统计时间："
    report_sheet["B3"] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    report_sheet["A4"] = "总行数："
    report_sheet["B4"] = len(rows)

    # 写入各列统计信息
    row_index = 6
    report_sheet["A6"] = "列名"
    report_sheet["B6"] = "数据类型"
    report_sheet["C6"] = "非空数量"
    report_sheet["D6"] = "最小值"
    report_sheet["E6"] = "最大值"
    report_sheet["F6"] = "平均值"

    # 设置表头样式
    for col in ["A", "B", "C", "D", "E", "F"]:
        cell = report_sheet[f"{col}6"]
        cell.font = header_font
        cell.fill = header_fill
        cell.alignment = header_alignment

    # 统计每一列
    for col_index, header in enumerate(headers, 1):
        col_letter = chr(ord("A") + col_index - 1)

        # 获取该列所有数据
        col_data = [row[col_index - 1] for row in rows]

        # 统计非空数量
        non_null_count = sum(1 for value in col_data if value is not None)

        # 判断数据类型
        sample = col_data[0] if col_data else None
        if isinstance(sample, (int, float)):
            data_type = "数字"
            min_value = min(col_data) if col_data else ""
            max_value = max(col_data) if col_data else ""
            avg_value = statistics.mean(col_data) if col_data else ""
        else:
            data_type = "文本"
            min_value = ""
            max_value = ""
            avg_value = ""

        # 写入统计信息
        row_index += 1
        report_sheet[f"A{row_index}"] = header
        report_sheet[f"B{row_index}"] = data_type
        report_sheet[f"C{row_index}"] = non_null_count
        report_sheet[f"D{row_index}"] = min_value
        report_sheet[f"E{row_index}"] = max_value
        report_sheet[f"F{row_index}"] = round(avg_value, 2) if avg_value else ""

    # 保存报告
    report_workbook.save(output_path)
    print(f"统计报告生成完成！保存到：{output_path}")

# 使用示例
if __name__ == "__main__":
    import datetime

    generate_statistics(
        "data/sales_data.xlsx",
        "output/统计报告.xlsx"
    )

完整工具集

class ExcelProcessor:
    """Excel批量处理工具集"""

    def __init__(self):
        pass

    def merge_files(self, file_paths, output_path, skip_rows=0):
        """合并多个Excel文件"""
        merge_excel_files(file_paths, output_path, skip_rows)

    def format_file(self, input_path, output_path):
        """格式化Excel文件"""
        format_excel(input_path, output_path)

    def add_calculations(self, input_path, output_path, formulas):
        """添加计算列"""
        add_calculated_column(input_path, output_path, formulas)

    def filter_data(self, input_path, output_path, filters):
        """筛选数据"""
        filter_excel(input_path, output_path, filters)

    def generate_report(self, input_path, output_path):
        """生成统计报告"""
        generate_statistics(input_path, output_path)


# 使用示例
if __name__ == "__main__":
    processor = ExcelProcessor()

    # 一键完成所有操作
    input_file = "data/sales_data.xlsx"

    # 1. 格式化
    processor.format_file(input_file, "output/1_已格式化.xlsx")

    # 2. 筛选
    filters = [{"column": "D", "operator": ">", "value": 1000}]
    processor.filter_data("output/1_已格式化.xlsx", "output/2_已筛选.xlsx", filters)

    # 3. 生成报告
    processor.generate_report("output/2_已筛选.xlsx", "output/3_统计报告.xlsx")

    print("所有操作完成！")

本章小结

批量合并Excel：自动合并多个Excel文件
批量格式化：设置列宽、字体、颜色、边框
添加计算列：自动添加公式和计算字段
批量筛选：根据条件筛选数据
生成报告：自动生成数据统计报告

这个工具可以帮你每天节省2小时处理Excel的时间！下一章我们来学习自动发送邮件，装X利器！

12-实战项目3-自动发邮件

Tue, 03 Feb 2026 00:00:00 +0000

再也不用记着发邮件了！

你有没有过这样的经历：

每天要定时给客户发日报，忘了就被老板骂
需要给100个人发相同的邮件，一个个手动发到手抽筋
需要根据不同的人发送不同的内容，复制粘贴到眼花

别再假装你会手动发邮件了，用Python吧！

今天我们做一个自动发邮件的工具，设置一次，终身受益。

准备工作

1. 开启邮箱的SMTP服务

以QQ邮箱为例：

登录QQ邮箱
点击"设置" -> “账户”
找到"POP3/IMAP/SMTP/Exchange/CardDAV/CalDAV服务"
开启"POP3/SMTP服务"
按照提示发送短信验证
保存授权码（非常重要！）

以网易163邮箱为例：

登录163邮箱
点击"设置" -> “POP3/SMTP/IMAP”
开启"POP3/SMTP服务"
按照提示设置授权密码
保存授权密码

2. 安装库

Python 3.6+ 已经内置了smtplib，不需要额外安装。

基础：发送纯文本邮件

import smtplib
from email.mime.text import MIMEText
from email.header import Header

def send_text_email(sender_email, sender_password, receiver_email, subject, content):
    """
    发送纯文本邮件

    Args:
        sender_email: 发件人邮箱
        sender_password: 邮箱授权码（不是登录密码！）
        receiver_email: 收件人邮箱
        subject: 邮件主题
        content: 邮件内容
    """
    # 邮件服务器配置
    smtp_server = "smtp.qq.com"  # QQ邮箱的SMTP服务器
    smtp_port = 465  # QQ邮箱的SMTP端口

    try:
        # 创建邮件对象
        message = MIMEText(content, "plain", "utf-8")

        # 设置邮件头
        message["From"] = sender_email
        message["To"] = receiver_email
        message["Subject"] = Header(subject, "utf-8")

        # 连接SMTP服务器
        with smtplib.SMTP_SSL(smtp_server, smtp_port) as server:
            server.login(sender_email, sender_password)
            server.sendmail(sender_email, receiver_email, message.as_string())

        print(f"邮件发送成功！收件人：{receiver_email}")

    except Exception as e:
        print(f"邮件发送失败：{e}")


# 使用示例
if __name__ == "__main__":
    sender_email = "your_email@qq.com"
    sender_password = "your_authorization_code"  # 授权码，不是登录密码！
    receiver_email = "receiver@example.com"
    subject = "测试邮件"
    content = """
    你好！

    这是一封用Python自动发送的测试邮件。

    祝好！
    """

    send_text_email(sender_email, sender_password, receiver_email, subject, content)

实战：自动发送日报

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.header import Header
from datetime import datetime
import os

def send_daily_report(sender_email, sender_password, receiver_email, data, attachment_path=None):
    """
    发送日报

    Args:
        sender_email: 发件人邮箱
        sender_password: 邮箱授权码
        receiver_email: 收件人邮箱（可以是列表）
        data: 日报数据字典
        attachment_path: 附件路径（可选）
    """
    smtp_server = "smtp.qq.com"
    smtp_port = 465

    try:
        # 生成日报内容
        report_date = data.get("date", datetime.now().strftime("%Y-%m-%d"))
        content = f"""
        日报日期：{report_date}
        姓名：{data.get('name', '')}

        【今日工作】
        """ + "\n        ".join(f"- {task}" for task in data.get("tasks", [])) + f"""

        【工作进度】
        {data.get('progress', '')}

        【遇到的问题】
        """ + "\n        ".join(f"- {problem}" for problem in data.get("problems", [])) + f"""

        【明日计划】
        """ + "\n        ".join(f"- {plan}" for plan in data.get("tomorrow", []))

        # 创建邮件对象
        message = MIMEMultipart()

        # 设置邮件头
        message["From"] = sender_email
        if isinstance(receiver_email, list):
            message["To"] = ", ".join(receiver_email)
        else:
            message["To"] = receiver_email
        message["Subject"] = Header(f"日报 - {data.get('name', '')} - {report_date}", "utf-8")

        # 添加邮件正文
        message.attach(MIMEText(content, "plain", "utf-8"))

        # 连接SMTP服务器
        with smtplib.SMTP_SSL(smtp_server, smtp_port) as server:
            server.login(sender_email, sender_password)
            if isinstance(receiver_email, list):
                server.sendmail(sender_email, receiver_email, message.as_string())
            else:
                server.sendmail(sender_email, receiver_email, message.as_string())

        print(f"日报发送成功！")

    except Exception as e:
        print(f"日报发送失败：{e}")


# 使用示例
if __name__ == "__main__":
    sender_email = "your_email@qq.com"
    sender_password = "your_authorization_code"
    receiver_email = ["boss@example.com"]

    # 日报数据
    report_data = {
        "name": "张三",
        "date": datetime.now().strftime("%Y-%m-%d"),
        "tasks": ["完成用户模块开发", "修复登录bug"],
        "progress": "用户模块开发完成80%",
        "problems": ["部分用户反馈页面加载慢"],
        "tomorrow": ["完成用户模块开发", "优化页面加载速度"]
    }

    send_daily_report(sender_email, sender_password, receiver_email, report_data)

常见问题

1. 授权码 vs 登录密码

一定要注意：SMTP需要的是授权码，不是登录密码！

13-实战项目4-爬取网页数据

Tue, 03 Feb 2026 00:00:00 +0000

信息差就是钱！

你有没有过这样的经历：

想统计某个网站的商品价格，手动记录到崩溃
想批量下载图片，一个一个右键保存到吐血
想获取竞争对手的数据，手动复制粘贴到天荒地老

别再假装你会手动收集数据了，用Python吧！

今天我们做一个网页爬虫，自动获取网页数据，信息差就是钱！

准备工作

安装所需库：

pip install requests beautifulsoup4

基础：获取网页内容

import requests

def get_webpage(url):
    """
    获取网页内容

    Args:
        url: 网页URL

    Returns:
        网页HTML内容
    """
    try:
        # 设置请求头（模拟浏览器）
        headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
        }

        # 发送请求
        response = requests.get(url, headers=headers)

        # 检查状态码
        if response.status_code == 200:
            print(f"成功获取网页：{url}")
            return response.text
        else:
            print(f"请求失败，状态码：{response.status_code}")
            return None

    except Exception as e:
        print(f"请求失败：{e}")
        return None


# 使用示例
if __name__ == "__main__":
    url = "https://www.example.com"
    html = get_webpage(url)

    if html:
        print(html[:500])  # 打印前500个字符

进阶：解析HTML提取数据

from bs4 import BeautifulSoup

def parse_html(html):
    """
    解析HTML提取数据

    Args:
        html: HTML字符串

    Returns:
        提取的数据
    """
    # 创建BeautifulSoup对象
    soup = BeautifulSoup(html, "html.parser")

    # 提取标题
    title = soup.title.string
    print(f"网页标题：{title}")

    # 提取所有链接
    print("\n所有链接：")
    for link in soup.find_all("a"):
        href = link.get("href")
        text = link.string
        if href and text:
            print(f"  - {text}: {href}")

    # 提取所有图片
    print("\n所有图片：")
    for img in soup.find_all("img"):
        src = img.get("src")
        alt = img.get("alt", "")
        if src:
            print(f"  - {alt}: {src}")


# 使用示例
if __name__ == "__main__":
    import requests

    url = "https://www.example.com"
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
    }

    response = requests.get(url, headers=headers)
    if response.status_code == 200:
        parse_html(response.text)

实战：爬取新闻标题

import requests
from bs4 import BeautifulSoup
import json

def crawl_news(url):
    """
    爬取新闻标题

    Args:
        url: 新闻网站URL

    Returns:
        新闻列表
    """
    try:
        headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
        }

        # 发送请求
        response = requests.get(url, headers=headers)

        if response.status_code != 200:
            print(f"请求失败，状态码：{response.status_code}")
            return []

        # 解析HTML
        soup = BeautifulSoup(response.text, "html.parser")

        # 提取新闻标题（这里需要根据实际网页结构修改）
        news_list = []

        # 示例：提取所有h2标题
        for item in soup.find_all("h2"):
            title = item.string
            link = item.find("a")

            if title and link:
                news_list.append({
                    "title": title,
                    "link": link.get("href")
                })

        return news_list

    except Exception as e:
        print(f"爬取失败：{e}")
        return []


def save_news(news_list, filename):
    """
    保存新闻到JSON文件

    Args:
        news_list: 新闻列表
        filename: 文件名
    """
    with open(filename, "w", encoding="utf-8") as f:
        json.dump(news_list, f, ensure_ascii=False, indent=2)

    print(f"新闻已保存到：{filename}")


# 使用示例
if __name__ == "__main__":
    url = "https://www.example.com/news"  # 替换成实际的新闻网站
    news_list = crawl_news(url)

    print(f"\n共爬取 {len(news_list)} 条新闻")
    for news in news_list[:10]:  # 只显示前10条
        print(f"- {news['title']}")

    save_news(news_list, "news.json")

实战：批量下载图片

import requests
import os
from urllib.parse import urljoin

def download_images(url, save_folder="images"):
    """
    批量下载网页图片

    Args:
        url: 网页URL
        save_folder: 保存文件夹
    """
    try:
        headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
        }

        # 获取网页
        response = requests.get(url, headers=headers)
        if response.status_code != 200:
            print(f"请求失败，状态码：{response.status_code}")
            return

        # 解析HTML
        soup = BeautifulSoup(response.text, "html.parser")

        # 创建保存文件夹
        os.makedirs(save_folder, exist_ok=True)

        # 找到所有图片
        images = soup.find_all("img")
        print(f"找到 {len(images)} 张图片")

        # 下载图片
        for i, img in enumerate(images, 1):
            src = img.get("src")

            if not src:
                continue

            # 转换成绝对URL
            img_url = urljoin(url, src)

            try:
                # 下载图片
                img_response = requests.get(img_url, headers=headers)

                if img_response.status_code == 200:
                    # 提取文件扩展名
                    ext = os.path.splitext(img_url)[1]
                    if not ext:
                        ext = ".jpg"

                    # 保存图片
                    filename = f"image_{i:03d}{ext}"
                    filepath = os.path.join(save_folder, filename)

                    with open(filepath, "wb") as f:
                        f.write(img_response.content)

                    print(f"  [{i}/{len(images)}] 下载成功：{filename}")

            except Exception as e:
                print(f"  [{i}/{len(images)}] 下载失败：{e}")

        print(f"\n图片已保存到：{save_folder}")

    except Exception as e:
        print(f"下载失败：{e}")


# 使用示例
if __name__ == "__main__":
    url = "https://www.example.com"  # 替换成实际的网页
    download_images(url, "downloaded_images")

注意事项

1. 遵守robots.txt

爬取前先查看网站的robots.txt文件，了解哪些页面可以爬取。

读《传习录》心得

Fri, 14 Nov 2025 00:00:00 +0000

王阳明的“不怕鬼”心法：通俗解读

> 原文摘录
> 王阳明说：
> “平日不能行善积德，而心有所疑惑，因此害怕。
> 如果平时行为与神明相合，有什么可怕的。”
> 又说：
> “写邪恶的鬼不能迷惑正直的人。
> 只要有害怕，就是心地不正；
> 如果有被迷惑的情况，不是鬼迷惑他，而是被自己的心迷惑了。”

一、到底在怕什么？

情况	原因	王阳明给的“诊断”
怕鬼、怕报应	平时没干好事，心里发虚	“疑”——自己都不认可自己

一句话总结：
怕，是因为心里有鬼，不是外面有鬼。

二、“不怕”的底气从哪来？

做法	效果	王阳明给的“药方”
日常行善	心里踏实	“行为与神明相合”
对得起良心	半夜敲门也不惊	“有什么可怕的？”

一句话总结：
白天不做亏心事，半夜不怕鬼敲门——把“鬼”换成“良心”也一样。

三、鬼真能迷惑人吗？

谁迷惑你？	真相	王阳明给的“提醒”
鬼	背锅侠	“邪恶的鬼不能迷惑正直的人”
自己	真凶	“被自己的心迷惑了”

一句话总结：
鬼不吓人，吓人的是自己的歪心思；
心正了，鬼都失业。

四、普通人怎么用？

每天做一件小小好事
让座、说句谢谢、不撒谎，都算。
睡前10秒自检
问自己：“今天哪件事要是被全网知道，我会脸红吗？”
脸不红，就睡踏实。
怕的时候先照心
先别怪“风水”“鬼神”，先问自己：
“我是不是在哪件事上亏心了？”
把亏心的地方补上，怕就少了。

五、一个口诀记住

心正 ——> 不怕心歪 ——> 生“鬼”

终极版一句话：
世上没有鬼，只有“心鬼”；
把“心鬼”修好，人就踏实了。

读《传习录》心得

Thu, 13 Nov 2025 00:00:00 +0000

王阳明的读书与做人道理

一、读书：别光啃字句，先动"心"

核心观点：读书不是背解释、抠字眼，而是"用心体会"。
通俗比喻：像吃橘子，光研究成分表不顶用，得亲口尝一尝才知道酸甜。
结论：解释得再明白，心没动，等于没读；心一动，哪怕一句话也能点亮自己。

二、做人：善恶开关就在"心"

心=理：天理不在天边，就在自己心里。
善人/恶人区别：
- 善人：心保持本来面貌，像干净镜子。
- 恶人：镜子被灰尘（私欲）遮住，照啥都歪。
一句话：改造命运先擦心镜，别急着改外表。

三、万变不离其"性"

性=心=理：三词一个意思，都是指"人的本来样子"。
生活场景自动切换：
- 见到爸 → 孝自然出现
- 见到领导 → 忠自然出现
- 见到朋友 → 信自然出现
公式：把"性"这个字搞明白，万千道理一键直达，无需外挂。

四、行动清单（拿就能用）

读书时先合上书，问"我有没有被触动？"——有触动才算读。
每天找一件小事（对父母、对同事）“擦镜子”：先问心，再行动。
遇事先回到"性"——“我本来的样子该怎么做？“答案往往一句话就能解决。

> 总结：把心当总部，把性当说明书；心若在线，读书、做事、待人一键通关。

读《传习录》心得

Wed, 12 Nov 2025 00:00:00 +0000

王阳明学习心法：从根上发力，别急着摘果子

> 原文：
> 王阳明认为，为学首先要有本原，必须从本原上下功夫，渐渐“盈科而进”。
> 立志用功，就像种树。开始生根发芽，还没有树干；等到有了树干，还没有枝条；有了枝条然后有树叶，有了树叶然后有花朵果实。起初中下根时，只要专心栽培灌溉，不要想枝叶花果，空想没有任何用。

一句话总结

学习就像种树，先埋头把根养壮，别急着开花结果；根稳了，后面的一切自然水到渠成。

拆成大白话

原文关键词	通俗解释
本原	树根，指最基础、最核心的东西（比如真兴趣、基本功、初心）。
盈科而进	水先灌满小坑，再往前流；学习先打牢一个小阶段，再进入下一阶段。
立志用功	下定决心并持续行动，不是喊口号。
空想枝叶花果	刚学两天就担心“啥时候年薪百万”“啥时候成名”，纯属自寻烦恼。

四步种树学习法

找种子——先想清楚“我为什么要学”，找到真正的内在动机。
埋根——从最基础、最枯燥的地方开始，比如背最基础的单词、练最基础的笔画。
浇水——每天固定时间、固定量学习，不求快，只求不间断。
等发芽——别扒开土看进度，相信时间；根养好了，树干、枝条、叶子、花果会依次长出来。

日常可用的小口诀

> “先养根，再盼果；每天浇，别扒土。”

举个栗子

你想练一手好字：

种子：想让签名好看，也想静心。
埋根：每天只练横、竖、撇、捺 20 分钟，不急着写整幅作品。
浇水：坚持 3 个月，不管有没有观众点赞。
等发芽：3 个月后，笔画稳了，整个字自然好看；再练章法，作品水到渠成。

避坑提醒

作死行为	后果
今天学明天停	根刚冒芽就被晒干。
一上来就写《兰亭序》	笔画不稳，越练越挫败。
天天刷“30 天速成大师”	被人割韭菜，还浪费自己时间。

写在最后

王阳明不是让你“别幻想”，而是告诉你：
幻想的钱、名、鲜花、掌声，都在树根深处藏着；
你只需日复一日浇水，时间到了，它们自己会冒头。

读《传习录》心得

Mon, 10 Nov 2025 00:00:00 +0000

为什么平静时想得挺好，一遇事就崩？

> 原文：
> 平静的时候觉得自己想的很好，一旦遇到事情就不同了，为什么会这样？
> 阳明先生说，这是由于平时只知道在平静中修养，没有在克己功夫上用心。人必须在事情上磨炼自己，才能够立得住。

一、到底在说什么？

大白话翻译：
“平时一个人待着时，道理都懂，计划也完美，自我感觉良好；可一旦真出事，立马慌神、掉链子。王阳明说：这是因为你只会在‘风平浪静’里做功课，没把‘管住自己’练成肌肉记忆。想真正稳，就得把自己扔进‘风浪’里反复摔打。”

二、核心观点拆给你看

关键词	通俗解释
平静中修养	像泡温泉，舒服但练不出体力。
克己功夫	对自己下狠手，忍住脾气、欲望、恐惧。
事情上磨炼	把生活当健身房，遇事就是举铁，一次一次累加。
立得住	遇到再大的事，心不乱、腿不软、手还能动。

三、举个日常例子

场景：
你打算早起跑步，头天晚上想得可美：“明早 6 点，5 公里！”
平静时：
躺在被窝，觉得自己自律到发光。
真出事（闹钟响）：
天冷风大，立刻按掉闹钟：“明天再跑。”
缺了啥？
缺的就是“在冷风里咬牙起床”这一下的真操练。
多练几次，大脑才知道“原来我能扛”，下次就不逃。

四、三步落地小练习

主动找小事“虐”自己
比如：排队时不刷手机；想吃炸鸡偏换成沙拉。
事后立刻写 1 句话总结
“我刚忍住了，心情从爆炸到平静用了 5 分钟。”
把总结贴在显眼处
让大脑一次次看到“我做过”，信心就像肌肉一样长出来。

五、一句话收束

别只当“道理收藏家”，要把生活当成“健身房”；遇事那一刻，才是你真正的“考试”，多考几次，自然就稳了。

读《传习录》心得

Sat, 08 Nov 2025 00:00:00 +0000

《传习录》轻松读：徐爱录结束

故事背景

徐爱是王阳明先生的学生，一开始脑子里装的都是旧学说，后来被先生"点醒"，开心得像捡到宝。

重点提炼

秦始皇背锅？
阳明先生吐槽：现在《诗经》里那些"少儿不宜"的淫靡歌词，其实是秦朝焚书后，后世儒生为了凑够三百篇硬塞进去的"补丁"。
徐爱真香现场
- 旧观念：总怀疑先生的学问不正宗
- 被点醒后：秒变"先生吹"——“这才是孔子亲传的正版教程！其他都是山寨！”
- 心情：豁然开朗，快乐得像卸载了流氓软件

一句话总结

学渣徐爱升级记：删掉旧版本（传统学说），安装正版系统（阳明心学），瞬间流畅到飞起！

读《传习录》心得

Thu, 06 Nov 2025 00:00:00 +0000

王阳明看孔子：删书，就是“砍废话”

> 用今天的大白话，把那段文言一次说清。

1. 孔子为啥“删书”？

当时经典太多、太啰嗦，全是“废话连篇”。
孔子出手：一律砍砍砍，只留下最精华、最实用的部分。
目的：让后人不再被“虚头巴脑”的文字带歪。

2. 后世干啥了？

一代又一代人拼命“加戏”，注解、续写、发挥……越堆越厚。
结果：空话、套话满天飞，真正的道理反而被淹没。

3. 孔子说话的艺术

有人问他“天理 vs 人欲”这类高深问题，他只给对症的“小剂量”答案。
绝不多讲——怕人一钻牛角尖，反而把理走歪。
总结：圣人不喂你“精神零食”，怕你吃撑了走火入魔。

4. 孔子写书的终极 KPI

只留下一样：天理；
统统砍掉：人欲、八卦、爽文。

时期	孔子态度	理由
春秋五霸之后	不细讲	太乱、太黑暗，说了容易教坏小朋友
伏羲、黄帝时代	也删略	太久远，跟当时社会脱节，参考价值低

5. 一句话收束

> 孔子删书就像整理硬盘：
> 留有用的文档，删垃圾文件，防止病毒（人欲）入侵系统（人心）。

读《传习录》心得

Wed, 05 Nov 2025 00:00:00 +0000

知行合一

> 认知与行为，本是一体。

原文摘录

> “知是行之始，行是知之成。”

常见疑问

> 今人皆知“孝亲敬长”，却常做不到，这是否说明“知”与“行”是两件事？

答疑

此现象并非“知”“行”分离，而是私欲隔断了本体。
真正的“知”必含践行之力；若知而不行，其实只是未知。

要义

圣贤教人，只为恢复知行合一的本然，非徒增见闻。
譬如称某人“孝亲敬长”，必指其已行孝悌之事，而非空言孝顺之语。

读《传习录》心得

Wed, 05 Nov 2025 00:00:00 +0000

心的主人，就是你自己

> 身之主宰便是心，
> 心之所发便是意，
> 意之本体便是知，
> 意之所在便是物。

一句话总结

“你心里怎么想，世界就怎么显。”

1. 心、意、知、物到底啥关系？

原文	大白话
身之主宰便是心	身体听谁的话？听“心”的。心就是总司令。
心之所发便是意	总司令一开口，就叫“意”——念头、想法、小算盘。
意之本体便是知	每个念头的根儿上，自带一个“对不对”的尺子，这把尺子叫“良知”。
意之所在便是物	念头落在哪儿，哪儿就成了你世界的“事”——陪爸妈、刷手机、哄孩子，全是“物”。

2. 性、天、心，又是啥？

> “性是心之体，天是性之源，尽心即是尽性。”

原文	大白话
性是心之体	心的“材质”叫“性”，相当于出厂设置。
天是性之源	出厂设置谁写的？老天爷写的，就是自然规矩。
尽心即是尽性	把心的全部功能用到极致，就等于把老天爷给你的说明书全兑现。

3. 世界到底在心外，还是在心内？

答案：心外没事，心外无理。

当你脑子里冒出“我得去孝顺爸妈”这个念头，
“孝顺爸妈”这件事才诞生。
你没这念头，这事就不存在。

4. “格物”不是啃书本，而是擦镜子

原文说法	通俗翻译
格物	给念头做保洁——发现歪念头，立马擦掉，留下干净、善良的。
无时无处不存天理	镜子擦亮了，走到哪儿都清清楚楚，自然按“良知”办事。
穷尽天理	把镜子擦到 100% 透亮，就叫“明明德”。

5. “致知”就是找回自带的导航

原文说法	通俗翻译
知是心的本体	你心里本来装着 GPS，路口该左转右转，它滴滴就报。
见父自然知孝，见兄自然知悌，见孺子入井自然知恻隐	不用别人教，看到爸妈你自然想孝顺，看到小孩掉井你自然想拉一把。
致良知	把私欲（贪心、面子、懒癌）这些垃圾软件卸载，让 GPS 永远在线，随时导航。

6. 一张图记住全过程

心(总司令) → 意(发号施令) → 物(具体事情)
                 ↑
良知(内置尺子) ← 格物(擦歪念头) → 致良知(尺子永远准)

读《传习录》心得

Mon, 03 Nov 2025 00:00:00 +0000

程朱理学 vs 阳明心学：孝顺父母的两种打开方式

1. 核心区别速览

维度	程朱理学	阳明心学
天理在哪儿	在事物上（外在）	在心里（内在）
怎么做	按伦理纲常的“标准动作”来	先纯化内心，动作自然跟上
孝顺关键词	温凊定省（行为清单）	心孝→行孝（自动触发）

2. 孝顺父母场景对比

2.1 程朱理学版

> 逻辑链：
> 事物上存在“孝”的客观道理 → 学习并遵守 → 每天必须完成“温凊定省”四项打卡
> 重点：行为合规才算孝。

2.2 阳明心学版

> 逻辑链：
> 天理就在我心里 → 扫清欲念、保留纯孝之心 → 心一旦真孝，身体自会去做温凊定省
> 重点：心孝了，行孝只是副产品。

3. 一句话总结

程朱：先把动作做对，再谈心态。
阳明：先把心态放纯，动作差不了。

读《传习录》前言心得

Sun, 02 Nov 2025 00:00:00 +0000

心学四要

心即理

> 你的内心所想，即是你认为的道理所在。

知行合一

知与行本为一体：
有「知」必有「行」；
「行」亦如实映照「知」。

致良知

内心认为好——便去做。
内心认为不好——便不做。
> 全然依循良知，内心敞亮，毫无内耗。

前提：先在「格物」上下功夫，辨清是非对错。

万物一体

圣人能与天地万物为一体，因仁心贯通。
常人被欲念所隔，故难臻此境。

企业微信配置与 ChatGPT-On-WeChat 部署指南

Sat, 06 Sep 2025 00:00:00 +0000

一、企业微信配置步骤

1. 注册企业微信

注册地址：https://work.weixin.qq.com/wework_admin/register_wx

2. 创建并配置应用

创建应用后，需进行以下配置：

网页授权及 JS-SDK 这里需要验证域名，点击“申请校验域名”，按照步骤操作即可。
配置企业可信 IP（就是你的服务器 ip 地址）
设置 API 接收消息（需提供 URL，微信会调用该接口进行验证，这里要先部署 chatgpt-on-wechat 才能验证）企业微信文档：https://developer.work.weixin.qq.com/document/10514 这一步设置很重要，需要先让 chatgpt-on-wechat 服务跑起来，才能验证url的功能。

3. 获取关键信息

请记录以下信息，后续部署会用到：

企业ID
应用的Secret
应用的Agent ID
应用接收消息的Token（可随机生成）
应用接收消息的EncodingAESKey（可随机生成）

二、部署 ChatGPT-On-WeChat 项目

1. 项目地址

github 地址：https://github.com/zhayujie/chatgpt-on-wechat

2. 部署方式

本文采用源码部署方式，你也可以选择 Docker 部署（请自行探索）。
按照项目手册进行部署即可，这里不再赘述。

3. 配置步骤

复制配置文件：

cp config-template.json config.json

编辑 config.json，参照 config.py 中的参数名称进行配置（这是重点！）。
启动应用：

python app.py

注意事项

确保企业微信中配置的 URL 可被外网访问，用于接收消息验证。
配置 config.json 时务必与 config.py 中的参数名称保持一致。

我的config.json配置信息：

{
	"channel_type": "wechatcom_app",
	"text_to_image": "dall-e-2",
	"voice_to_text": "openai",
	"text_to_voice": "openai",
	"proxy": "",
	"hot_reload": false,
	"single_chat_prefix": [
		"bot",
		"@bot"
	],
	"single_chat_reply_prefix": "[bot] ",
	"group_chat_prefix": [
		"@bot"
	],
	"group_name_white_list": [
		"ChatGPT测试群",
		"ChatGPT测试群2"
	],
	"image_create_prefix": [
		"画"
	],
	"speech_recognition": true,
	"group_speech_recognition": false,
	"voice_reply_voice": false,
	"conversation_max_tokens": 2500,
	"expires_in_seconds": 3600,
	"character_desc": "你是基于大语言模型的AI智能助手，旨在回答并解决人们的任何问题，并且可以使用多种语言与人交流。",
	"temperature": 0.7,
	"subscribe_msg": "感谢您的关注！\n这里是AI智能助手，可以自由对话。\n支持语音对话。\n支持图片输入。\n支持图片输出，画字开头的消息将按要求创作图片。\n支持tool、角色扮演和文字冒险等丰富的插件。\n输入{trigger_prefix}#help 查看详细指令。",
	"use_linkai": false,
	"linkai_api_key": "",
	"linkai_app_code": "",
	"wechatcom_corp_id": "【你的企业 id】",
	"wechatcomapp_token": "【应用接收消息的 token(随机生成)】",
	"wechatcomapp_secret": "【应用的 secret】",
	"wechatcomapp_agent_id": "【应用的 agent_id】",
	"wechatcomapp_aes_key": "【应用接收消息的 encoding_aes_key(随机生成)】",
	"wechatcomapp_port": 9898,
	"model": "xunfei",
	"xunfei_app_id": "【讯飞 app_id】",
	"xunfei_api_key": "【讯飞 api_key】",
	"xunfei_api_secret": "【讯飞 api_secret】",
	"xunfei_domain": "x1", //讯飞我用的 Spark X1-32K 大模型（json 格式，注释要删掉！）
	"xunfei_spark_url": "wss://spark-api.xf-yun.com/v1/x1"
}

Markdown 全面教程

Fri, 15 Aug 2025 00:00:00 +0000

Markdown 是一种轻量级标记语言，使用纯文本格式编写，可转换为结构化的 HTML。它简单易学，广泛应用于技术文档、博客、笔记和 README 文件。

标题

使用 1-6 个 # 创建标题：

# 一级标题
## 二级标题
### 三级标题
#### 四级标题
##### 五级标题
###### 六级标题

一级标题

二级标题

三级标题

四级标题

五级标题

六级标题

文本格式

**粗体文本**  
*斜体文本*  
~~删除线文本~~  
<mark>高亮文本</mark>
`行内代码`  
H<sub>2</sub>O  
E = mc<sup>2</sup>

粗体文本
斜体文本
~~删除线文本~~
高亮文本
行内代码
H₂O
E = mc²

列表

无序列表

- 苹果
- 香蕉
  - 进口香蕉
  - 本地香蕉
- 橙子

苹果
香蕉
- 进口香蕉
- 本地香蕉
橙子

有序列表

1. 第一步：准备材料
2. 第二步：混合原料
3. 第三步：烘烤
   1. 预热烤箱
   2. 放入模具
4. 第四步：装饰

第一步：准备材料
第二步：混合原料
第三步：烘烤
1. 预热烤箱
2. 放入模具
第四步：装饰

任务列表

- [x] 完成项目提案
- [ ] 编写代码文档
- [ ] 测试功能模块

完成项目提案
编写代码文档
测试功能模块

链接与图片

基本链接

[GitHub](https://github.com)

GitHub

引用链接

学习更多 [Markdown 语法][1]

[1]: https://www.markdownguide.org

学习更多 Markdown 语法

图片

![Markdown 标志](https://markdown-here.com/img/icon256.png)

图片链接

[![GitHub 标志](https://github.githubassets.com/images/modules/logos_page/GitHub-Mark.png)](https://github.com)

代码

行内代码

使用 `console.log()` 输出信息

使用 console.log() 输出信息

ubuntu24.04 通过部署ollama提供大模型api接口

Fri, 15 Aug 2025 00:00:00 +0000

想部署一个大模型api接口，供自己在内网调用。
用AI生成部署方法，很多时候驴唇不对马嘴。
干脆自己写一篇完整的部署流程。

服务器环境

ubuntu 24.04
显卡 NVIDA 3090（显存24G）
内存 32G
硬盘 1T

部署

安装 ubuntu 驱动

踩过坑的痛！！！因为我是空白系统，直接上来安装ollama，确实装成功了，但发现跑起来非常慢，就连说个“你好”，都要5秒才回应。通过监控，原来是GPU没跑起来，是用CPU跑的，真蛋疼！

安装推荐驱动命令：

- sudo ubuntu-drivers autoinstall 
- 安装完重启重启命令：sudo reboot

安装cuda

如果可以直接安装，那么不需要补充cuda仓库，直接安装就好了。

# 先补充cuda仓库，这里一定注意自己匹配的系统版本和架构（我用的ubuntu 24.04，x86_64架构）：
 - sudo apt-key adv --fetch-keys https://developer.download.nvidia.cn/compute/cuda/repos/ubuntu2404/x86_64/3bf863cc.pub`
 - sudo add-apt-repository "deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/ /"
# 安装：
 - sudo apt-get update
 - sudo apt-get install -y nvidia-container-toolkit（安装完重启）

安装ollama

1. 安装命令（早上7点半速度很快）：curl -fsSL https://ollama.com/install.sh | sh
2. 验证ollama：ollama --version
3. 下载模型：ollama pull gpt-oss:20b
4. 增加对外接口的配置，配置文件里加一行：Environment="OLLAMA_HOST=0.0.0.0:11434"
5. 重载配置：sudo systemctl daemon-reload
6. 重启服务：sudo systemctl restart ollama
7. 暂停服务：sudo systemctl stop ollama

8. 其中第4步，我实测没生效，改用全局变量：
- 设置全局变量：sudo vim /etc/environment，
- 在后面追加一行：OLLAMA_HOST=0.0.0.0:11434，
- 别忘了重启系统：sudo reboot

排查：

ollama的配置文件：

/etc/systemd/system/ollama.service

查看端口占用：

sudo lsof -i :11434

监控显存

watch -n 1 nvidia-smi  # 每秒刷新一次，显示显存、利用率、温度等
watch -n 1 'nvidia-smi --query-gpu=memory.used,memory.total --format=csv' #只看显存

防火墙放行

# 添加放行端口：
- sudo ufw allow 11434/tcp
- sudo ufw allow 11434/udp # udp协议不用可以不加
# 查看防火墙规则：
sudo ufw status verbose

法律法规考点汇总（基金从业）

Mon, 28 Jul 2025 00:00:00 +0000

基金从业资格考试法律法规考点总结

| 将产品或服务风险等级由低至高至少划分为五级【必考题】 | 券商等金融机构将产品或服务风险等级由低至高至少划分为五级： R1（低风险等级）、 R2（中低风险等级）、 R3（中风险等级）、 R4（中高风险等级）、 R5（高风险等级）。依据各个基金的投资方向、投资范围、投资比例三要素来确定其基本风险等级，再依据基金历史规模和持仓比例、基金过往业绩及其基金净值的历史波动程度、基金成立以来有无违规行为发生三方面进行风险等级调整，每个季度调整一次。

基金产品风险评价应当至少依据以下四个因素: 一是基金招募说明书所明示的投资方向、投资范围和投资比例，二是基金的历史规模和持仓比例，三是基金的过往业绩及基金净值的历史波动程度，四是基金成立以来有无违规行为发生。同时综合考虑流动性、到期时限、杠杆情况、结构复杂性、投资最低金额、募集方式等因素。

私募基金管理人自行销售或者委托销售机构销售私募基金，应当自行或者委托第三方机构对私募基金进行风险评级。 | nan | nan | | 道德调整范围和法律调整范围【必考题】 | 一般认为，道德调整的范围比法律调整的范围更为广泛。法律调整的对象侧重于人们的外在行为和结果的合法化，具有较强的客观性，人们的思想、心理动机和精神世界都不是法律调整的对象; 道德不仅要调整人们的外在行为和结果，还要调整人们内在的精神世界和心理动机。道德的特征: ①道德具有差异性; ②道德具有继承性; ③道德具有约束性; ④道德具有具体性。道德依靠社会舆论、传统习俗和内心信念等力量来发挥其约束的作用，因此，社会道德评价标准、行为习惯、道德观念等就成为道德得以实施的重要支撑力量。 | nan | nan | | 基金职业道德的核心规范 | 诚实守信是基金职业道德的核心规范。 | nan | nan | | 基金宣传推介材料【必考题】 | 基金宣传推介材料是指为推介基金向公众分发或者发布，使公众可以普遍获得的书面、电子或者其他介质的信息。微信公众号文章、朋友圈广告、信函、传真都属于公众可以普遍获得的书面、电子或者其他介质的信息。基金从业人员分发或公布的基金宣传推介材料，应为基金管理机构或基金代销机构统一制作的材料。除基金管理人、基金销售机构外，其他机构或者个人不得擅自制作或者发放与货币市场基金相关的宣传推介材料。基金管理人的基金宣传推介材料，应当事先经基金管理人负责基金销售业务的高级管理人员和督察长检查，出具合规意见书，并自向公众分发或者发布之日5个工作日内报主要经营活动所在地中国证监会派出机构备案。基金宣传推介材料需要登载私募基金承担的主要费用和费率。基金宣传推介材料中推介货币市场基金的，应当提示基金投资人，购买货币市场基金并不等于将资金作为存款存放在银行或者存款类金融机构，基金管理人不保证基金一定盈利，也不保证最低收益。基金销售支付结算机构等相关机构开展与货币市场基金相关的业务推广活动，应当事先征得合作基金管理人或者基金销售机构的同意，严格遵守相关法律法规的规定，不得混同、比较货币市场基金与银行存款及其他产品的投资收益，不得以宣传理财账户或者服务平台等名义变相从事货币市场基金的宣传推介活动。

基金宣传推介材料必须真实、准确，与基金合同、基金招募说明书相符，不得有下列情形: (1)虚假记载、误导性陈述或者重大遗漏。 (2)预测基金的投资业绩。 (3)违规承诺收益或者承担损失。 (4)诋毁其他基金管理人、基金托管人或者基金销售机构，或者其他基金管理人募集或者管理的基金。 (5)夸大或者片面宣传基金，违规使用安全、保证、承诺、保险、避险、有保障、高收益、无风险等可能使投资人认为没有风险的或者片面强调集中营销时间限制的表述。 (6)登载单位或者个人的推荐性文字。 (7)基金宣传推介材料所使用的语言表述应当准确清晰，应当特别注意:①在缺乏足够证据支持的情况下，不得使用“业绩稳健”“业绩优良”“名列前茅”“位居前列”“首只”“最大”“最好”“最强”“唯一"等表述;②不得使用“坐享财富增长”“安心享受成长”“尽享牛市”等易使基金投资人忽视风险的表述;③不得使用“欲购从速”“申购良机"等片面强调集中营销时间限制的表述;④不得使用“净值归一"等误导基金投资人的表述。 | nan | nan | | 宣传推介材料违规 | (一)基金管理公司或基金代销机构使用基金宣传推介材料的违规情形主要包括以下三种: (1)未履行报送手续。 (2)基金宣传推介材料和上报的材料不一致。 (3)基金宣传推介材料违反《证券投资基金销售管理办法》及其他情形。 (二)行政监管处罚措施出现上述情形的，将视违规程度由中国证监会或地方证监局依法采取以下行政监管或行政处罚措施: (1)提示基金管理公司或基金代销机构进行改正。 (2)对基金管理公司或基金代销机构出具监管警示函。 (3)对在6个月内连续两次被出具监管警示函仍未改正的基金管理公司或基金代销机构，该公司或机构在分发或公布基金宣传推介材料前，应当事先将材料报送中国证监会。基金宣传推介材料自报送中国证监会之日起10日后，方可使用;在上述期限内，中国证监会发现基金宣传推介材料不符合有关规定的，可及时告知该公司或机构进行修改，材料未经修改的，该公司或机构不得使用。 (4)责令基金管理公司或基金代销机构进行整改，暂停办理相关业务，并对其立案调查。 (5)对直接负责的基金管理公司或基金代销机构高级管理人员和其他直接责任人员,采取监管谈话、出具警示函、记入诚信档案、暂停履行职务、认定为不适宜担任相关职务者等行政监管措施，或建议公司或机构免除有关高管人员的职务。 | nan | nan | | 督察长 | 督察长是监督检查基金和公司运作的合法合规情况及公司内部风险控制情况的高级管理人员。基金公司应保证督察长工作的独立性，不得安排或者要求督察长从事基金销售投资等与其履行职责相冲突的职务和工作。

发现下列情形之一的，督察长应当及时向公司董事会、中国证监会及相关派出机构报告: (1)基金及公司发生违法违规行为。 (2)基金及公司存在重大经营风险或者隐患。 (3)督察长依法认为需要报告的其他情形。 (4)中国证监会规定的其他情形。 | nan | nan | | 董事会审议 | 董事会审议下列事项，应当经过2/3以上的独立董事通过: ①公司及基金投资运作中的重大关联交易; ②公司和基金审计事务，聘请或者更换会计师事务所； ③公司管理的基金的半年度报告和年度报告; ④法律、行政法规和公司章程规定的其他事项。 | nan | nan | | 风险分类 | 市场风险，是指因受各种因素影响引起证券及其衍生品市场价格不利波动，使投资组合资产、公司资产面临损失的风险。流动性风险，是指因市场交易量不足，导致不能以合理价格及时进行证券交易的风险，或投资组合无法应付客户赎回要求所引起的违约风险。 | nan | nan | | 风险管理 | 基金公司的风险管理是指基金公司围绕公司总体经营战略，从董事会、管理层到全体员工全员参与，在日常经营中，识别潜在风险，评估风险的影响程度，并根据公司风险偏好制定风险应对策略，有效管理公司各环节风险的持续过程。为充分保护基金份额持有人的利益，促进公司和行业持续、健康、稳定发展，基金管理人应强化风险意识，增强风险防范能力，建立全面的风险管理体系。风险管理应该遵循全面性原则。风险管理是公司经营管理的重要组成部分也是业务运作体系及日常业务流程中不可或缺的因素风险控制必须覆盖公司的各项业务、各个部门和各个岗位渗透到决策、执行、反馈等各个业务环节。

公司管理层对有效的风险管理承担直接责任。在风险管理责任的划分上，各业务部门负责人是其部门风险管理的第一责任人，基金经理是相应投资组合风险管理的第一责任人。董事会对有效的风险管理承担最终责任，履行的风险管理职责是:

关于我

Mon, 28 Jul 2025 00:00:00 +0000

全栈技术开发者 | 多领域业务实践者

技术能力

前百度高级工程师，在以下领域有工程实践：

后端开发：微服务架构、分布式系统、性能优化
基础设施：云原生应用部署（K8S/Docker）、自动化运维体系
跨端能力：服务端开发为主，具备前端基础（Jquery/Vue）

业务理解

参与过多个行业的系统建设：

车联网：车载通信平台开发
在线教育：直播课堂技术支持
金融科技：支付系统开发经验
网络安全：安全防护方案实施
电商平台：高并发场景实践

持续成长

🧠 技术精进

持续钻研系统设计（eg：高并发、分布式）
整理基础设施落地笔记

🌱 思维拓展

探索技术决策中的业务平衡
关注工程伦理与社会价值

📚 多元兴趣

研习国学典籍
了解中医基础理论与养生哲学
从传统文化中汲取系统思维养分

证券投资考点

Mon, 28 Jul 2025 00:00:00 +0000

逐笔全额结算

逐笔全额结算是指证券登记结算机构对每笔证券交易均独立结算，同一结算参与人应收资金(证券)和应付资金(证券)不轧差处理。

在交收时点，买卖双方应付资金和证券都符合要求的，完成交收;任何一方或双方结算参与人应付资金或应付证券不足的，交收失败。证券登记结算机构不作为双方的共同对手方，不提供交收担保。

逐笔全额结算的主要特点：

(1)资金(证券)的足额以单笔交易为最小单位，资金(证券)足额则全部交收，不足则全不交收，不分拆交收。(A正确)
(2)交收期灵活，从实时逐笔全额(RTGS)到交收期为T+0~T+n日不等。
(3)交收方式多样，结算参与人可以根据需要采用货银对付(DVP)、纯券过户等多种交收方式。

全额结算的优点：

由于买卖双方是一一对应的，每个市场参与者都可监控自己参与的每一笔交易结算进展情况，从而评估自身对不同对手方的风险暴露;
有利于保持交易的稳定和结算的及时性，降低结算本金风险。

全额结算的缺点：

对频繁交易的做市商有较高的资金要求，资金负担较大，结算成本较高。

实时处理的全额结算也就是实时全额结算,结算效率较高,其结算的本金风险较小,但对市场参与者的流动性要求也相对较高。

远期合约

是一种非标准化的合约，是交易双方约定在未来的某一确定时间，以确定的价格买卖一定数量的某种金融资产的合约。是必须履行的协议。

主要有远期利率协议、远期外汇合约、远期股票合约。远期合约是现金交易，买方和卖方达成协议在未来的某一特定时期交割一定质量和数量的商品。远期合约是场外交易，交易双方都存在风险。

如果即期价格低于远期价格，市场状况被描述为正向市场或溢价。
如果即期价格高于远期价格，市场状况被描述为反向市场或差价。

远期交易从成交日至结算日的期限(含成交日不含结算日)由交易双方确定，但最长不得超过【365天】。

期货合约

是一种标准化的合约，是买方同意在一段指定时间之后按特定价格接收某种资产，卖方同意在一段指定时间之后按特定价格交付某种资产的协议。

双方同意将来交易时使用的价格称为期货价格。
双方将来必须进行交易的指定日期称为结算日或交割日。
期货交易中最后进行实物交割的比例很小，一般用现金进行结算。远期合约通常用实物交割。
期货合约的信用风险较低。

期权对买入方一般不采用盯市制度。对卖出方可以通过采用标的物抵押，也可以采用保证金，只有采用保证金方式才有必要盯市。在期货市场因为都是保证金方式，所以通常都会采用盯市制度。

期货合约是指交易双方签署的在未来某个确定的时间按确定的价格买入或卖出某项合约标的资产的合约。相对远期合约而言，期货合约是标准化合约。

投机者是期货市场的重要组成部分，是期货市场必不可少的润滑剂。金融期货合约的交割大多采用现金结算。

逐日盯市制度

逐日盯市制度，是指结算部门在每日闭市后计算、检查保证金账户余额，通过适时发出追加保证金通知，使保证金余额维持在一定水平之上，防止负债现象发生的结算制度。

盯市制度对保证期货合约的履行非常重要。

另类投资

是指投资于传统的股票、债券和现金之外的金融和实物资产，如房地产、证券化资产、对冲基金、私人股本基金、大宗商品、艺术品等。

由于不在公共交易平台上运作，另类投资的一个重大特点便是缺少流动性。一个项目从购入到套现通常需要几年的时间，于是另类投资基金一般设有5、10年的锁定期，中途赎回很困难。

另类投资仍属高风险、高回报类，只宜为证券投资之外的补充。

另类投资产品局限性：

①缺乏监管和信息透明度;
②流动性较差，杠杆率偏高;
③估值难度大，难以对资产价值进行准确评估。

投资者将另类投资产品纳入投资组合当中，主要目的是通过投资组合提高投资回报和分散风险。

不动产

直接的不动产投资流动性较差，产权交易时间长、费用高。若要快速转售，往往要承担较大的折价损失。直接的不动产投资金额大，且不容易拆分以卖给多个投资者。这意味着一项投资就可能占据投资组合的很大比例。对大多数个体投资者而言，不动产投资意味着购买自己的居住用房地产，这也是这些投资者所持有的资产净值当中的重要部分。不动产投资具有异质性给房地产估值带来了困难。

大宗交易

大宗交易是指单笔数额较大的证券买卖。按照规定，证券交易所可以根据市场实际情况调整大宗交易的最低限额。

上海证券交易所，如果在交易日15:00前处于停牌状态的证券，则不受理其大宗交易的申报。上海证券交易所接受大宗交易的时间为每个交易日9:30-11:30、13:00-15:30。

大宗商品

投资者可以通过购买主营资源勘探、开发或大宗商品生产加工企业的股票来进行大宗商品投资。对单一商品或商品价格指数采用衍生产品合约形式进行投资，是大多数大宗商品投资者常用的投资方式。

大宗商品基本上可以分为四类:能源类、基础原材料类、贵金属类和农产品类。大宗商品价值受全球经济因素、供求关系等影响较大，在通货膨胀时价格随之上涨，具有天然的通货膨胀保护功能。

β系数（市场整体波动性）

β系数（贝塔系数）是一种衡量股票或投资组合相对于市场整体波动性的风险指数，用于评估系统性风险。

如果β系数大于1，表示其波动性高于市场；
如果β系数小于1，表示其波动性低于市场。
β系数可以小于0，β系数小于0时，该投资组合的价格变动方向与市场相反。

某资产的贝塔系数越大，意味着该资产收益率与市场组合收益率的协方差越大。两种金融资产收益率相关系数和协方差符号总是相同。相关系数为0代表两种金融资产收益率之间无线性相关联。

夏普比率（整体风险）

是衡量投资组合风险调整后收益的核心指标。核心思想是：‌投资者每承担一单位总风险，获得的超额收益越高，投资性价比越优‌。

夏普比率越高，说明在承担一定风险的情况下，所获得的超额回报越高。
夏普比率和其他指标一样，同类型基金比较才有意义。如果是同类型基金，不考虑其他因素，夏普比率越高的越好。

当组合超额收益为负数，除以较大(小)的总风险时，夏普比率得到较小(大)的负数，基金业绩反而变得较佳(差)，由此会产生错误的评价结论。

特雷诺比率（系统风险）

系统风险是指那些影响所有公司的因素引起的风险。例如战争、经济衰退、通货膨胀、高利率等非预期的变动。

特雷诺比率是衡量投资组合承担单位系统性风险所获超额收益的指标，用于评估风险调整后的绩效。

特雷诺指数越大，单位风险溢价越高，开放式基金的绩效越好。
特雷诺比率是无风险收益到投资组合收益两点间直线的斜率，反映了承担单位市场风险所获得的超额收益。

詹森指数（超额收益，对比CAPM）

是用于评估基金或投资组合风险调整后超额收益的重要指标。即基金的实际收益超过它所承受风险对应的预期收益的部分来评价基金，此差额部分就是与基金经理业绩直接相关的收益。

其计算公式是：詹森指标 = 基金的实际收益 - 市场自身收益（承担市场风险所得的收益）

詹森指数＞0，表明基金业绩表现优于市场基准组合，大得越多、业绩越好；
詹森指数＜0，则表明绩效不好。

信息比率（主动风险）

用来衡量超额风险所带来的超额收益。它表示单位主动风险所带来的超额收益。

信息比率 = 超额收益 / 跟踪误差

超额收益 = 投资组合收益率 - 基准指数收益率
跟踪误差 = 超额收益的标准差（衡量主动风险）

信息比率越大，说明该基金在同样的跟踪误差水平上能获得更大的超额收益或者在同样的超额收益水平下跟踪误差更小。

跟踪误差（指数偏离）

跟踪误差(Tracking Error)是衡量投资组合或策略与其基准指数之间偏离程度的指标,通常以两者收益率差异的标准差计算。跟踪误差一般用于指数基金。

波动率是一个绝对风险指标，跟踪误差则是相对于业绩比较基准的相对风险指标。
跟踪误差计量的前提是清晰的业绩比较基准。
指数基金的跟踪误差通常较低。主动管理基金受到投资目标和风格不同的影响，跟踪误差较大。

资本资产定价模型（CAPM）

资本资产定价模型，研究的重点在于探求风险资产收益与风险的数量关系，即为了补偿某一特定程度的风险，投资者应该获得多少的报酬率。

核心思想是：‌投资者承担的系统性风险越高，要求的回报补偿也越高‌。

是否缴纳增值税

基金管理人是基金运营过程中发生的增值税的纳税人。

交：机构投资者买卖基金份额属于金融商品转让，应按照卖出价扣除买入价后的余额为销售额计征增值税。
免：
- 个人买卖基金份额的行为免征增值税。
- 合格境外投资者(QFII)委托境内公司在我国从事证券买卖业务、香港市场投资者通过基金互认买卖内地基金份额取得的收入免征增值税。

印花税

印花税是对在经济活动和经济交往中书立、领受具有法律效力的凭证的行为征收的一种税。

基金卖出股票时按照千分之一的税率征收证券(股票)交易印花税。
对买入交易不再征收印花税，即对印花税实行单向征收。
机构投资者买卖基金份额暂免征收印花税。
个人投资者买卖基金份额暂免征收印花税。
对香港市场投资者通过基金互认买卖、继承、赠予内地基金份额，暂不征收印花税。

企业所得税

机构投资者在境内买卖基金份额获得的差价收入，应并入企业的应纳税所得额，征收企业所得税；
机构投资者从基金分配中获得的收入，暂不征收企业所得税；
对内地企业投资者通过基金互认买卖香港基金份额取得的转让差价所得，计入其收入总额，依法征收企业所得税；
对内地企业投资者通过基金互认从香港基金分配取得的收益，计入其收入总额，依法征收企业所得税。

相对收益归因分析

最常用的是Brinson模型。相对收益归因侧重分析基金如何跑输或跑赢业绩比较基准。相对收益归因的计算比绝对收益归因的计算更加复杂。

绝对收益归因分析

绝对收益归因是考察各个因素对基金总收益的贡献,其本质是对基金总收益的分解。

Mon, 01 Jan 0001 00:00:00 +0000

2个月甩肉20斤！普通上班族的「管住嘴」实战攻略

（附：吃不胖的GI食物清单+防暴食技巧）

减肥前：靠零食缓解考证压力 → 住院一周
减肥后：腰围减8cm+王者上55星
最惊喜的是：没运动纯靠吃，但皮肤和精神反而变好了！

一、我的故事：为什么狠下心减肥？

5月拼基金从业资格证，压力大，到顿顿狂炫。考完第二天，生病进医院，躺了一礼拜。出院就一个念头：
🔥 “要么瘦，要么再住院，我选瘦！”
（后来无数次饿到想放弃，全靠这句话撑住）

二、减肥底层逻辑：小白必懂的2个核心

1. 热量缺口：减肥不是挨饿，是“聪明吃”

公式：吃进去的热量 < 身体消耗的热量

每天少摄入300-500大卡（≈1杯奶茶+半包薯片）
别极端节食！ 否则代谢暴跌，反弹更胖

2. 胰岛素稳了，脂肪才会燃烧！

关键角色：升糖指数（GI值）

GI等级	对血糖影响	代表食物
≤55（低）	血糖平稳，胰岛素分泌少	燕麦、苹果、豆腐
56-69（中）	血糖较快上升	香蕉、糙米饭、菠萝
≥70（高）	血糖飙升→胰岛素狂分泌→囤脂肪！	白米饭、蛋糕、西瓜

★ 核心技巧：

多吃低GI食物 = 血糖稳 = 胰岛素少 = 身体狂烧脂肪 不确定食物GI值？百度“XX升糖指数”秒查！

三、我的“沙县减脂餐”进阶版（附食谱）

初期图省事连吃一周沙县鸡腿饭，后来自己升级：

🍗 黄金公式：1拳蛋白+1拳低GI碳水+2拳蔬菜

蛋白（防肌肉流失）：鸡腿/鸡蛋/豆腐（去皮！）
碳水（选低GI）：荞麦面/糙米/红薯（代替挂面！）
蔬菜（管饱不限量）：菠菜/西兰花/番茄

我的一餐：去皮鸡腿1个+水煮蛋1个+挂面20根(强烈建议换成荞麦面！！！)+青菜1大把

💡 为什么换掉挂面？
普通挂面GI值≈80（高！），换成荞麦面（GI=45）或胚芽米（GI=48），饱腹感更强，血糖不坐过山车

四、防暴食秘诀：饿了不打游戏也能扛住！

初期饿到抓狂，但靠这3招没破功：

✅ 终极心法：“饿≠会死，撑过20分钟就消失”

战术喝水：灌1杯温水+嚼2片黄瓜（胃欺骗术）
硬核转移：开王者排位（必须排位！普通匹配不够刺激）→ 本赛季怒冲55星✨
紧急加餐（仅限饿到手抖时）：1个水煮蛋/10颗杏仁/无糖酸奶:

血泪教训：别少食多餐！胰岛素频繁波动反而更难瘦

五、2025超火饮食法：直接抄作业！

中国营养学会最新推荐 “211餐盘法”，特别适合中国胃：

餐盘对半分蔬菜（深绿色叶菜优先）
1/4放优质蛋白（鸡胸/鱼虾/豆腐）
1/4放低GI主食（推荐TOP3：藜麦饭/燕麦/黑米）

🍚 主食替换表（高GI→低GI）

少吃这些（高GI）	改吃这些（低GI）
白米饭、馒头	糙米/胚芽米（GI低30%）
普通面条	荞麦面/意大利面
白面包	全麦黑麦面包
土豆泥	山药/芋头

六、写给饿着肚子的你：

减肥不是自虐，是学会和身体合作。

“当你不再和食欲对抗，而是指挥它，脂肪就慌了。”

我经历过半夜饿到哭，也飘过火锅店的香味…但看到瘦下来的帅气+腰围缩进L码时，一切都值了。你比自己想象的更强大，现在就开始，拿回身体主动权！

前后体重变化，附图：