小白Python入门 on 小马哥博客

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文件，了解哪些页面可以爬取。

小白Python入门 on 小马哥博客

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

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

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

你可以用Python做什么？

Python有多简单？

学习前别被这些谣言吓到

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

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

谣言3：“学完用不上”

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

下一步准备什么？

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

第一次装软件别翻车

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

Windows用户看这里

1. 下载Python（别下错了）

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

3. 验证安装成功

Mac用户看这里

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

2. 用Homebrew安装（最推荐）

3. 验证安装

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

推荐VS Code（免费又强大）

或者用PyCharm Community（免费版）

第一次运行Python代码

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

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

常见坑及解决方案

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

坑2：Mac上输入python没反应

坑3：VS Code运行Python时报错

环境配置检查清单

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

编程其实就做两件事

什么是变量？

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

能用什么字符？

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

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

1. 整数（int）

2. 浮点数（float）

3. 字符串（str）

4. 布尔值（bool）

5. 列表（list）

6. 字典（dict）

变量的赋值和修改

赋值

修改

删除

查看变量类型

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

电脑也会做决定？

if语句的基本语法

if-else：二选一

if-elif-else：多选一

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

逻辑运算符（组合条件）

and：并且

or：或者

05-循环-一次做1000件事

重复劳动交给电脑！

for循环：遍历一个序列

基本语法

遍历列表

遍历字符串

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

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

基本语法

简单例子

一定要有退出条件！

break和continue：控制循环

break：跳出循环

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

别再复制粘贴代码了！

函数的基本语法

无参无返回值

有参无返回值

有参有返回值