Python 核心语法实战：变量、流程控制与函数详解

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

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

核心运算符分类

• 算术运算符：+（加）、-（减）、*（乘）、/（除）、%（取余）、//（整除）、**（幂运算）。实例：print(7//3) # 输出 2（整除取整数部分）；print(2**3) # 输出 8（2 的 3 次方）。
• 除零异常：/、//、%的除数不能为 0，否则会报错（ZeroDivisionError）。
• %求余的正负：结果的正负和被除数一致（比如 7%3=1，-7%3=2，7%-3=-2）。

# 求余示例
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.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）创建列表

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

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

空列表创建：

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

（3）列表的核心操作

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

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

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

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

修改元素：通过 [下标] = 新值 修改，下标必须在有效范围内（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

基本访问：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

④ 列表的增删操作

• 新增元素：
• 删除元素：
• 连接列表：

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]（原列表不变）

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

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

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

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

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

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

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

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

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

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

⑤ 查找元素

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

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

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

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

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

（1）元组是什么？

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

（2）创建元组

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

带初始值的元组：

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

空元组：

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

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

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

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

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

遍历、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

下标访问、切片：

atuple = (1,2,3,4)
print(atuple[2]) # 输出：3
print(atuple[1:3]) # 输出：(2, 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'

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

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

1. 数据安全：传递元组给函数时，无需担心函数修改数据（列表可能被修改）；
2. 可作为字典的 key：字典的 key 要求是'可哈希对象'（不可变），元组不可变可哈希，而列表可变不可哈希，无法作为字典 key。

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

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

1. 字典是什么？

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

2. 创建字典

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

带初始值的字典：

# 单行书写
student = {'id': 1, 'name': 'zhangsan', 'score': 80}

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

空字典：

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

3. 字典的核心操作

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

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

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

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

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

（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 类型：list（列表）、dict（字典）等可变类型（不可哈希，报错）：

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

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

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

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

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

• 文件的本质：硬盘上的一段二进制数据，通过'文件名 + 路径'唯一标识；
• 常见文件类型（文档列举）：
  • 文本文件：.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）。

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

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

示例：

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

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

① 写文件（w 或 a 模式）

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

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

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

a 模式（追加写入）：

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

w 模式（清空写入）：

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

② 读文件（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,) # 避免 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.close()
f.read() # 报错：ValueError: I/O operation on closed file.

示例：

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

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

文档强调：文件编码与代码读取编码必须一致，否则会出现乱码或 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 块内操作文件对象 content = f.read()
    print(content)
# 出 with 块后，文件自动关闭，无需 f.close()

标准库：Python 自带的工具箱

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

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

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

核心分类及说明如下：

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

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

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

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

• 核心思路：用 datetime.datetime 构造日期对象，直接相减得到差值。
• 扩展：更多日期操作（如格式化、时区转换）可参考官方文档：https://docs.python.org/3/library/datetime.html

代码实现：

# 导入 datetime 模块
import datetime

# 构造两个日期对象（参数格式：年，月，日）
date1 = datetime.datetime(2012, 2, 14) # 起始日期
date2 = datetime.datetime(2022, 7, 12) # 结束日期

# 日期对象相减，输出间隔
print(date2 - date1) # 输出：3801 days, 0:00:00

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

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

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

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

• 核心方法：os.walk(路径)——递归遍历目录，返回三元组（当前路径，子目录列表，文件列表）。
• 扩展：更多 os 模块操作（如创建目录、删除文件）可参考官方文档：https://docs.python.org/3/library/os.html

代码实现：

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}') # 输出文件完整路径

第三方库：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] 是依赖的图像处理模块）。
• 原理：二维码本质是'黑白点阵表示字符串'，若内容为 URL（如"https://www.baidu.com"），扫码后会自动跳转网页。

步骤 3：编写代码：

import qrcode

# 生成二维码（内容为字符串）
img = qrcode.make('请关注中草药')

# 保存二维码图片（格式为 png）
img.save('qrcode.png')

案例 2：操作 Excel（xlrd 库）

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

• 步骤 1：确定库——读取 Excel 用 xlrd 库，修改用 xlwt 库。
• 步骤 2：安装库——pip install xlrd==1.2.0（指定版本，避免不支持 xlsx 格式）。
• 扩展：xlrd 文档：https://xlrd.readthedocs.io/en/latest/；xlwt 文档：https://xlwt.readthedocs.io/en/latest/

步骤 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}') # 输出平均分

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

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

• 步骤 1：确定库——pynput 监听键盘，playsound 播放音频。
• 步骤 3：编写代码（多线程解决音频卡顿）：
• 注意：需将 ding.mp3 音频文件放在代码同级目录下。

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

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