🔥个人主页： 中草药

 🔥专栏：【Java】登神长阶 史诗般的Java成神之路

---

本文不做Python以及Pycharm安装的详细教程，请大家自行查阅资料，或到官网去下载

        Python作为一门 “优雅且强大” 的编程语言，Python 凭借易上手、用途广的特点，成为很多人入门编程的首选。无论是数据分析、人工智能，还是 Web 开发、自动化脚本，Python 都能胜任。但想要用好 Python，扎实的基础语法是关键 —— 本文将结合系统的语法知识，从 “计算器” 级别的简单运算，到数据持久化的文件操作，带你一站式吃透 Python 核心语法，让你看完就能上手写代码！

变量与数据类型：程序的"原材料仓库"

        变量就像快递盒，用来装不同类型的数据；数据类型则是快递盒上的标签，告诉我们里面装的是文件、水果还是电子产品。类型系统其实是在对变量进行 "归类". 相同类型的变量(数据) 往往具有类似的特性和使用规则。

        Python的变量规则和其他语言大差不差，关键在于Python不用手动指定数据类型，赋值后会自动识别，即动态类型特性，这是它的一大特色。

        动态类型特性是一把双刃剑。

        对于中小型程序, 可以大大的解约代码量(比如写一段代码就可以同时支持多种类型).

        对于大型程序, 则提高了模块之间的交互成本. (程序猿 A 提供的代码难以被 B 理解)

常见数据类型及操作

数据类型	定义方式	核心操作	适用场景
整数（int）	num = 10	加减乘除、取余（%）、整除（//）	计数、编号等整数场景
浮点数（float）	price = 9.9	同整数，注意精度问题	金额、重量等小数场景
字符串（str）	name = "Python"	拼接（+）、切片（[0:2]）、替换（replace）	文本存储与处理
列表（list）	nums = [1,2,3]	增（append）、删（pop）、改（nums[0]=0）	存储多个可变数据
元组（tuple）	info = ("Tom",20)	只能查，不能改	存储固定不变的数据（如坐标）
字典（dict）	student = {"name":"Tom","age":20}	按键取值（student["name"]）、增删键值对	存储键值对应的数据（如个人信息）
集合（set）	s = {1,2,3}	去重、交集（&）、并集（|）	数据去重、关系判断

在 Python 中, 单引号构成的字符串和双引号构成的字符串, 没有区别. 'hello' 和 "hello" 是完

全等价的.

关键易错点解析

• 可变vs不可变类型：列表、字典、集合是可变类型（能修改内部数据），整数、浮点数、字符串、元组是不可变类型（修改会生成新对象）。 错误示例：s = "hello"; s[0] = "H"（报错，字符串不可变） 正确示例：s = "hello"; s = "Hello"（重新赋值生成新字符串）

• 列表与元组的区别：元组用小括号，列表用中括号；元组不能修改，列表可以。新手常犯：把元组当成列表修改，导致报错。

• 字典的键要求：必须是不可变类型（如字符串、整数），不能用列表当键。 错误示例：dict = {[1]:"a"}（报错） 正确示例：dict = {(1):"a"}（用元组当键）

运算符：程序的"计算器+判断器"

运算符就像数学里的加减乘除和逻辑判断，是实现数据运算和条件判断的核心工具。重点记清优先级和实用技巧。

核心运算符分类

• 算术运算符：+（加）、-（减）、*（乘）、/（除）、%（取余）、//（整除）、**（幂运算） 实例：print(7//3) # 输出2（整除取整数部分）；print(2**3) # 输出8（2的3次方）

除零异常：/、//、%的除数不能为 0，否则会报错（ZeroDivisionError）；

%求余的正负：结果的正负和被除数一致（比如7%3=1，-7%3=2，7%-3=-2）。

示例：

# 除零异常（会报错）
# print(10 / 0)  # ZeroDivisionError: division by zero

# 求余示例
print(7 % 3)   # 1（7÷3=2余1）
print(-7 % 3)  # 2（-7 = (-3)*3 + 2）
print(7 % -3)  # -2（7 = (-3)*(-2) + 1？不对，实际是7 = (-3)*(-2) + 1？不
#正确计算是：商取小于等于被除数/除数的最大整数，7/-3≈-2.333，
#商是-3，所以7 = (-3)*(-3) + (-2)，余数是-2）

• 比较运算符：==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于） 注意：比较结果是布尔值（True/False），实例：print(5==5) # 输出True

• 逻辑运算符：and（与）、or（或）、not（非） 短路特性：and前为False则不执行后面；or前为True则不执行后面。 实例：print(0 and 5) # 输出0（前面为False，短路）

• 赋值运算符：=、+=、-=、*=、/=（简化运算） 实例：a = 5; a +=3 # 等价于a = a+3，结果a=8

特殊赋值方式

• 链式赋值：同时给多个变量赋同一个值；
• 多元赋值：同时给多个变量赋不同值（常用于交换变量）。

示例：

# 链式赋值
a = b = 10  # a和b都等于10
print(a, b)  # 输出10 10

# 多元赋值（交换变量，无需中间变量）
x = 10
y = 20
x, y = y, x  # 交换x和y的值
print(x, y)  # 输出20 10

⚠️ 注意：Python没有++和--运算符（比如a++、a--），如果需要自增 / 自减，用a += 1或a -= 1。

• 成员运算符：in（在...内）、not in（不在...内） 实例：print("a" in "abc") # 输出True；print(4 in [1,2,3]) # 输出False

优先级避坑：算术运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符。不确定时加括号，比如(3+2)*4比3+2*4更清晰，避免出错。

注释：代码的"笔记本"

Python 支持两种注释风格：

（1）单行注释：#开头

适合简短解释，#后面的内容都会被视为注释：

# 这是一行单行注释
num = 10  # 这也是单行注释（写在代码后面）

（2）多行注释：三引号包裹

适合长段解释（比如函数功能、文件说明），用"""或'''包裹：

"""
这是多行注释的第一行
这是多行注释的第二行
常用于函数/文件的开头，说明功能
"""
def calc_sum(a, b):
    '''
    计算两个数的和
    参数：a -> 第一个数，b -> 第二个数
    返回值：a + b 的结果
    '''
    return a + b

输入输出：程序的交互窗口

程序需要和用户交互：用户输入数据（比如成绩），程序输出结果（比如平均分）。Python 中最基础的交互方式是控制台输入输出。

输出：print函数

print()是 Python 内置函数，用于把内容输出到控制台（比如 PyCharm 的下方窗口、Windows 的 CMD）。

（1）输出单个 / 多个内容

# 输出单个内容
print("Hello Python")  # 输出字符串
print(10 + 20)  # 输出表达式结果（30）
print(avg)  # 输出变量值

# 输出多个内容：用逗号分隔，默认用空格隔开
name = "张三"
age = 20
print("姓名：", name, "年龄：", age)  # 输出 姓名： 张三 年龄： 20

（2）格式化输出：f-string

如果想让输出更美观（比如 “姓名：张三，年龄：20”），可以用f-string：在字符串前加f，用{变量/表达式}嵌入内容。

示例：

name = "张三"
age = 20
score = 89.5

# f-string格式化
print(f"姓名：{name}，年龄：{age}")  # 输出 姓名：张三，年龄：20
print(f"平均分：{score}，总分：{score * 3}")  # 表达式也能嵌入，输出 平均分：89.5，总分：268.5

输入：input()函数

input()函数用于读取用户在控制台输入的内容，返回值永远是字符串类型（即使输入的是数字，也需要手动转换类型）。

语法：变量 = input("提示信息")，其中 “提示信息” 会显示在控制台，告诉用户该输入什么。

示例：

# 读取字符串输入
name = input("请输入你的姓名：")
print(f"你好，{name}！")  # 输入“张三”，输出“你好，张三！”

# 读取数字输入（需转换类型）
age = input("请输入你的年龄：")  # age是字符串类型
age = int(age)  # 转换为int类型
print(f"明年你{age + 1}岁")  # 输入“20”，输出“明年你21岁”

# 简化写法：直接在input后转换
score = float(input("请输入你的成绩："))  # 输入“89.5”，直接转为float

案例：输入 4 个小数，求平均分

# 输入4个小数
score1 = float(input("请输入第1个分数："))
score2 = float(input("请输入第2个分数："))
score3 = float(input("请输入第3个分数："))
score4 = float(input("请输入第4个分数："))

# 计算平均分
avg = (score1 + score2 + score3 + score4) / 4

# 输出结果
print(f"4个分数的平均分为：{avg}")

流程控制：让程序 “做选择”“重复做”

        默认情况下，程序是 “从上到下” 顺序执行的。但实际场景中，我们需要程序 “根据条件做选择”（比如成绩及格与否）或 “重复做一件事”（比如计算 100 次循环）—— 这就需要流程控制语句。

顺序语句：默认执行方式

顺序语句是最简单的流程：代码从第一行到最后一行，依次执行，没有跳转。

示例：

print("第一步：输入成绩")
score = float(input("请输入成绩："))
print("第二步：判断是否及格")
if score >= 60:
    print("及格")
else:
    print("不及格")
print("第三步：程序结束")

 条件语句：根据条件做选择

条件语句用if、if-else、if-elif-else表示 “如果… 就… 否则…” 的逻辑，缩进是关键（Python 用缩进表示 “代码块”，通常是 4 个空格）。

（1）if语句：单条件

if 条件表达式:
    代码块（条件为True时执行）
# 代码块外的内容，无论条件是否成立都会执行

（2）if-else语句：二选一

语法：

if 条件表达式:
    代码块1（条件为True时执行）
else:
    代码块2（条件为False时执行）

（3）if-elif-else语句：多条件

语法：

if 条件1:
    代码块1（条件1为True时执行）
elif 条件2:
    代码块2（条件1为False，条件2为True时执行）
elif 条件3:
    代码块3（条件1、2为False，条件3为True时执行）
...
else:
    代码块n（所有条件都为False时执行）

⚠️ 注意：elif是 “else if” 的缩写，不能写成else if（会报错）；且条件是 “互斥” 的，只要有一个条件成立，后续条件就不再判断。

（4）条件语句嵌套

条件语句内部可以再写条件语句，实现更复杂的逻辑。

示例：判断年份是否为闰年（闰年规则：能被 400 整除，或能被 4 整除但不能被 100 整除）：

year = 2024
if year % 100 == 0:
    # 世纪年（如2000、1900），需被400整除才是闰年
    if year % 400 == 0:
        print(f"{year}是闰年")
    else:
        print(f"{year}是平年")
else:
    # 非世纪年，能被4整除就是闰年
    if year % 4 == 0:
        print(f"{year}是闰年")
    else:
        print(f"{year}是平年")  # 2024是闰年，输出“2024是闰年”

（5）空语句pass

如果条件语句的代码块暂时没有内容，需要用pass占位（否则会报错）——pass表示 “什么都不做”。

示例：

score = 70
if score >= 60:
    pass  # 暂时不写逻辑，用pass占位
else:
    print("需要补考")

循环语句：重复执行代码

循环语句用于 “重复执行一段代码”，Python 中常用while循环和for循环。

（1）while循环：条件满足就循环  

while 条件表达式:
    循环体（条件为True时执行）
    # 注意：循环体中要有让条件变为False的语句，否则会无限循环

sum_result = 0  # 存储总和
num = 1
while num <= 100:
    sum_result += num  # 累加num到sum_result
    num += 1
print(f"1~100的和为：{sum_result}")  # 输出5050

⚠️ 注意：如果循环体中没有让条件变为 False 的语句（比如忘记写num += 1），循环会 “无限执行”（死循环），需要手动停止程序。

（2）for循环：遍历可迭代对象

for循环比while更简洁，主要用于 “遍历可迭代对象”（比如列表、元组、字符串，或用range()生成的序列）。

for 循环变量 in 可迭代对象:
    循环体（每次从可迭代对象中取一个值给循环变量，执行一次循环体）

关键：range()函数

range()用于生成一个整数序列，常用三种写法：

• range(n)：生成0 ~ n-1的序列（如range(5) → 0,1,2,3,4）；
• range(start, end)：生成start ~ end-1的序列（前闭后开，如range(1,5) → 1,2,3,4）；
• range(start, end, step)：生成start ~ end-1的序列，步长为step（如range(1,10,2) → 1,3,5,7,9）。

示例 1：用for循环打印 1~10

for i in range(1, 11):  # 生成1~10的序列
    print(i)

示例 2：计算 1~100 的和（for循环版）

sum_result = 0
for i in range(1, 101):  # 1~100的序列
    sum_result += i
print(f"1~100的和为：{sum_result}")  # 输出5050

示例 3：遍历字符串

s = "Python"
for char in s:  # 逐个取字符串的字符
    print(char)  # 依次输出P、y、t、h、o、n

（3）循环控制：break和continue

break和continue用于控制循环的执行流程：

• break：结束整个循环，跳出循环体；
• continue：结束本次循环，直接进入下一次循环。

示例 1：break—— 吃包子吃到第 3 个就停

for i in range(1, 6):  # 计划吃5个包子
    if i == 3:
        print(f"第{i}个包子有虫，不吃了！")
        break  # 结束整个循环
    print(f"吃完第{i}个包子")
# 输出：
# 吃完第1个包子
# 吃完第2个包子
# 第3个包子有虫，不吃了！

示例 2：continue—— 吃包子跳过第 3 个

for i in range(1, 6):  # 计划吃5个包子
    if i == 3:
        print(f"第{i}个包子有虫，跳过！")
        continue  # 结束本次循环，进入下一次（i=4）
    print(f"吃完第{i}个包子")
# 输出：
# 吃完第1个包子
# 吃完第2个包子
# 第3个包子有虫，跳过！
# 吃完第4个包子
# 吃完第5个包子

函数：代码的 “复用神器”

        如果一段代码需要重复使用（比如计算不同区间的和），每次都复制粘贴会很麻烦 —— 修改时要改几十次。这时候就需要函数：把重复的代码封装起来，需要时直接 “调用”，不用重复写。

函数是什么？

函数就像一个 “工厂”：输入 “原材料”（参数），经过 “加工”（函数体），输出 “产品”（返回值）。它的核心作用是代码复用和逻辑封装。

比如计算 “a 到 b 的和”，不用函数需要重复写循环；用函数后，只需定义一次，调用时传不同的 a 和 b 即可：

# 不用函数：重复代码
sum1 = 0
for i in range(1, 101):
    sum1 += i
print(sum1)

sum2 = 0
for i in range(300, 401):
    sum2 += i
print(sum2)

# 用函数：复用代码
def calc_sum(a, b):  # 定义函数，a和b是参数
    sum_result = 0
    for i in range(a, b+1):
        sum_result += i
    print(sum_result)

# 调用函数
calc_sum(1, 100)  # 计算1~100的和
calc_sum(300, 400)  # 计算300~400的和

函数的语法：定义与调用

（1）定义函数

def 函数名(形参列表):
    函数体（需要执行的代码）
    [return 返回值]  # 可选，没有return则返回None

• def：关键字，用于声明函数；

• 函数名：遵循变量名规则，建议用有意义的单词（如calc_sum）；

• 形参列表：函数的 “输入”，多个参数用逗号分隔，可空（无参数）；

• 函数体：函数的核心逻辑，需要缩进；

• return：函数的 “输出”，执行到return时函数结束，返回值给调用者。

示例：定义一个计算两数之和的函数

def add(x, y):  # x和y是形参（形式参数）
    result = x + y  # 函数体
    return result  # 返回结果

（2）调用函数

定义函数后，需要 “调用” 才会执行函数体。语法：

# 1. 不接收返回值（只执行函数逻辑）
函数名(实参列表)

# 2. 接收返回值（需要用变量存储）
返回值变量 = 函数名(实参列表)

• 实参列表：传给函数的 “实际值”，个数和形参一致；

• 函数调用时，实参会赋值给形参（如add(10, 20)中，10→x，20→y）。

示例：调用add函数

# 调用函数，接收返回值
total = add(10, 20)  # 10和20是实参（实际参数）
print(total)  # 输出30

# 调用函数，不接收返回值（只执行，但add的return值会被丢弃）
add(30, 40)

⚠️ 注意：

1. 函数必须 “先定义，后调用”（否则会报错NameError）；

2. 函数定义时，函数体不会执行；只有调用时才会执行。

函数的参数：灵活传递数据

函数的参数有多种形式，满足不同场景的需求。

（1）形参与实参的匹配

调用函数时，实参的个数必须和形参一致，否则会报错。比如def add(x, y)需要 2 个实参，传 1 个或 3 个都会报错：

# 错误调用（实参个数不匹配）
# add(10)  # TypeError: add() missing 1 required positional argument: 'y'
# add(10, 20, 30)  # TypeError: add() takes 2 positional arguments but 3 were given

（2）参数默认值

可以给形参设置 “默认值”—— 调用时如果不传该参数，就用默认值；传了就用实参值。

语法：def 函数名(形参1, 形参2=默认值, 形参3=默认值):，有默认值的参数必须放在无默认值参数的后面（否则报错）。

示例：

# 定义函数：debug默认值为False
def add(x, y, debug=False):
    if debug:
        print(f"计算{x} + {y}")  # 调试信息，debug为True时打印
    return x + y

# 调用：不传debug，用默认值False
print(add(10, 20))  # 输出30，不打印调试信息

# 调用：传debug=True
print(add(10, 20, True))  # 先输出“计算10 + 20”，再输出30

（3）关键字参数

默认情况下，实参是 “按位置” 传给形参（第一个实参给第一个形参，第二个给第二个）。但可以用 “关键字参数” 显式指定实参传给哪个形参，顺序可以任意。

语法：函数名(形参名1=实参1, 形参名2=实参2)

示例：

def test(x, y):
    print(f"x={x}, y={y}")

# 按位置传参（默认）
test(10, 20)  # 输出x=10, y=20

# 按关键字传参（顺序任意）
test(y=20, x=10)  # 输出x=10, y=20

 函数的返回值：输出结果

函数的返回值用return语句指定，有以下特性：

1. 一个函数可以有多个return语句，但执行到第一个return时函数就会结束；

2. 一个函数可以返回多个值，用逗号分隔，接收时用多个变量（或元组）接收；

3. 如果没有return，函数默认返回None（表示 “无值”）。

（1）多个return语句

示例：判断一个数是否为奇数

def is_odd(num):
    if num % 2 == 0:
        return False  # 偶数，返回False，函数结束
    return True  # 奇数，返回True

print(is_odd(10))  # 输出False
print(is_odd(11))  # 输出True

（2）返回多个值

示例：返回一个点的 x 和 y 坐标

def get_point():
    x = 10
    y = 20
    return x, y  # 返回多个值，用逗号分隔

# 接收多个返回值
x, y = get_point()
print(x, y)  # 输出10 20

# 用元组接收（等价）
point = get_point()
print(point)  # 输出(10, 20)，返回的多个值会自动封装成元组

# 忽略某个返回值（用_）
_, y = get_point()
print(y)  # 输出20

（3）无返回值（返回None）

示例：

def print_hello():
    print("Hello")  # 没有return

result = print_hello()
print(result)  # 输出None

 变量作用域：变量的 “有效范围”

变量不是在所有地方都能使用 —— 它的 “有效范围” 称为作用域。Python 中变量作用域主要分两种：

（1）局部变量：函数内部定义的变量

• 只能在函数内部使用，出了函数就失效；

• 函数调用结束后，局部变量会被销毁。

示例：

def test():
    num = 10  # 局部变量，只能在test内部使用
    print(num)  # 输出10

test()
# print(num)  # 报错：NameError: name 'num' is not defined（num是局部变量，外部不能用）

（2）全局变量：函数外部定义的变量

• 可以在所有函数外部使用；

• 函数内部可以 “读取” 全局变量，但要 “修改” 全局变量，需要用global关键字声明（否则会被视为局部变量）。

示例 1：读取全局变量

num = 10  # 全局变量

def test():
    print(num)  # 读取全局变量，输出10

test()

示例 2：修改全局变量（需global声明）

num = 10  # 全局变量

def test():
    global num  # 声明num是全局变量
    num = 20  # 修改全局变量

test()
print(num)  # 输出20（全局变量被修改）

⚠️ 注意：if、for、while等语句块不会产生作用域—— 在这些语句块中定义的变量，外部也能使用：

for i in range(1, 5):
    num = i  # 在for循环中定义变量

print(num)  # 输出4（num在外部能使用）

 函数的调用：嵌套与递归

（1）嵌套调用：函数内部调用其他函数

函数内部可以调用另一个函数，这称为 “嵌套调用”。

示例：

def add(x, y):
    return x + y

def calc_avg(a, b, c):
    # 调用add函数计算总和
    total = add(a, add(b, c))
    return total / 3

avg = calc_avg(10, 20, 30)
print(avg)  # 输出20.0

（2）递归调用：函数调用自身

递归是一种特殊的嵌套调用：函数内部调用自己。它的核心是 “把大问题拆成小问题”，需要满足两个条件：

1. 存在 “递归结束条件”（否则会无限递归，导致栈溢出）；

2. 每次递归时，参数要 “逼近” 结束条件。

示例：递归计算 n 的阶乘（n! = n × (n-1) × ... × 1）

def factorial(n):
    # 递归结束条件：n=1时，1! = 1
    if n == 1:
        return 1
    # 递归公式：n! = n × (n-1)!
    return n * factorial(n - 1)

print(factorial(5))  # 计算5! = 5×4×3×2×1 = 120，输出120

⚠️ 注意：无限递归会导致 “栈溢出”（RecursionError），比如忘记写结束条件：

def factorial(n):
    # 没有结束条件，会无限递归
    return n * factorial(n - 1)

# factorial(5)  # 报错：RecursionError: maximum recursion depth exceeded

函数的设计原则

1. 单一职责：一个函数只做一件事（比如add只算和，calc_avg只算平均）；

2. 逻辑与交互分离：函数内部尽量不做控制台输入输出（比如calc_sum只返回和，不打印；打印交给调用者）；

3. 注释清晰：用文档字符串说明函数功能、参数、返回值（方便他人使用）。

示例：规范的函数设计

def calc_sum(a, b):
    """
    计算区间[a, b]内所有整数的和（包含a和b）
    
    参数：
        a: int，区间的起始整数
        b: int，区间的结束整数（需大于等于a）
    
    返回值：
        int，区间[a, b]的和
    """
    if b < a:
        raise ValueError("结束值b不能小于起始值a")  # 抛出异常，提示错误
    sum_result = 0
    for i in range(a, b+1):
        sum_result += i
    return sum_result

# 调用函数，打印结果（交互交给调用者）
total = calc_sum(1, 100)
print(f"1~100的和为：{total}")

列表和元组：批量存储数据的 “容器”

列表和元组是 Python 中用于批量表示序列型数据的核心结构，二者功能相似但存在 “可变 / 不可变” 的关键差异 —— 文档中用 “散装辣条” 比喻列表（可随时增减），用 “包装辣条” 比喻元组（固定不可改），非常直观。

列表（List）：可变的 “散装辣条” 容器

（1）列表是什么？

列表是一种可修改的序列结构，用于批量保存任意类型的数据（数字、字符串、布尔值等均可混合存储）。当需要存储的数据集数量不确定或需要动态调整时，优先使用列表。

（2）创建列表

文档中明确了两种核心创建方式，且强调 “避免用list作为变量名”（因list是 Python 内建函数）：

• 空列表创建：

  # 方式1：使用 []
  alist = []
  # 方式2：使用 list() 函数
  alist = list()
  print(type(alist))  # 输出：<class 'list'>
  

• 带初始值的列表：直接在[]中填写元素，元素类型可混合：

  alist = [1, 'hello', True]  # 整数、字符串、布尔值混合
  print(alist)  # 输出：[1, 'hello', True]
  

（3）列表的核心操作

① 访问与修改：下标（索引）操作

列表通过[下标]访问元素，下标从 0 开始计数，也支持负数下标（表示 “倒数第 N 个”）：

• 基本访问：

  alist = [1, 2, 3, 4]
  print(alist[2])   # 下标 2 → 第 3 个元素，输出：3
  print(alist[-1])  # 负数下标 -1 → 倒数第 1 个元素，输出：4
  

• 修改元素：通过[下标] = 新值修改，下标必须在有效范围内（0 ~ len(alist)-1），否则报错：

  alist = [1, 2, 3, 4]
  alist[2] = 100  # 将下标 2 的元素改为 100
  print(alist)    # 输出：[1, 2, 100, 4]
  
  # 下标越界会报错
  print(alist[100])  # 抛出 IndexError: list index out of range
  

• 用len()函数获取列表长度（元素个数）：

  alist = [1, 2, 3, 4]
  print(len(alist))  # 输出：4（有效下标范围 0~3）
  

② 切片操作：批量获取子列表

切片通过[start:end:step]获取连续的子列表，规则为前闭后开区间（包含start，不包含end），step为步长（默认 1），支持省略边界和负步长：

• 基础切片（获取下标 1 到 3 的子列表，不包含 3）：

  alist = [1, 2, 3, 4]
  print(alist[1:3])  # 输出：[2, 3]（对应下标 1、2）
  

• 省略边界：

  alist = [1, 2, 3, 4]
  print(alist[1:])   # 省略 end → 从下标 1 到末尾，输出：[2, 3, 4]
  print(alist[:-1])  # 省略 start → 从开头到倒数第 2 个，输出：[1, 2, 3]
  print(alist[:])    # 省略 start 和 end → 复制整个列表，输出：[1, 2, 3, 4]
  

• 指定步长（含负步长，从后往前取）：

  alist = [1,2,3,4,5,6,7,8,9,10]
  print(alist[::2])   # 步长 2 → 取奇数位置元素，输出：[1,3,5,7,9]
  print(alist[::-1])  # 步长 -1 → 反转列表，输出：[10,9,8,...,1]
  

• 切片越界无副作用：仅返回能获取到的元素，不报错：

  alist = [1,2,3,4]
  print(alist[100:200])  # 输出：[]（无符合条件的元素）
  

③ 遍历列表：逐个获取元素

提供 3 种遍历方式，根据场景选择：

1. 直接遍历元素（最简洁，无需下标）：

   alist = [1,2,3,4]
   for elem in alist:
       print(elem)  # 依次输出：1、2、3、4
   

2. 按下标遍历（需获取下标时用）：

   alist = [1,2,3,4]
   for i in range(len(alist)):
       print(f"下标 {i}：{alist[i]}")  # 输出：下标 0：1、下标 1：2...
   

3. while 循环遍历（手动控制下标）：

   alist = [1,2,3,4]
   i = 0
   while i < len(alist):
       print(alist[i])
       i += 1  # 手动更新下标
   

④ 列表的增删操作

• 新增元素：

  • append(元素)：在列表末尾添加（尾插，效率高）：

    alist = [1,2,3,4]
    alist.append('hello')
    print(alist)  # 输出：[1,2,3,4,'hello']
    

  • insert(下标, 元素)：在指定下标位置插入（会移动后续元素，效率低）：

    alist = [1,2,3,4]
    alist.insert(1, 'hello')  # 在下标 1 插入
    print(alist)  # 输出：[1, 'hello', 2, 3, 4]
    

• 删除元素：

  • pop()：删除并返回列表末尾元素；pop(下标)：删除并返回指定下标元素：

    alist = [1,2,3,4]
    alist.pop()      # 删除末尾元素 4
    alist.pop(1)     # 删除下标 1 的元素 2
    print(alist)     # 输出：[1, 3]
    

  • remove(值)：（注意不要以为是下标）按元素值删除（仅删除第一个匹配值，值不存在报错）：

    alist = [1,2,3,4]
    alist.remove(2)  # 删除值为 2 的元素
    print(alist)     # 输出：[1, 3, 4]
    

• 连接列表：

  • +：拼接两个列表，生成新列表（不修改原列表）：

    alist = [1,2,3]
    blist = [4,5,6]
    print(alist + blist)  # 输出：[1,2,3,4,5,6]
    

  • extend(列表)：将另一个列表的元素追加到当前列表（修改原列表）：

    alist = [1,2,3]
    blist = [4,5,6]
    alist.extend(blist)
    print(alist)  # 输出：[1,2,3,4,5,6]
    print(blist)  # 输出：[4,5,6]（原列表不变）
    

⑤ 查找元素

• in：判断元素是否在列表中，返回布尔值（True/False）：

  alist = [1,2,3,4]
  print(2 in alist)   # 输出：True
  print(10 in alist)  # 输出：False
  

• index(值)：返回元素的下标（值不存在报错）：

  alist = [1,2,3,4]
  print(alist.index(2))  # 输出：1
  

元组（Tuple）：不可变的 “包装辣条” 容器

（1）元组是什么？

元组与列表结构相似，但创建后不可修改（不能新增、删除、修改元素）。当数据集需要 “只读保护” 时，优先使用元组。

（2）创建元组

元组用()表示，创建方式与列表类似，但需注意单个元素的元组必须加逗号（避免与括号表达式混淆）：

• 空元组：

  atuple = ()
  atuple = tuple()
  print(type(atuple))  # 输出：<class 'tuple'>
  

• 带初始值的元组：

  atuple = (1, 'hello', True)  # 多元素元组
  single_tuple = (1,)          # 单个元素元组（必须加逗号）
  print(single_tuple)          # 输出：(1,)
  

（3）元组的操作限制与支持的操作

• 不支持的操作（所有 “修改” 操作均报错）：

  atuple = (1,2,3)
  atuple[0] = 100  # 报错：TypeError: 'tuple' object does not support item assignment
  atuple.append(4) # 报错：AttributeError: 'tuple' object has no attribute 'append'
  

• 支持的操作（仅 “读” 操作，与列表一致）：

  • 下标访问、切片：

    atuple = (1,2,3,4)
    print(atuple[2])    # 输出：3
    print(atuple[1:3])  # 输出：(2, 3)
    

  • 遍历、in、index()：

    atuple = (1,2,3,4)
    for elem in atuple:
        print(elem)          # 依次输出：1、2、3、4
    print(2 in atuple)       # 输出：True
    print(atuple.index(3))   # 输出：2
    

  • 用+拼接（生成新元组）：

    atuple1 = (1,2)
    atuple2 = (3,4)
    print(atuple1 + atuple2)  # 输出：(1,2,3,4)
    

（4）元组的核心优势（为什么需要元组？）

文档明确了元组的两个不可替代的优势：

1. 数据安全：传递元组给函数时，无需担心函数修改数据（列表可能被修改）；

2. 可作为字典的 key：字典的 key 要求是 “可哈希对象”（不可变），元组不可变可哈希，而列表可变不可哈希，无法作为字典 key。

字典：键值对映射的 “查询表”

字典是 Python 中用于存储键值对（key-value） 的结构，类似于java的哈希，核心作用是 “通过 key 快速查找 value”，类似生活中的 “字典”（通过拼音查汉字）、“学号查学生”。

1. 字典是什么？

字典中，key 是唯一的（不能重复），value 可重复且支持任意类型；key 与 value 是 “一对一映射”，通过 key 能直接定位到 value，查询效率极高。

2. 创建字典

字典用{}表示，key 与 value 之间用:分隔，键值对之间用,分隔。文档推荐多键值对时分行书写，代码更清晰：

• 空字典：

  adict = {}
  adict = dict()
  print(type(adict))  # 输出：<class 'dict'>
  

• 带初始值的字典：

  # 单行书写
  student = {'id': 1, 'name': 'zhangsan', 'score': 80}
  # 多行书写（推荐，易读）
  student = {
      'id': 1,
      'name': 'zhangsan',
      'score': 80,  # 末尾逗号可加可不加
  }
  print(student)  # 输出：{'id': 1, 'name': 'zhangsan', 'score': 80}
  

3. 字典的核心操作

（1）查找 value：通过 key 访问

• 用[key]获取 value：key 不存在则报错（KeyError）：

  student = {'id': 1, 'name': 'zhangsan'}
  print(student['id'])   # 输出：1
  print(student['score'])# 报错：KeyError: 'score'
  

• 用in判断 key 是否存在：返回布尔值，避免报错：

  student = {'id': 1, 'name': 'zhangsan'}
  print('score' in student)  # 输出：False
  

（2）新增 / 修改键值对

字典通过[key] = value实现新增或修改，逻辑为：

• 若 key 不存在：新增键值对；

• 若 key 已存在：修改 value；

student = {'id': 1, 'name': 'zhangsan'}
student['score'] = 90  # key 不存在 → 新增
student['name'] = 'lisi'  # key 存在 → 修改
print(student)  # 输出：{'id': 1, 'name': 'lisi', 'score': 90}

（3）删除键值对

用pop(key)删除指定 key 的键值对，key 不存在报错：

student = {'id': 1, 'name': 'zhangsan', 'score': 80}
student.pop('score')  # 删除 'score' 键值对
print(student)        # 输出：{'id': 1, 'name': 'zhangsan'}

（4）遍历字典

字典遍历的核心是 “遍历 key”，再通过 key 获取 value，文档提供 4 种常见方式：

遍历 key（默认）：

student = {'id': 1, 'name': 'zhangsan', 'score': 80}
for key in student:
    print(f"{key}: {student[key]}")  # 输出：id:1、name:zhangsan、score:80

用keys()获取所有 key：返回dict_keys类型（支持遍历，类似列表）：

print(student.keys())  # 输出：dict_keys(['id', 'name', 'score'])
for key in student.keys():
    print(key)  # 依次输出：id、name、score

用values()获取所有 value：返回dict_values类型：

print(student.values())  # 输出：dict_values([1, 'zhangsan', 80])
for value in student.values():
    print(value)  # 依次输出：1、zhangsan、80

用items()获取所有键值对：返回dict_items类型（每个元素是(key, value)元组）：

print(student.items())  # 输出：dict_items([('id', 1), ('name', 'zhangsan'), ('score', 80)])
for key, value in student.items():
    print(f"{key}: {value}")  # 同方式 1，更简洁

（5）合法的 key 类型

字典的 key 必须是 “可哈希对象”（即能通过hash()函数计算出固定哈希值的类型），明确：

• 支持的 key 类型：int（整数）、str（字符串）、bool（布尔值）、tuple（元组）等不可变类型：

  print(hash(1))       # 输出：1（整数可哈希）
  print(hash('hello')) # 输出：-232464653545525718（字符串可哈希）
  print(hash(()))      # 输出：5740354900026072187（空元组可哈希）
  

• 不支持的 key 类型：list（列表）、dict（字典）等可变类型（不可哈希，报错）：

  hash([1,2,3])  # 报错：TypeError: unhashable type: 'list'
  hash({'a':1})  # 报错：TypeError: unhashable type: 'dict'
  

文件：数据持久化的 “硬盘容器”

        变量存储的数据在程序 / 电脑重启后会丢失，而文件能将数据持久化存储到硬盘，是程序与外部数据交互的核心方式。文档重点讲解 “文本文件” 的操作（最基础、最常用）。

• 文件的本质：硬盘上的一段二进制数据，通过 “文件名 + 路径” 唯一标识；

• 常见文件类型（文档列举）：

  • 文本文件：.txt（纯文本，人类可读）；

  • 可执行文件：.exe、.dll（机器可执行）；

  • 媒体文件：.jpg（图片）、.mp4（视频）；

  • 办公文件：.docx（Word）、.ppt（PPT）。

文件路径：定位文件的 “地址”

要操作文件，必须先通过 “路径” 告诉程序文件的位置，文档分两种路径：

（1）绝对路径

从 “盘符” 开始的完整路径，如D:/program/qq/Bin/QQ.exe，特点是 “唯一、不依赖基准目录”，新手推荐使用（不易出错）。

• 路径分隔符：Windows 支持\或/，代码中推荐用/（避免\的转义问题）；

• 示例：D:/test.txt（D 盘根目录下的test.txt文件）。

（2）相对路径

以 “当前程序所在目录” 为基准的路径（如./test.txt表示程序同目录下的test.txt），文档暂不展开（新手易混淆，建议先掌握绝对路径）。

 文件操作流程：打开 → 读写 → 关闭

文件操作必须遵循 “打开→操作→关闭” 的流程，文档详细说明了每个步骤的用法与注意事项。

（1）打开文件：open()函数

用 Python 内建函数open()打开文件，返回 “文件对象”（后续读写操作依赖此对象），语法：

文件对象 = open(文件路径, 打开方式, encoding=编码方式)

• 核心参数：

  1. 文件路径：字符串，绝对路径（如D:/test.txt）或相对路径；

  2. 打开方式：字符串，控制文件的读写权限，文档重点讲 3 种：

     • r：只读模式（默认），文件不存在则报错；

     • w：只写模式，文件不存在则创建，文件存在则清空原有内容；

     • a：追加模式，文件不存在则创建，写入内容追加到文件末尾（不清空原有内容）；

  3. encoding：字符串，指定文件编码（处理中文必须设置，如utf-8、gbk）。

• 示例：

  # 以只读模式打开 D 盘的 test.txt，编码为 utf-8
  f = open('D:/test.txt', 'r', encoding='utf-8')
  

• 打开失败：路径错误或文件不存在时，抛出FileNotFoundError：

  open('D:/不存在的文件.txt', 'r')  # 报错：FileNotFoundError: [Errno 2] No such file or directory: 'D:/不存在的文件.txt'
  

（2）读写文件：根据打开方式操作

① 写文件（w或a模式）

用文件对象的write(内容)方法写入，内容必须是字符串：

• w模式（清空写入）：

  # 打开文件（w 模式）
  f = open('D:/test.txt', 'w', encoding='utf-8')
  f.write('hello world')  # 写入字符串
  f.close()  # 必须关闭文件（否则内容可能未真正写入硬盘）
  

• a模式（追加写入）：

  f = open('D:/test.txt', 'a', encoding='utf-8')
  f.write('\nPython  file')  # 追加内容（\n 是换行符）
  f.close()
  

• 注意：r模式下写文件会报错：

  f = open('D:/test.txt', 'r')
  f.write('hello')  # 报错：io.UnsupportedOperation: not writable
  

② 读文件（r模式）

文档提供 3 种常见读方式：

read(n)：读取n个字符（n省略则读取全部内容）：

f = open('D:/test.txt', 'r', encoding='utf-8')
content = f.read(5)  # 读取前 5 个字符
print(content)       # 输出：hello
f.close()

for 循环读行：逐行读取（处理大文件高效，避免内存溢出）：

# 假设 test.txt 内容：
# 床前明月光
# 疑是地上霜
f = open('D:/test.txt', 'r', encoding='utf-8')
for line in f:
    print(line, end='')  # end='' 避免 print 自动加换行（文件每行已含换行符）
f.close()
# 输出：
# 床前明月光
# 疑是地上霜

readlines()：读取所有行，返回列表（每行是列表的一个元素）：

f = open('D:/test.txt', 'r', encoding='utf-8')
lines = f.readlines()
print(lines)  # 输出：['床前明月光\n', '疑是地上霜\n']
f.close()

（3）关闭文件：close()方法

必须用文件对象的close()方法关闭文件，原因：

• 程序能同时打开的文件数量有限，不关闭会导致 “文件句柄泄漏”，最终报错（OSError: Too many open files）；

• 未关闭的文件，写入内容可能停留在内存缓冲区，未真正写入硬盘（丢失数据）。

• 示例：

  f = open('D:/test.txt', 'r')
  f.read()
  f.close()  # 关闭文件（必须执行）
  

• 注意：关闭后的文件对象不能再操作，否则报错：

  f.close()
  f.read()  # 报错：ValueError: I/O operation on closed file.
  

中文编码问题：避免乱码或解码错误

文档强调：文件编码与代码读取编码必须一致，否则会出现乱码或UnicodeDecodeError。

• 常见中文编码：

  • gbk：Windows 系统默认编码（记事本保存的 “ANSI” 格式即gbk）；

  • utf-8：跨平台通用编码（推荐使用）。

• 解决方法：用open()的encoding参数显式指定编码：

  # 若文件是 utf-8 编码，指定 encoding='utf-8'
  f = open('D:/test.txt', 'r', encoding='utf-8')
  # 若文件是 gbk 编码，指定 encoding='gbk'
  f = open('D:/test.txt', 'r', encoding='gbk')
  

上下文管理器：with语句（自动关闭文件）

文档推荐用with语句打开文件，无需手动调用close()——with块执行完毕后，会自动关闭文件（即使发生异常），代码更简洁、安全。

• 语法与示例：

  with open('D:/test.txt', 'r', encoding='utf-8') as f:
      # with 块内操作文件对象 f
      content = f.read()
      print(content)
  # 出 with 块后，文件自动关闭，无需 f.close()
  

标准库：Python自带的工具箱

标准库是 Python 安装后默认自带的库，无需额外安装即可直接使用。其覆盖场景极广，是 Python 生态的基础支撑。

认识标准库：覆盖哪些核心场景？

Python 标准库包含数千个模块，涵盖开发中的常见需求，无需记忆所有内容，只需了解大致分类，使用时查阅官方文档即可。官方文档地址：https://docs.python.org/3.10/library/index.html

核心分类及说明如下：

分类	核心功能示例
内置函数 / 类型	函数：print()、input()；类型：int、str、list、dict 及内置操作（如 str.split()）
文本处理	字符串切割、拼接、前缀判定等（如 str.startswith()）
时间日期	日期构造、差值计算（如 datetime 模块）
数学计算	数值运算、三角函数（如 math 模块）
文件目录	目录遍历、文件操作（如 os 模块的 os.walk()）
数据存储	数据库操作、数据序列化（如 json 模块）
加密解密	哈希计算、加密算法（如 hashlib 模块）
操作系统相关	进程管理、环境变量（如 os 模块）
并发编程	多进程、多线程、协程（如 threading、multiprocessing 模块）
网络编程	TCP/UDP 通信、HTTP 请求（如 socket 模块）
多媒体 / 图形化界面	音频处理、窗口开发（如 tkinter 模块）

标准库的使用：import 导入模块

标准库的模块本质是独立的 .py 文件，需通过 import [模块名] 导入当前代码文件后使用。以下结合文档中的3 个实战案例，讲解具体用法。

案例 1：日期计算（datetime 模块）

需求：输入两个日期，计算间隔天数（如计算与 “心爱之人” 的相识天数）。

• 核心思路：用 datetime.datetime 构造日期对象，直接相减得到差值。

• 代码实现：

  # 导入datetime模块
  import datetime
  
  # 构造两个日期对象（参数格式：年, 月, 日）
  date1 = datetime.datetime(2012, 2, 14)  # 起始日期
  date2 = datetime.datetime(2022, 7, 12)  # 结束日期
  
  # 日期对象相减，输出间隔
  print(date2 - date1)  # 输出：3801 days, 0:00:00
  

• 扩展：更多日期操作（如格式化、时区转换）可参考官方文档：https://docs.python.org/3/library/datetime.html

案例 2：字符串操作（内置 str 类型）

字符串是 Python 内置类型，其方法无需导入额外模块，可直接使用。

分类	方法 / 操作	功能描述	示例	返回值
创建与转换	str(obj)	将对象转为字符串	str(123) → "123"	新字符串
	单 / 双 / 三引号	直接定义字符串（三引号支持多行）	s = 'hi'；s = """line1\nline2"""	字符串变量
	r"..."（原始字符串）	忽略转义字符（如\n不解析为换行）	r"a\nb" → "a\\nb"	原始字符串
修改（返回新串）	s.replace(old, new, count)	替换子串old为new，count指定替换次数（默认全部）	"abac".replace("a", "x", 2) → "xbxc"	新字符串
	s.strip(chars)	去除首尾指定字符（默认去除空白：空格、\n、\t等）	" abc ".strip() → "abc"；"###abc##".strip("#") → "abc"	新字符串
	s.lstrip(chars)	去除左侧指定字符	" abc ".lstrip() → "abc "	新字符串
	s.rstrip(chars)	去除右侧指定字符	" abc ".rstrip() → " abc"	新字符串
	s.center(width, fillchar)	居中对齐，用fillchar（默认空格）填充至width长度	"hi".center(5, "*") → "*hi*"	新字符串
	s.ljust(width, fillchar)	左对齐，填充至width长度	"hi".ljust(5, "-") → "hi---"	新字符串
	s.rjust(width, fillchar)	右对齐，填充至width长度	"hi".rjust(5, "-") → "---hi"	新字符串
判断（布尔值）	s.isalpha()	是否全为字母（无数字 / 符号）	"abc".isalpha() → True	bool
	s.isdigit()	是否全为数字（0-9，不包含中文数字）	"123".isdigit() → True	bool
	s.isalnum()	是否全为字母或数字	"abc123".isalnum() → True	bool
	s.isspace()	是否全为空白字符（空格、\n、\t等）	" \t\n".isspace() → True	bool
	s.islower()	是否全为小写字母	"abc".islower() → True	bool
	s.isupper()	是否全为大写字母	"ABC".isupper() → True	bool
	s.startswith(prefix)	是否以prefix开头（prefix可为元组，匹配任一）	"test".startswith(("te", "a")) → True	bool
	s.endswith(suffix)	是否以suffix结尾（suffix可为元组，匹配任一）	"test".endswith(("st", "x")) → True	bool
查找与计数	s.find(sub, start, end)	从start到end查找sub，返回首个索引；无则返回-1	"abac".find("a") → 0；find("x") → -1	整数
	s.rfind(sub, start, end)	从右侧查找sub，返回首个索引；无则返回-1	"abac".rfind("a") → 2	整数
	s.index(sub, start, end)	同find，但无匹配时抛ValueError	"abac".index("a") → 0	整数（无匹配则报错）
	s.rindex(sub, start, end)	同rfind，但无匹配时抛ValueError	"abac".rindex("a") → 2	整数（无匹配则报错）
	s.count(sub, start, end)	统计sub在start到end间出现的次数	"abac".count("a") → 2	整数
分割与连接	s.split(sep, maxsplit)	按sep分割（默认按空白），maxsplit指定最大分割次数（默认全部分割）	"a,b,c".split(",") → ["a","b","c"]；"a b c".split(maxsplit=1) → ["a", "b c"]	列表
	s.rsplit(sep, maxsplit)	从右侧按sep分割，maxsplit指定最大次数	"a/b/c".rsplit("/", 1) → ["a/b", "c"]	列表
	s.splitlines(keepends)	按换行符（\n、\r\n等）分割，keepends=True保留换行符	"line1\nline2".splitlines() → ["line1", "line2"]	列表
	sep.join(iterable)	用sep连接可迭代对象（元素需为字符串）	"-".join(["a","b"]) → "a-b"	新字符串
大小写转换	s.lower()	转为全小写	"AbC".lower() → "abc"	新字符串
	s.upper()	转为全大写	"AbC".upper() → "ABC"	新字符串
	s.title()	每个单词首字母大写（其余小写）	"hello world".title() → "Hello World"	新字符串
	s.capitalize()	首字符大写，其余小写	"hello".capitalize() → "Hello"	新字符串
	s.swapcase()	大小写互换	"AbC".swapcase() → "aBc"	新字符串
格式化	s.format(*args, **kwargs)	格式化字符串（用{}占位）	"I am {age}".format(age=18) → "I am 18"	新字符串
	f-string（f"{var}"）	嵌入式格式化（Python 3.6+）	name="Tom"; f"Hi {name}" → "Hi Tom"	新字符串
编码解码	s.encode(encoding)	按encoding（默认utf-8）编码为字节串	"你好".encode() → b'\xe4\xbd\xa0\xe5\xa5\xbd'	字节串（bytes）
	bytes.decode(encoding)	字节串按encoding解码为字符串（需配合bytes使用）	b'\xe4\xbd\xa0'.decode() → "你"	字符串

案例 3：文件查找工具（os 模块）

需求：指定路径和关键词，查找路径下所有文件名含关键词的文件。

• 核心方法：os.walk(路径)—— 递归遍历目录，返回三元组 (当前路径, 子目录列表, 文件列表)。

• 代码实现：

  import os
  
  # 输入待搜索路径和关键词
  inputPath = input('请输入待搜索路径: ')
  pattern = input('请输入待搜索关键词: ')
  
  # 递归遍历目录
  for dirpath, dirnames, filenames in os.walk(inputPath):
      for f in filenames:
          if pattern in f:  # 文件名含关键词
              print(f'{dirpath}/{f}')  # 输出文件完整路径
  

• 扩展：更多 os 模块操作（如创建目录、删除文件）可参考官方文档：https://docs.python.org/3/library/os.html

第三方库：Python 生态的 “扩展包”

第三方库是开发者或组织编写并发布的库，需额外安装才能使用。其覆盖场景远超标准库（如二维码生成、Excel 操作、键盘监听等），是 Python 生态强大的核心原因。

第三方库的核心使用流程

使用第三方库需遵循 “找库 → 安装 → 导入使用” 三步流程：

步骤 1：找库 —— 确定合适的第三方库

遇到需求时，通过搜索引擎（百度、Bing、搜狗等）查询 “Python + 需求”（如 “Python 生成二维码”），即可找到常用库（如 qrcode 库）。

步骤 2：安装 —— 用 pip 管理库

pip 是 Python 内置的包管理器（类似手机 “应用商店”），可从官方库仓库 PyPI（https://pypi.org/）下载安装第三方库。

（1）验证 pip 是否可用

打开 cmd（Windows）或终端（Mac/Linux），输入 pip，若显示帮助信息（如下），则说明可用：

C:\Users>pip
Usage: pip <command> [options]
Commands:
  install    Install packages.
  uninstall  Uninstall packages.
  list       List installed packages.
  ...

• 若提示 “pip 不是内部或外部命令”：需将 Python 安装目录下的 Scripts 文件夹（含 pip.exe）添加到系统 PATH 环境变量，或重装 Python 并勾选 “Add Python 3.10 to PATH”。

（2）安装第三方库

基本命令：pip install [库名]（需联网，安装成功后即可导入使用）。

• 特殊情况：部分库需指定版本（如 xlrd 最新版不支持 xlsx 格式，需安装旧版），命令为 pip install [库名]==[版本号]（如 pip install xlrd==1.2.0）。

步骤 3：导入使用 —— 与标准库用法一致

安装完成后，通过 import [库名] 导入模块，语法与标准库完全相同。

第三方库实战案例

案例 1：生成二维码（qrcode 库）

需求：生成含指定内容（如 “请关注中草药”）的二维码图片，扫码可查看内容。

• 步骤 1：确定库 —— 搜索 “Python 生成二维码”，选择 qrcode 库。

• 步骤 2：安装库 ——pip install qrcode[pil]（[pil] 是依赖的图像处理模块）。

• 步骤 3：编写代码：

  import qrcode
  
  # 生成二维码（内容为字符串）
  img = qrcode.make('请关注中草药')
  # 保存二维码图片（格式为png）
  img.save('qrcode.png')
  

• 原理：二维码本质是 “黑白点阵表示字符串”，若内容为 URL（如 "https://www.baidu.com"），扫码后会自动跳转网页。

案例 2：操作 Excel（xlrd 库）

需求：读取 Excel 文件（d:/test.xlsx），计算 “101 班” 学生的平均分（Excel 内容含 “姓名、班级、分数”）。

• 步骤 1：确定库 —— 读取 Excel 用 xlrd 库，修改用 xlwt 库。

• 步骤 2：安装库 ——pip install xlrd==1.2.0（指定版本，避免不支持 xlsx 格式）。

• 步骤 3：编写代码：

  import xlrd
  
  # 1. 打开Excel文件
  xlsx = xlrd.open_workbook('d:/test.xlsx')
  # 2. 获取第0个标签页（Excel默认第一个标签页索引为0）
  table = xlsx.sheet_by_index(0)
  # 3. 获取总行数（用于遍历）
  nrows = table.nrows
  
  # 4. 遍历数据，计算101班平均分
  count = 0  # 101班学生人数
  total = 0  # 101班总分
  for i in range(1, nrows):  # 从第1行开始（第0行为表头）
      classId = table.cell_value(i, 1)  # 获取第i行第1列（班级）
      if classId == 101:  # 筛选101班
          score = table.cell_value(i, 2)  # 获取第i行第2列（分数）
          total += score
          count += 1
  
  print(f'101班平均分: {total / count}')  # 输出平均分
  

• 扩展：xlrd 文档：https://xlrd.readthedocs.io/en/latest/；xlwt 文档：https://xlwt.readthedocs.io/en/latest/

案例 3：程序猿鼓励师（pynput + playsound 库）

需求：监听键盘按键，每按 10 次自动播放音频（ding.mp3），鼓励开发者。

• 步骤 1：确定库 ——pynput 监听键盘，playsound 播放音频。

• 步骤 2：安装库 —— 指定旧版本避免兼容性问题：

  pip install pynput==1.6.8
  pip install playsound==1.2.2
  

• 步骤 3：编写代码（多线程解决音频卡顿）：

• 注意：需将 ding.mp3 音频文件放在代码同级目录下。

---

推荐 3 个提升 Python 库使用能力的资源：

1. 《Python Cookbook（第 3 版）》：经典进阶书籍，针对各类场景提供库的实战解决方案。

2. awesome-python：整理了 Python 实用库的集合，地址：https://gitee.com/awesome-lib/awesome-python。

3. 500 Lines or Less：用简短代码实现有趣程序，学习库的精简用法，地址：https://github.com/aosabook/500lines。

---

要为重活而高兴，不要为死去的忧伤。                                                                ——林清玄

🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀

以上，就是本期的全部内容啦，若有错误疏忽希望各位大佬及时指出💐

  制作不易，希望能对各位提供微小的帮助，可否留下你免费的赞呢🌸 

转载自CSDN-专业IT技术社区

原文链接：https://blog.csdn.net/2302_79806056/article/details/153927608