Python期末复习

1.基本语法

• 基本命名规则：由字母、数字、下划线组成，不能以数字开头，不能与关键字冲突
• 动态类型，赋值即定义a ＝ 10

1.1 生成式表达式

生成式表达式（Generator Expression）是 Python 中一种紧凑、高效的循环语法，核心作用是动态生成可迭代对象（逐个产生元素，而非一次性创建完整列表 / 集合），语法简洁且内存占用低。

它和你可能听过的 "列表推导式"（[x for x in ...]）语法相似，但用圆括号 () 包裹，本质是 "生成器"（Generator）------ 只有在迭代时才计算元素，迭代一次消耗一个元素，不会提前占用大量内存。

生成式表达式的基本语法

(表达式 for 变量 in 可迭代对象 [if 条件判断])

• 方括号 [] 中的 if 条件判断 是可选的；
• 执行逻辑：循环遍历 "可迭代对象" 的每个元素，满足条件（若有）则执行 "表达式"，生成一个新元素；
• 核心特点：惰性计算（用的时候才生成元素）、不占用额外内存（不会一次性存所有元素）。

1.2 分支

1.2.0 if 单分支语句

• 语法：if 条件表达式: + 缩进的代码块（条件为True时执行）。

• 示例：

  score = 85
  if score >= 60:
      print("成绩合格")  # 条件成立，执行该语句

1.2.1 if-else 双分支语句

• 语法：if 条件: + 缩进代码块1（条件真），else: + 缩进代码块2（条件假）。

• 示例：

  age = 17
  if age >= 18:
      print("成年")
  else:
      print("未成年")  # 条件不成立，执行else块

1.2.2 if-elif-else 多分支语句

• 语法：按if→elif→...→else顺序判断，满足首个条件即执行对应代码块，后续不再判断。

• 示例：

  score = 88
  if score >= 90:
      print("优秀")
  elif score >= 70:
      print("良好")  # 满足该条件，执行后跳出分支
  elif score >= 60:
      print("合格")
  else:
      print("不合格")

1.2.3 三元表达式（简洁条件赋值）

• 语法：变量 = 值1 if 条件 else 值2，条件真取值1，假取值2。
• 示例：status = "成年" if age >= 18 else "未成年"

1.3 循环语句

1.3.1 for 循环（遍历型循环）

• 核心用途：遍历可迭代对象（列表、字符串、字典、range等）。
• 基础语法：for 变量 in 可迭代对象: + 缩进代码块。
• 常见示例：

 # 遍历字符串
 for char in "Python":
     print(char)
 # 遍历range（生成指定范围整数）
 for i in range(3):  # 生成0、1、2
     print(i)
 # 遍历字典
 person = {"name": "Alice", "age": 30}
 for key, value in person.items():
     print(f"{key}: {value}")

1.3.2 while 循环（条件型循环）

• 语法：while 条件表达式: + 缩进代码块，条件为True时持续执行。

• 关键：需在循环内修改条件变量，避免无限循环。

• 示例：

  count = 0
  while count < 5:
      print(count)
      count += 1  # 修改条件变量，避免无限循环

1.3.3 循环控制语句

• break：立即终止当前所在的最内层循环，跳出循环执行后续代码。

  for i in range(10):
      if i == 5:
          break  # 当i=5时，终止循环
      print(i)  # 输出0-4

• continue：跳过当前迭代的剩余代码，直接进入下一次迭代。

  for i in range(5):
      if i == 2:
          continue  # 跳过i=2的迭代
      print(i)  # 输出0、1、3、4

• pass：空操作占位符，维持代码结构完整，无实际功能。

  for i in range(3):
      if i == 1:
          pass  # 语法占位，暂不处理
      print(i)

1.3.4 循环的 else 子句

• 语法：循环后接else: + 缩进代码块，仅在循环"正常结束"（未被break终止）时执行。

• 示例：

  for i in range(3):
      print(i)
  else:
      print("循环正常结束")  # 会执行

1.4 流程控制嵌套

1.4.1 条件语句嵌套

• 语法：在if/elif/else代码块内嵌套另一个条件语句。

• 示例：

  x = 15
  if x > 10:
      if x < 20:
          print("x在10-20之间")  # 满足嵌套条件，执行该语句

1.4.2 循环语句嵌套

• 语法：在for/while循环内嵌套另一个循环（for/while）。

• 示例：

  # 嵌套for循环
  for i in range(2):
      for j in range(3):
          print(f"({i}, {j})")  # 输出(0,0)、(0,1)、(0,2)、(1,0)等

1.4.3 条件与循环混合嵌套

• 示例（猜数字游戏核心逻辑）：

  secret = 50
  while True:
      guess = int(input("猜数字："))
      if guess < secret:
          print("太小了")
      elif guess > secret:
          print("太大了")
      else:
          print("猜对了！")
          break

2.常用数据结构及方法

2.1 字符串基础与基本操作

2.1.0 字符串定义与引号使用

字符串是Python中表示文本数据的类型，需用引号括起，不同引号的功能差异如下：

• 单引号（' '）：可包含双引号，不可跨行。示例：s1 = 'He said "Python"'

• 双引号（" "）：可包含单引号，不可跨行。示例：s2 = "It's a book"

• 三单引号（''' '''）/三双引号（""" """）：支持跨行，可包含任意引号。示例：

  s3 = '''Python字符串
  支持跨行书写'''
  s4 = """包含"双引号"和'单引号'"""

2.1.1 字符串基本运算符

• 拼接（+）：连接多个字符串，返回新字符串。示例：

  name = "李白"
  country = "俄罗斯"
  s = "世界那么大，" + name + "想去" + country + "看看"
  print(s)  # 输出：世界那么大，李白想去俄罗斯看看

• 复制（*）：重复字符串指定次数。示例：print("To" * 3) # 输出：ToToTo

• 子串判断（in/not in）：判断子串是否存在，区分大小写。示例：

  print("He" in "Hello")  # 输出：True
  print("he" in "Hello")  # 输出：False

2.1.2 字符串不可变性

字符串是不可变对象（Immutable），创建后无法原地修改单个字符，修改需通过生成新字符串实现。示例：

s = "Hello"
# s[0] = "h"  # 报错：TypeError（不可原地修改）
# 间接修改：切片拼接生成新字符串
new_s = "h" + s[1:]
print(new_s)  # 输出：hello（原字符串s仍为"Hello"）

2.2 字符串索引与切片

2.2.0 字符串索引规则

字符串中每个字符对应唯一索引，支持两种计数方式：

• 正向递增：从左到右，起始为0。示例：s = "Hello Mike" 中，s[0] = "H"，s[6] = "M"
• 反向递减：从右到左，起始为-1。示例：s[-1] = "e"，s[-4] = "M"

2.2.1 基础切片（无步长）

切片语法：s[头下标:尾下标]，遵循"左闭右开"规则（包含头下标，不包含尾下标），缺省下标时默认取到头/尾。示例：

s = "Hello Mike"  # 索引：0:H,1:e,2:l,3:l,4:o,5: ,6:M,7:i,8:k,9:e
print(s[0:5])   # 取0-4索引：Hello
print(s[6:-1])  # 取6-8索引：Mik
print(s[:5])    # 缺头下标，从开头取：Hello
print(s[6:])    # 缺尾下标，取到末尾：Mike
print(s[:])     # 缺头缺尾，取整个字符串：Hello Mike

2.2.2 带步长切片

切片语法扩展：s[头下标:尾下标:步长]，步长控制取值间隔与方向（正：左→右，负：右→左）。示例：

s = "Hello Mike"
print(s[0:6:2])  # 步长=2（左→右，间隔1）：Hlo
print(s[4:0:-1]) # 步长=-1（右→左，不含0索引）：olle
print(s[::-1])   # 步长=-1（反转字符串）：ekiM olleH
print(s[::-3])   # 步长=-3（反向间隔2）：eklH

2.3 字符串常用函数与方法

2.3.0 核心内置函数

• len(x)：返回字符串长度。示例：print(len("好好学习，天天向上")) # 输出：9

• str(x)：将任意类型转为字符串 。示例：print(str(125)) # 输出：'125'

• ord(x)/chr(x)：Unicode编码与字符互转 。示例：

  print(ord("A"))  # 输出：65（A的Unicode编码）
  print(chr(100))  # 输出：d（编码100对应字符）

• max(x)/min(x)：返回字符串中Unicode编码最大/最小的字符。示例：

  s = "abcXYZ"
  print(max(s))  # 输出：z（编码122）
  print(min(s))  # 输出：A（编码65）

2.3.1 查找与计数方法

• find(sub)/rfind(sub)：从左/右查找子串，返回首次索引（未找到返回-1）。示例：

  s = "bird, fish, monkey, fish"
  print(s.find("fish"))  # 输出：5
  print(s.rfind("fish")) # 输出：20

• count(sub)：统计子串出现次数。示例：print(s.count("i")) # 输出：3

2.3.2 分割与连接方法

• split(sep)：按分隔符分割字符串，返回列表（默认按空格分割）。示例：

  s = "I am a boy"
  print(s.split())  # 输出：['I', 'am', 'a', 'boy']

• join(iterable)：用字符串连接可迭代对象（元素需为字符串），返回新字符串。示例：

  lst = ["apple", "banana", "pear"]
  print(":".join(lst))  # 输出：apple:banana:pear

2.3.3 替换与去空白方法

• replace(old, new)：替换子串。示例：

  s = "Hello World"
  print(s.replace("World", "Python"))  # 输出：Hello Python

• strip()/lstrip()/rstrip()：去除两端/左端/右端空白。示例：

  s = "  Hello  "
  print(s.strip())  # 输出：Hello
  print(s.lstrip()) # 输出：Hello  

2.4 格式化字符串

2.4.1 旧式格式化（% 语法）

通过%搭配格式符（%s字符串、%d整数等）实现格式化。示例：

name = "Jack"
age = 20
print("姓名：%s，年龄：%d" % (name, age))  # 输出：姓名：Jack，年龄：20

2.4.2 新式格式化（str.format()）

支持位置指定、填充对齐、精度控制，灵活性更高。示例：

# 基础用法（按位置/关键字）
print("我是{}班{}号".format("化工1701", 28))  # 输出：我是化工1701班28号
print("我是{1}班{0}号".format(28, "化工1701"))  # 按索引：我是化工1701班28号

# 高级控制（填充、对齐、精度）
print("{:*^20}".format("Mike"))  # 宽度20，居中，*填充：********Mike********
print("{:.2f}".format(3.1415))  # 保留2位小数：3.14

2.4.3 字符串插值（f-Strings，Python3.6+）

直接在字符串中嵌入变量/表达式，语法简洁。示例：

name = "Jack"
age = 20
print(f"姓名：{name}，明年年龄：{age + 1}")  # 输出：姓名：Jack，明年年龄：21

2.5 字符串与列表的转换

2.5.1 字符串转列表

• 方法1：split(sep)：按分隔符分割为列表。示例：

  s = "apple banana pear"
  lst = s.split() # 默认按照空格分隔
  print(lst)  # 输出：['apple', 'banana', 'pear']

• 方法2：list()：将每个字符转为列表元素。示例：

  s = "Hello"
  lst = list(s)
  print(lst)  # 输出：['H', 'e', 'l', 'l', 'o']

2.5.2 列表转字符串

通过join()方法实现，列表元素需为字符串类型。示例：

lst1 = ['H', 'e', 'l', 'l', 'o']
s1 = "".join(lst1)
print(s1)  # 输出：Hello

lst2 = ['apple', 'banana']
s2 = "-".join(lst2)
print(s2)  # 输出：apple-banana

2.2 列表（list）

• 存储有序、可变的元素集合，支持重复集合，元素类型可混合int/str/list
  特点:

# 创建列表
# 空列表
list1 = []
list2 = list()  # 内置函数创建

# 普通列表（支持混合类型）
num_list = [1, 2, 3, 4]
mix_list = [1, "Python", True, [5, 6]]  # 元素可嵌套列表

# 访问元素＋切片
fruits = ["apple", "banana", "orange", "grape"]
print(fruits[0])       # 正向索引：输出 apple
print(fruits[-1])      # 反向索引：输出 grape
print(fruits[1:3])     # 切片：输出 ["banana", "orange"]（取索引1、2）
print(fruits[::2])     # 步长2：输出 ["apple", "orange"]（隔一个取一个）

# 增删查改
# 1. 新增元素
fruits.append("mango")  # 末尾添加（推荐，效率高）→ ["apple", "banana", "orange", "grape", "mango"]
fruits.insert(2, "pear")# 指定索引插入 → ["apple", "banana", "pear", "orange", "grape", "mango"]
fruits.extend(["cherry", "peach"])# 合并另一个列表 → 末尾添加多个元素

# 2. 删除元素
del fruits[3]           # 按索引删除 → 删除 "orange"
fruits.remove("banana") # 按元素值删除（删除第一个匹配项）
pop_fruit = fruits.pop()# 默认删除末尾元素，返回删除值；pop(0) 删除第一个元素（效率低）
fruits.clear()          # 清空列表 → []

# 3. 修改元素
fruits = ["apple", "banana"]
fruits[1] = "pineapple" # 按索引赋值 → ["apple", "pineapple"]

nums.sort()             # 原地排序（默认升序）→ [1, 1, 3, 4, 5, 9]
nums.reverse()          # 原地反转 → [9, 5, 4, 3, 1, 1]
new_nums = sorted(nums) # 返回新排序列表（不改变原列表）

2.3元组（tuple）:静态不可变的"有序容器"

• 本质：有序、不可变的元素集合（创建后无法增删改元素），支持重复元素、混合类型。
• 标识：用 () 定义（单个元素需加逗号，如 (1,) ，否则视为普通数据类型）。

# 定义
# 空元组
t1 = ()
t2 = tuple()

# 普通元组（单个元素必须加逗号）
num_tuple = (1, 2, 3, 4)
single_tuple = (5,)  # 正确（单个元素元组）
wrong_tuple = (5)    # 错误，视为整数 5

# 省略括号（Python自动识别）
mix_tuple = 1, "Python", True, (6, 7)  # 等价于 (1, "Python", True, (6,7))

# 访问元素
colors = ("red", "green", "blue", "yellow")
print(colors[2])       # 正向索引 → "blue"
print(colors[-2])      # 反向索引 → "blue"
print(colors[1:3])     # 切片 → ("green", "blue")


#（3）不可变性说明（关键）
# 元组本身不可变，但如果元素是可变类型（如列表），则元素内部可修改：
t = (1, 2, [3, 4])
# t[0] = 5 → 报错（元组元素不可修改）
t[2].append(5)         # 合法！列表元素内部可变 → (1, 2, [3, 4, 5])

# 常用方法（因不可变，方法较少）
nums = (3, 1, 4, 1, 5)
print(len(nums)))      # 长度 → 5
print(nums.count(1))   # 元素出现次数 → 2
print(nums.index(4))   # 元素首次出现的索引 → 2

# 遍历（与列表完全一致）
for color in colors:
    print(color)

for idx, color in enumerate(colors):# 返回一个包含  (索引, 元素)  二元组的枚举对象，方便遍历中同时获取位置和值。
    print(f"索引{idx}：{color}")

2.4 字典（Dictionary）

1. 核心定义与特性

• 本质：无序（Python 3.7+ 按插入顺序保留）的键值对（key-value）集合 ，key 唯一且不可变（如 int、str、tuple），value 可任意类型。
• 底层：基于哈希表实现，查找、增删改效率极高（O(1) 时间复杂度）。

2. 基础操作（必学）
   （1）创建字典

# 1. 大括号直接定义
dict1 = {"name": "张三", "age": 20, "score": 90}

# 2. dict() 构造
dict2 = dict(city="北京", job="工程师")
dict3 = dict(zip(["math", "english"], [85, 92]))

# 3. 空字典+动态添加
dict4 = {}
dict4["course"] = "Python"

# 4. 嵌套字典
dict5 = {"student1": {"id": 101, "grade": "大一"}, "student2": {"id": 102, "grade": "大二"}}

print(dict1, dict2, dict3, dict4, dict5, sep="\n")

（2）访问与修改键值对

dict1 = {"name": "张三", "age": 20, "score": {"math": 85}}

# 访问
print(dict1["name"])  # 直接访问
print(dict1.get("height", 175))  # get带默认值，若键不存在返回默认值175
print(dict1["score"]["math"])  # 嵌套访问

# 修改
dict1["age"] = 21  # 直接修改
dict1["score"]["math"] = 90  # 嵌套修改
dict1.update({"gender": "男", "age": 22})  # 批量修改/添加

print(dict1)

（3）常用方法与遍历

dict1 = {"apple": 5.9, "banana": 2.5, "orange": 3.8}

# 常用方法
print(dict1.keys())    # 获取所有键
print(dict1.values())  # 获取所有值
print(dict1.items())   # 获取所有键值对
print(dict1.pop("banana"))  # 删除并返回键对应值
dict1.clear()  # 清空字典

# 遍历
dict2 = {"a": 1, "b": 2, "c": 3}
for key in dict2:
    print(key, dict2[key])  # 遍历键，访问值
for k, v in dict2.items():
    print(f"{k}: {v}")  # 遍历键值对（最常用）

（4）字典推导式（高效创建）

# 1. 基础推导式（键值映射）
dict1 = {x: x*2 for x in range(1, 5)}  # 字典推导式{1:2, 2:4, 3:6, 4:8}

# 2. 筛选条件推导式
dict2 = {"a": 10, "b": 20, "c": 5, "d": 30}
dict3 = {k: v for k, v in dict2.items() if v > 10}  # 筛选值大于10的键值对

# 3. 键值互换（确保值唯一），若有重复保留最后插入那个
dict4 = {v: k for k, v in dict2.items()}

print(dict1, dict3, dict4, sep="\n")

2.5 集合

Python 中的集合（Set） 是一种无序、不重复、可变的数据结构，核心作用是「去重」和「成员关系判断」，底层基于哈希表实现，查找效率极高（时间复杂度 O(1)）。以下是集合的核心知识点，按「定义→特性→常用操作→实战场景」整理，直接覆盖日常开发需求：

集合用 大括号 {} 表示，元素之间用逗号分隔；空集合不能用 {}（会被解析为字典），需用 set() 函数创建。

2.5.1 集合的创建

1. 直接创建（非空集合）

# 普通集合（元素为不可变类型：数字、字符串、元组）
s1 = {1, 2, 3, 4}  # 数字集合
s2 = {"apple", "banana", "cherry"}  # 字符串集合
s3 = {(1,2), (3,4)}  # 元组集合（元组是不可变的，可作为集合元素）

# 自动去重（创建时重复元素会被自动过滤）
s4 = {1, 2, 2, 3}  # 结果：{1, 2, 3}

2. 用 set() 函数创建（支持可迭代对象）

# 从列表创建（去重常用）
lst = [1, 2, 2, 3]
s5 = set(lst)  # 结果：{1, 2, 3}

# 从字符串创建（拆分字符，去重）
s6 = set("hello")  # 结果：{'h', 'e', 'l', 'o'}（重复的 'l' 被去重）

# 从元组创建
tup = (1, 2, 3, 3)
s7 = set(tup)  # 结果：{1, 2, 3}

# 创建空集合（必须用 set()）
s_empty = set()  # 正确（空集合）
# s_empty = {}  # 错误（这是空字典）

注意：集合元素的限制

集合中的元素必须是 不可变类型（哈希able），不能包含列表、字典、集合等可变类型，否则会报错：

# 错误示例：元素包含列表（可变类型）
s = {1, [2, 3]}  # 报错：TypeError: unhashable type: 'list'

2.5.2 集合的核心特性（关键区别于其他数据结构）

1. 无序性：集合中的元素没有固定顺序，每次打印可能不同（不支持索引、切片）；

   s = {1, 2, 3}
   # print(s[0])  # 报错：TypeError: 'set' object is not subscriptable（不支持索引）

2. 唯一性：自动去重，集合中不会有重复元素（核心特性）；
3. 可变性：可动态添加/删除元素（但元素本身必须不可变）；
4. 高效性：查找、添加、删除元素的效率远高于列表（哈希表底层，O(1) 时间复杂度）。

2.5.3 集合的常用操作（增删改查+集合运算）

1. 增：添加元素

# 1. add(element)：添加单个元素（已存在则不重复添加，无报错）
s = {1, 2}
s.add(3)
print("add(3) 后：", s)  # 输出：add(3) 后：{1, 2, 3}
s.add(2)  # 元素已存在，不做任何操作
print("add(2) 后（重复元素）：", s)  # 输出：add(2) 后（重复元素）：{1, 2, 3}

# 2. update(iterable)：添加多个元素（接收列表、字符串、元组等可迭代对象）
s.update([3, 4])  # 添加列表元素
print("update([3,4]) 后：", s)  # 输出：update([3,4]) 后：{1, 2, 3, 4}
s.update("ab", (5, 6))  # 同时添加字符串和元组的元素
print("update(\"ab\", (5,6)) 后：", s)  # 输出：update("ab", (5,6)) 后：{1, 2, 3, 4, 5, 6, 'a', 'b'}

2. 删：删除元素

s = {1, 2, 3, 4}

# 1. remove(element)：删除指定元素（元素不存在则报错 KeyError）
s.remove(2)
print("remove(2) 后：", s)  # 输出：remove(2) 后：{1, 3, 4}
# s.remove(5)  # 执行会报错：KeyError: 5

# 2. discard(element)：删除指定元素（元素不存在不报错，推荐使用）
s.discard(3)
print("discard(3) 后：", s)  # 输出：discard(3) 后：{1, 4}
s.discard(5)  # 元素不存在，无报错
print("discard(5) 后（元素不存在）：", s)  # 输出：discard(5) 后（元素不存在）：{1, 4}

# 3. pop()：随机删除一个元素（返回删除的元素，空集合调用会报错）
deleted_elem = s.pop()
print("pop() 删除的元素：", deleted_elem)  # 输出：pop() 删除的元素：1（随机，也可能是4）
print("pop() 后：", s)  # 输出：pop() 后：{4}（取决于删除的元素）

# 4. clear()：清空集合，返回空集合
s.clear()
print("clear() 后：", s)  # 输出：clear() 后：set()

Python 集合的 pop() 并非「完全随机」，而是取决于集合的底层实现（哈希表） ------ 它删除的是「哈希表中第一个槽位的元素」，但由于集合是「无序的」，这个「第一个槽位」对用户来说是不可预测的，所以官方文档称之为「随机删除」

3. 查：成员关系判断（核心高效操作）

# 用 in / not in 判断元素是否在集合中（O(1) 高效查找）
s = {1, 2, 3, 4}
print("3 在集合中吗？", 3 in s)  # 输出：3 在集合中吗？ True
print("5 不在集合中吗？", 5 not in s)  # 输出：5 不在集合中吗？ True

# 对比列表的查找效率（数据量大时差距明显，列表是 O(n) 效率）
lst = [1, 2, 3, 4]
print("3 在列表中吗？", 3 in lst)  # 输出：3 在列表中吗？ True
# 集合查找原理：底层哈希表，直接通过哈希值定位元素；列表需逐个遍历

in 和 not in 是 Python 内置的通用成员运算符，并不是集合（set）特有的 ------ 它们可以用于 所有可迭代对象，判断某个元素是否属于该对象（或是否在对象中存在）。

4. 集合运算（交集、并集、差集等核心用途）

# 定义两个示例集合
s1 = {1, 2, 3}
s2 = {3, 4, 5}

# 1. 并集：合并两个集合，自动去重（符号 | 或方法 union()）
union_result1 = s1 | s2
union_result2 = s1.union(s2)
print("并集（s1 | s2）：", union_result1)  # 输出：并集（s1 | s2）：{1, 2, 3, 4, 5}
print("并集（s1.union(s2)）：", union_result2)  # 输出：并集（s1.union(s2)）：{1, 2, 3, 4, 5}

# 2. 交集：取两个集合的共同元素（符号 & 或方法 intersection()）
intersection_result1 = s1 & s2
intersection_result2 = s1.intersection(s2)
print("交集（s1 & s2）：", intersection_result1)  # 输出：交集（s1 & s2）：{3}
print("交集（s1.intersection(s2)）：", intersection_result2)  # 输出：交集（s1.intersection(s2)）：{3}

# 3. 差集：取 s1 中有但 s2 中没有的元素（符号 - 或方法 difference()）
difference_result1 = s1 - s2
difference_result2 = s1.difference(s2)
print("差集（s1 - s2）：", difference_result1)  # 输出：差集（s1 - s2）：{1, 2}
print("差集（s1.difference(s2)）：", difference_result2)  # 输出：差集（s1.difference(s2)）：{1, 2}

# 4. 对称差集：取两个集合中互不相同的元素（并集 - 交集，符号 ^ 或方法 symmetric_difference()）
sym_diff_result1 = s1 ^ s2
sym_diff_result2 = s1.symmetric_difference(s2)
print("对称差集（s1 ^ s2）：", sym_diff_result1)  # 输出：对称差集（s1 ^ s2）：{1, 2, 4, 5}
print("对称差集（s1.symmetric_difference(s2)）：", sym_diff_result2)  # 输出：对称差集（s1.symmetric_difference(s2)）：{1, 2, 4, 5}

# 5. 子集判断：判断 s1 是否是 s2 的子集（所有元素都在 s2 中，符号 < 或方法 issubset()）
subset_test1 = {1, 2} < s1
subset_test2 = {1, 2}.issubset(s1)
print("{1,2} 是 s1 的子集吗？", subset_test1)  # 输出：{1,2} 是 s1 的子集吗？ True
print("{1,2} 是 s1 的子集吗？", subset_test2)  # 输出：{1,2} 是 s1 的子集吗？ True

# 6. 超集判断：判断 s1 是否是 s2 的超集（包含 s2 所有元素，符号 > 或方法 issuperset()）
superset_test1 = s1 > {1, 2}
superset_test2 = s1.issuperset({1, 2})
print("s1 是 {1,2} 的超集吗？", superset_test1)  # 输出：s1 是 {1,2} 的超集吗？ True
print("s1 是 {1,2} 的超集吗？", superset_test2)  # 输出：s1 是 {1,2} 的超集吗？ True

2.5.4 集合的常用内置函数

# 定义示例集合（数字集合）
num_set = {3, 1, 4, 2, 5}
# 定义字符串集合（用于演示可比较元素的 max/min）
str_set = {"apple", "banana", "cherry"}

# 1. len(s)：返回集合元素的个数
print("num_set 元素个数：", len(num_set))  # 输出：num_set 元素个数：5
print("str_set 元素个数：", len(str_set))  # 输出：str_set 元素个数：3

# 2. max(s) / min(s)：返回集合中最大/最小元素（元素需支持比较）
print("num_set 最大值：", max(num_set))  # 输出：num_set 最大值：5
print("num_set 最小值：", min(num_set))  # 输出：num_set 最小值：1
print("str_set 最大值（字典序）：", max(str_set))  # 输出：str_set 最大值（字典序）：cherry
print("str_set 最小值（字典序）：", min(str_set))  # 输出：str_set 最小值（字典序）：apple

# 3. sum(s)：返回集合元素的和（仅适用于元素为数字的集合）
print("num_set 元素总和：", sum(num_set))  # 输出：num_set 元素总和：15
# print(sum(str_set))  # 执行会报错：TypeError: unsupported operand type(s) for +: 'int' and 'str'

# 4. sorted(s)：将集合转为排序后的列表（破坏集合的无序性，返回新列表）
sorted_num = sorted(num_set)
sorted_str = sorted(str_set)
print("num_set 排序后：", sorted_num)  # 输出：num_set 排序后：[1, 2, 3, 4, 5]
print("str_set 排序后（字典序）：", sorted_str)  # 输出：str_set 排序后（字典序）：['apple', 'banana', 'cherry']
print("排序后原集合是否变化？", num_set)  # 输出：排序后原集合是否变化？ {1, 2, 3, 4, 5}（原集合不变）

2.6.5 集合的实战场景（高频用途）

1. 快速去重 ：将列表/元组转为集合，自动去重（最常用场景）；

   lst = [1, 2, 2, 3, 3, 3]
   unique_lst = list(set(lst))  # 去重后转为列表：[1,2,3]（顺序不确定）

2. 成员关系判断 ：高效判断元素是否存在（如用户权限校验、数据存在性检查）；

   # 权限校验：判断用户是否在管理员列表中
   admins = {"admin1", "admin2", "admin3"}
   username = "admin1"
   if username in admins:
       print("拥有管理员权限")

3. 数据对比：用集合运算筛选两个数据集的交集、差集（如学生选课、商品库存对比）；

4. 去除列表中重复的对象：当列表元素是不可变类型时，用集合去重比手动遍历高效。

2.7 列表、元组、字典、集合的对比

以下是 列表（list）、元组（tuple）、字典（dict）、集合（set） 的核心区别表格总结，涵盖「核心特性、底层实现、关键操作、适用场景」等核心维度，清晰避坑：

对比维度	列表（list）	元组（tuple）	字典（dict）	集合（set）
定义标识	方括号 []	圆括号 ()（可省略）	大括号 {key: value}	大括号 {}（空集合用 set()）
核心特性	有序、可重复、可变（增删改元素）	有序、可重复、不可变（元素不能改）	3.7+ 有序、键唯一、值可重复、可变（增删改键值对）	无序、元素唯一、可变（增删元素）
元素要求	无限制（可存任意类型，包括可变类型）	无限制（可存任意类型，包括可变类型）	键 必须是不可变类型（哈希able），值无限制	元素 必须是不可变类型 （哈希able）
底层实现	动态数组	静态数组	哈希表	哈希表
索引/访问方式	支持索引（lst[index]）、切片	支持索引（tup[index]）、切片	支持按键访问（dic[key]）、get() 方法	不支持索引/切片，仅支持 in 判断
重复元素处理	允许重复，按添加顺序保留	允许重复，按添加顺序保留	键唯一（重复键会覆盖），值可重复	自动去重（重复元素添加无效）
核心操作效率（平均）	访问：O(1)，增删（首尾）：O(1)，中间增删：O(n)	访问：O(1)，无增删改操作（不可变）	按键查找/增删：O(1)，按值查找：O(n)	成员判断/增删：O(1)，遍历：O(n)
常用核心方法	append()、insert()、remove()、sort()	仅内置函数（len()、max()等），无修改方法	keys()、values()、items()、get()、pop()	add()、discard()、union()、intersection()
内存占用	中等（动态数组需预留空间）	较低（静态数组，无预留空间）	较高（哈希表需存储键值对+哈希结构）	中等（哈希表仅存储元素，无冗余）
迭代顺序	按添加顺序迭代	按添加顺序迭代	3.7+ 按添加顺序迭代，3.7- 无序	无序迭代（按哈希表槽位顺序）
典型适用场景	存储有序数据、需要频繁增删改、索引访问	存储固定数据（如配置项、坐标）、函数返回多值、作为字典键	键值对映射（如用户信息、配置表）、按键快速查找	去重、成员关系判断、数据对比（交集/并集）
常见坑点	中间增删效率低、无自动去重	不可修改元素，误用会导致逻辑错误	键必须不可变、按值查找效率低	无序不支持索引、元素必须不可变、pop() 顺序不可控

补充关键备注：

1. 元组的「不可变」 ：指元组本身的「元素不能增删改 」，但如果元组中包含可变元素（如列表），该可变元素的内容可以修改（例：tup = (1, [2,3]); tup[1].append(4) 合法）；
2. 字典的「键唯一」 ：若添加重复键，后添加的会覆盖前一个（例：dic = {1:2, 1:3} 最终为 {1:3}）；
3. 集合的「无序」 ：遍历顺序不固定，且不支持索引，如需有序结果需转列表排序（sorted(set)）；
4. 哈希able 判定：不可变类型（int、str、tuple、frozenset）可作为字典的键/集合的元素，可变类型（list、dict、set）不可。

选择技巧：

• 需有序+可修改 → 列表（list）；
• 需有序+不可修改 → 元组（tuple）；
• 需键值对映射 → 字典（dict）；
• 需去重+成员判断 → 集合（set）。

3.函数

3.1 函数定义与调用

# 函数定义
def add(a, b):
    return a + b

# 位置参数调用
result1 = add(3, 5)
print("位置参数调用:", result1)

# 关键字参数调用
result2 = add(a=4, b=6)
result3 = add(b=7, a=2)
print("关键字参数调用1:", result2)
print("关键字参数调用2:", result3)

# 位置参数必须在关键字参数之前
# 混合参数调用
result4 = add(2, b=8)
print("混合参数调用:", result4)

3.2 函数参数类型

# 1. 默认参数（默认值参数需放最后）
def calc_score(mid=0, final=0):
    return mid * 0.4 + final * 0.6
print(calc_score(80, 90))  # 传两个参数：86.0
print(calc_score(80))  # 只传 mid，final 用默认值 0：32.0

# 2. 可变位置参数（*args，打包为元组）
def print_args(*args):
    for arg in args:
        print(arg)
print_args(1, "a", [2,3])  # 输出：1、a、[2,3]

# 3. 可变关键字参数（**kwargs，打包为字典）
def print_kwargs(**kwargs):
    for k, v in kwargs.items():
        print(f"{k}: {v}")
print_kwargs(name="张三", age=20)  # 输出：name: 张三、age: 20

3.3 函数式编程（高阶函数、lambda）

3.3.1 lambda

# 1. lambda 匿名函数（简单逻辑，仅一行）
add = lambda a, b: a + b
print(add(2, 3))  # 输出：5

# 2. 高阶函数 filter（过滤偶数）
nums = [1, 2, 3, 4, 5]
even_nums = list(filter(lambda x: x % 2 == 0, nums))
print(even_nums)  # 输出：[2,4]
# filter 是 Python 内置的高阶函数（能接收函数作为参数），作用是：筛选可迭代对象中的元素，只保留 "让第一个函数返回 True" 的元素，最终返回一个 "筛选后的迭代器"（需要转成列表 / 元组才能直接看到结果）。
# 语法格式：filter(判断函数, 可迭代对象)


# 3. 高阶函数 map（每个元素乘 2）
double_nums = list(map(lambda x: x * 2, nums))
print(double_nums)  # 输出：[2,4,6,8,10]

3.3.2 内置高阶函数

结合日常开发高频场景，筛选出 5个最常用、最能提升效率 的Python内置高阶函数，按「知识点+核心用法+实战场景」整理，覆盖80%以上的使用需求，直接记牢就能套用：

3.3.3 sorted()：自定义规则排序（最常用）

核心知识点

• 作用：对可迭代对象（列表、元组、字典等）排序，返回新列表（不修改原数据）；
• 关键参数：
  • key：接收「函数」，定义排序规则（如按长度、按字典值、按自定义计算结果）；
  • reverse：布尔值，True 降序，默认 False 升序；
• 核心优势：支持任意复杂排序规则，一行搞定，比手动写排序逻辑简洁10倍。

# 1. 基础排序（默认升序）
nums = [3, 1, 2]
sorted(nums)  # 输出：[1, 2, 3]

# 2. 按自定义规则排序（key=lambda）
strs = ["apple", "banana", "cherry"]
sorted(strs, key=lambda s: len(s))  # 按字符串长度排序：["apple", "cherry", "banana"]

# 3. 字典排序（按value值）
dic = {"a": 3, "b": 1, "c": 2}
# 默认先比第一个元素再比第二个元素
sorted(dic.items(), key=lambda item: item[1])  # 输出：[("b",1), ("c",2), ("a",3)]

# 4. 降序排序（reverse=True）
sorted(nums, reverse=True)  # 输出：[3, 2, 1]

3.3.4. map()：批量元素转换（替代for循环）

核心知识点

• 作用：将「处理函数」应用到可迭代对象的每个元素，批量转换，返回迭代器；
• 关键参数：
  • 第一个参数：「处理函数」（lambda或普通函数）；
  • 后续参数：1个或多个可迭代对象（多个时按索引对应元素）；
• 核心优势：替代重复的for循环，一行实现批量处理（如类型转换、数值计算）。

# 1. 单个可迭代对象：批量计算
nums = [1, 2, 3, 4]
list(map(lambda x: x * 2, nums))  # 所有元素乘2：[2, 4, 6, 8],map返回的是一个迭代器

# 2. 单个可迭代对象：批量类型转换
str_list = ["10", "20", "30"]
list(map(int, str_list))  # 字符串转整数：[10, 20, 30]

# 3. 多个可迭代对象：对应元素处理
a = [1, 2]
b = [3, 4]
list(map(lambda x, y: x + y, a, b))  # 对应元素相加：[4, 6]

3.3.5 filter()：按条件筛选元素

核心知识点

• 作用：遍历可迭代对象，只保留「判断函数返回True」的元素，返回迭代器；
• 关键参数：
  • 第一个参数：「判断函数」（返回布尔值）；
  • 第二个参数：要筛选的可迭代对象；
• 核心优势：替代"for循环+if判断"的筛选逻辑，代码更紧凑。

# 1. 筛选数值（偶数）
nums = [1, 2, 3, 4, 5, 6]
list(filter(lambda x: x % 2 == 0, nums))  # 输出：[2, 4, 6]

# 2. 筛选字符串（非空、非空格）
strs = ["", "hello", "  ", "python", None]
list(filter(lambda s: s and s.strip() if s else False, strs))  # 输出：["hello", "python"]
# strip() 是 字符串对象的内置方法，核心作用是：去除字符串两端的空白字符（默认）或指定字符，返回处理后的新字符串（原字符串不变）。

# 3. 筛选字典（value>2）
dic_list = [{"a":1}, {"a":2}, {"a":3}]
list(filter(lambda d: d["a"] > 2, dic_list))  # 输出：[{"a":3}]

3.3.6 sum()：累加计算（高效聚合）

核心知识点

• 作用：对可迭代对象的元素求和，支持「筛选后累加」（配合生成式表达式）；
• 关键参数：
  • 第一个参数：可迭代对象（列表、生成式表达式等）；
  • 第二个参数（可选）：初始值（默认0）；
• 核心优势：比 reduce 更简洁、效率更高，是累加场景的首选。

# 1. 基础累加
sum(range(1, 11))  # 1~10求和：55

# 2. 筛选后累加（生成式表达式配合）
nums = [1, 2, 3, 4, 5]
sum(x for x in nums if x % 2 == 0)  # 偶数求和：2+4=6

# 3. 带初始值的累加
sum([1, 2, 3], 10)  # 初始值10，总和10+1+2+3=16

3.3.7 reduce()：复杂聚合（求和/求积/自定义合并）

核心知识点

• 作用：将可迭代对象「归约」为单个值（累计执行二元函数）；
• 关键注意：Python3需从 functools 导入；
• 关键参数：
  • 第一个参数：「二元函数」（接收两个参数，返回计算结果）；
  • 第二个参数：可迭代对象；
  • 第三个参数（可选）：初始值；
• 核心优势：处理「多元素合并为一个」的复杂逻辑（如累乘、字符串拼接、自定义聚合）。

from functools import reduce

# 1. 累乘（1×2×3×4）
nums = [1, 2, 3, 4]
reduce(lambda x, y: x * y, nums)  # 输出：24

# 2. 字符串拼接（"a"+"b"+"c"+"d"）
strs = ["a", "b", "c", "d"]
reduce(lambda x, y: x + y, strs)  # 输出："abcd"

# 3. 带初始值的累加（0+1+2+3+4）
reduce(lambda x, y: x + y, nums, 0)  # 输出：10

3.3.8 关键补充：2个辅助高频函数

3.3.8.1. enumerate()：遍历带索引

• 核心知识点：遍历元素时同时返回「索引+元素」，避免手动维护索引变量；
• 实战示例：

  fruits = ["apple", "banana", "cherry"]
  for idx, fruit in enumerate(fruits, start=1):  # start=1：索引从1开始
      print(f"第{idx}个水果：{fruit}")  # 输出：第1个水果：apple...

3.3.8.2. max/min()：带规则找最值

• 核心知识点：key 参数支持自定义规则，找最大/最小值；
• 实战示例：

  # 按字符串长度找最长元素
  strs = ["a", "bc", "def"]
  max(strs, key=lambda s: len(s))  # 输出："def"

3.3.9 核心用法对比（避免混淆）

函数	核心作用	处理函数返回值要求	典型场景
sorted()	自定义规则排序	任意值（排序依据）	按长度、字典值排序
map()	批量转换元素	任意值（新元素）	类型转换、数值计算
filter()	按条件筛选元素	布尔值（True保留）	筛选偶数、非空字符串
sum()	累加计算	-（直接接收可迭代对象）	数值求和、筛选后求和
reduce()	复杂聚合（归约）	单个值（累计结果）	累乘、字符串拼接

必记实战技巧

1. 「转换+筛选」组合：先用 map 转换，再用 filter 筛选，或反之（需转迭代器）；

   nums = [1,2,3,4]
   # 先乘2，再筛选大于5的元素
   list(filter(lambda x: x>5, map(lambda x: x*2, nums)))  # 输出：[6, 8]

2. 生成式配合 sum()：筛选+累加一步到位，比 filter+sum 更简洁；

   sum(x for x in nums if x%2==0)  # 等价于 sum(filter(lambda x: x%2==0, nums))

3. 迭代器转列表：map/filter 返回迭代器，需用 list() 转换才能直接查看结果。

4. 文件与异常

4.1 文件基本操作（核心流程：打开→读写→关闭）

4.1.1 文件路径与访问基础

文件的保存位置称为路径，分为绝对路径和相对路径两类，实际使用时需注意路径字符串的转义问题：

• 绝对路径：从盘符开始描述位置，例如 F:\documents\python\5-1.py。由于Python中 \ 是转义字符，需用两种方式处理：

  # 方式1：用 \\ 转义
  file_path1 = "F:\\documents\\python\\5-1.py"
  # 方式2：用 r 定义原始字符串（推荐）
  file_path2 = r"F:\documents\python\5-1.py"

• 相对路径：从当前工作目录开始描述位置，当前工作目录可通过 os 库查看和修改：

  import os
  # 查看当前工作目录（默认是Python安装目录）
  print(os.getcwd())  # get current working dir
  # 示例输出：'C:\\Programs\\Python\\Python37-32'
  
  # 修改当前工作目录到F盘documents文件夹
  os.chdir(r"F:\documents") # change dir
  # 再次查看，确认修改
  print(os.getcwd())  # 输出：'F:\\documents'

4.1.2 文件打开模式与语法

文件打开需通过 open() 函数指定路径和模式，模式决定文件类型（文本/二进制）、操作权限和存在性处理逻辑，常用模式的代码示例对比：

• 只读模式（'r'）：仅能读取文件，文件不存在则报错

  # 尝试读取不存在的文件，会触发IOError
  try:
      file = open("nonexistent.txt", 'r')
  except IOError:
      print("文件不存在，无法读取")

• 写入模式（'w'）：仅能写入文件，文件不存在则新建，存在则覆盖内

  # 新建并写入文件，覆盖已有内容
  file = open("test.txt", 'w')
  file.write("覆盖原有内容")
  file.close()

• 追加模式（'a'）：仅能写入文件，文件不存在则新建，存在则从末尾追加内容

  # 在已有文件末尾追加内容
  file = open("test.txt", 'a')
  file.write("，这是追加的内容")
  file.close()

• 二进制模式（如 'rb'/'wb'）：用于读写图片、音频等二进制文件，示例：

  # 读取二进制文件（如图片）
  with open("image.jpg", 'rb') as img_file:
      img_data = img_file.read()
  # 写入二进制文件
  with open("copy_image.jpg", 'wb') as new_img_file:
      new_img_file.write(img_data)

4.1.3 核心写文件方法对比（write() vs writelines()）

写文件主要依赖 write() 和 writelines() 两种方法，二者均需手动添加分隔符，代码对比：

• write()：写入单个字符串，返回写入的字符数

  file = open("write_test.txt", 'w')
  # 写入单个字符串，无自动分隔
  file.write("飞雪连天射白鹿")
  file.write("笑书神侠倚碧鸳")  # 两个字符串会连在一起
  file.close()
  # 文件内容：飞雪连天射白鹿笑书神侠倚碧鸳

• writelines()：一次性写入多个字符串（接收列表/元组等序列）

  file = open("writelines_test.txt", 'w')
  # 写入列表中的多个字符串，同样无自动分隔
  ls1 = ["飞雪连天射白鹿", "笑书神侠倚碧鸳"]
  file.writelines(ls1)
  # 手动添加分隔符（如 \n 换行、\t 制表符）
  ls2 = ["飞雪连天射白鹿\t", "笑书神侠倚碧鸳\n"]
  file.writelines(ls2)
  file.close()
  # 文件内容：飞雪连天射白鹿笑书神侠倚碧鸳飞雪连天射白鹿	笑书神侠倚碧鸳

4.1.4 核心读文件方法对比（read() vs readline() vs readlines()）

读文件有三种常用方法，适用于不同场景，代码对比：

• read()：读取文件全部内容，返回单个字符串（含原始分隔符）

  with open("test.txt", 'r') as file:
      content = file.read()
      print(content)
      # 示例输出：'飞雪连天射白鹿\t笑书神侠倚碧鸳\n横批:越女剑'

• readline()：逐行读取 文件，每次调用读取一行，返回单个字符串

  with open("test.txt", 'r') as file:
      # 第一次读取第一行
      line1 = file.readline()
      print(line1)  # 输出：'飞雪连天射白鹿\t笑书神侠倚碧鸳\n'
      # 第二次读取第二行
      line2 = file.readline()
      print(line2)  # 输出：'横批:越女剑\n'

• readlines()：读取文件全部内容，按行分割为列表，每行作为列表的一个元素

  with open("test.txt", 'r') as file:
      lines = file.readlines()
      print(lines)
      # 示例输出：['飞雪连天射白鹿\t笑书神侠倚碧鸳\n', '横批:越女剑\n']
      # 可通过循环处理每行
      for line in lines:
          print(line.strip())  # 去除每行首尾空白

4.1.5 文件关闭操作

文件使用后必须关闭，以同步内存修改到外存并释放资源，有两种关闭方式：

• 手动关闭：调用 close() 方法

  file = open("test.txt", 'r')
  content = file.read()
  file.close()  # 手动关闭，不可遗漏

• 自动关闭：用 with 上下文管理器（推荐），代码块结束后自动关闭文件

  # with 块结束后，文件自动关闭，无需手动调用close()
  with open("test.txt", 'r') as file:
      content = file.read()

4.2 异常和异常处理

4.2.1 常见异常类型与示例

异常是程序执行中的错误，会导致程序非正常终止，常见异常的代码触发示例：

• ZeroDivisionError：除数为0

  try:
      result = 3 / 0  # 触发除数为0异常
  except ZeroDivisionError:
      print("错误：除数不能为0")

• IOError：输入/输出操作失败（如文件不存在）

  try:
      file = open("nonexistent.txt", 'r')  # 触发文件不存在异常
  except IOError:
      print("错误：文件不存在或无法访问")

• IndexError：序列索引超出范围

  try:
      lst = [1, 2, 3]
      print(lst[5])  # 触发索引超出范围异常
  except IndexError:
      print("错误：序列索引超出范围")

• KeyError：字典中无指定键

  try:
      dic = {"name": "张三", "age": 20}
      print(dic["height"])  # 触发键不存在异常
  except KeyError:
      print("错误：字典中无此键")

4.2.2 异常处理语法（try-except-else）

异常处理通过 try-except-else 结构实现，捕获指定异常并处理，避免程序崩溃，代码框架与示例：

try:
    # 可能发生异常的代码块（核心业务逻辑）
    a = int(input("请输入被除数："))
    b = int(input("请输入除数："))
    result = a / b
except ZeroDivisionError:
    # 捕获除数为0异常，执行处理逻辑
    print("异常：除数不能为0，请重新输入")
except ValueError:
    # 捕获输入非整数异常，执行处理逻辑
    print("异常：请输入有效的整数")
else:
    # 未发生任何异常时，执行正常逻辑
    print(f"{a} ÷ {b} = {result}")

4.2.3 异常处理实战：文件操作异常捕获

文件读写过程中易发生 IOError（如文件不存在、权限不足），需嵌套或多重异常处理，代码示例：

# 读文件异常处理 + 写文件异常处理
try:
    # 第一步：读取hamlet.txt文件
    with open(r"F:\documents\python\hamlet.txt", 'r') as read_file:
        text = read_file.read()
except IOError:
    print("读文件异常：文件不存在或无法读取")
else:
    # 第二步：处理文本（此处简化，实际可加词频统计等逻辑）
    processed_text = text.lower()
    try:
        # 第三步：写入处理结果到hamlet_result.txt
        with open(r"F:\documents\python\hamlet_result.txt", 'w') as write_file:
            write_file.write(processed_text)
    except IOError:
        print("写文件异常：无法写入文件，可能权限不足")
    else:
        print("文件读写操作全部完成")

4.3 扩展：CSV文件操作（基于csv模块）

CSV文件是逗号分隔的纯文本表格数据文件，Python通过内置 csv 模块操作，核心读写方法代码对比：

• 读CSV文件：用 csv.reader() 迭代读取，每行返回列表格式

  import csv
  # 读取stu.csv文件，指定编码避免中文乱码
  with open("stu.csv", 'r', encoding='utf-8') as csv_file:
      reader = csv.reader(csv_file)
      for row in reader:
          print(row)  # 示例输出：['姓名', '性别', '年龄'], ['李明', '男', '19']...

• 写CSV文件：用 csv.writer() 的 writerow()（写单行）和 writerows()（写多行），需指定 newline='' 避免空行

  import csv
  # 方式1：用writerow()写单行
  with open("stu.csv", 'a', newline='', encoding='utf-8') as csv_file:
      writer = csv.writer(csv_file)
      writer.writerow(['张芳', '女', '20'])  # 写入一行数据
  
  # 方式2：用writerows()写多行
  with open("stu.csv", 'a', newline='', encoding='utf-8') as csv_file:
      writer = csv.writer(csv_file)
      # 写入嵌套列表中的多行数据
      writer.writerows([['王虎', '男', '18'], ['刘婷', '女', '19']])

5. 面向对象编程

5.1 class 的基本概念

5.1.0 类与对象的定义

• 类（Class） ：对一类事物的抽象描述，包含属性（数据）和方法（行为），是创建对象的模板。
  语法：class 类名(父类名):，未指定父类时默认继承 object 类（所有类的基类）。
  示例：

  class Point:
      def __init__(self, x=0, y=0):
          self.x = x  # 属性：x坐标
          self.y = y  # 属性：y坐标
      
      def prt(self):  # 方法：打印坐标
          print(f"({self.x}, {self.y})")

• 对象（Object） ：类的实例，是具体的事物个体，通过 类名(参数) 实例化创建。
  示例：

  p = Point(3, 4)  # 创建Point类的对象p
  p.prt()          # 调用对象的方法，输出：(3, 4)

5.1.1 构造方法 __init__

• 特殊方法（魔术方法），实例化对象时自动调用，用于初始化对象的属性。
• 第一个参数必须是 self，代表当前创建的实例，通过 self.属性名 绑定实例属性。
  示例：上述 Point 类中，__init__ 方法初始化 x 和 y 坐标，创建对象时传入的参数会传递给该方法。

5.1.2 类与对象的关系

• 类是"模板"，定义共性属性和方法；对象是"模板实例"，拥有独立的属性值，共享类的方法。
  示例：

  p1 = Point(1, 2)
  p2 = Point(5, 6)
  # p1和p2是独立对象，x、y属性值不同，但共享prt()方法
  p1.prt()  # 输出：(1, 2)
  p2.prt()  # 输出：(5, 6)

5.2 封装、继承、多态

5.2.1 封装

• 核心思想：隐藏对象内部细节，仅通过公有接口对外提供访问，保护数据安全。

• 实现方式：通过 双下划线 __ 定义私有属性 /方法 ，类外部无法直接访问，需通过公有方法间接操作。
  示例：

  class Point:
      def __init__(self, x=0, y=0):
          self.__x = x  # 私有属性：外部无法直接访问
          self.__y = y
      
      # 公有接口（getter方法）：获取私有属性
      def get_x(self):
          return self.__x
      
      # 公有接口（setter方法）：修改私有属性（可加逻辑校验）
      def set_x(self, x):
          if x >= 0:
              self.__x = x
          else:
              print("x坐标不能为负数")
  
  p = Point(3, 4)
  print(p.get_x())  # 输出：3（通过公有方法访问私有属性）
  p.set_x(5)        # 通过公有方法修改私有属性
  # print(p.__x)    # 报错：AttributeError（外部无法直接访问私有属性）

5.2.2 继承

• 核心思想：子类（派生类）继承父类（基类）的属性和方法，可新增属性/方法或重写父类方法，实现代码复用。

• 语法：class 子类名(父类名):，支持多继承（如 class 子类(父1, 父2):）。

• 关键操作：

  1. super() 函数：获取父类代理对象，调用父类方法（尤其构造方法），避免重复代码。
  2. 方法重写 ：子类定义与父类同名的方法，覆盖父类实现。
     示例：

  # 父类：Point2D
  class Point2D:
      def __init__(self, x=0, y=0):
          self.x = x
          self.y = y
      
      def move(self, delta_x, delta_y):
          self.x += delta_x
          self.y += delta_y
  
  # 子类：Point3D 继承 Point2D，扩展z轴属性
  class Point3D(Point2D):
      def __init__(self, x=0, y=0, z=0):
          super().__init__(x, y)  # 调用父类构造方法，初始化x、y
          self.z = z  # 子类新增属性
      
      # 重写父类move方法：支持z轴移动
      def move(self, delta_x, delta_y, delta_z):
          super().move(delta_x, delta_y)  # 调用父类move方法，更新x、y
          self.z += delta_z  # 子类扩展逻辑
  
  p3d = Point3D(7, 8, 9)
  p3d.move(0, 1, 2)
  print(p3d.x, p3d.y, p3d.z)  # 输出：7 9 11

5.2.3 多态

• 核心思想：同一操作作用于不同对象，根据对象所属类执行不同的方法实现（依赖方法重写）。

• Python 中通过"鸭子类型"实现：无需继承关系，只要对象支持所需方法，即可被调用。
  示例：

  # 通用函数：接收任何有move()和prt()方法的对象
  def move_and_print(obj, *args):
      obj.move(*args)
      obj.prt()
  
  # 父类对象
  p2d = Point2D(3, 4)
  # 子类对象
  p3d = Point3D(7, 8, 9)
  
  # 多态体现：同一函数调用，执行不同类的方法
  move_and_print(p2d, 1, 2)    # 调用Point2D的move和prt，输出：(4, 6)
  move_and_print(p3d, 0, 1, 2) # 调用Point3D的move和prt，输出：(7, 9, 11)

5.3 对象成员和方法、类成员和方法、静态成员和方法

5.3.1 对象成员（实例成员）和实例方法

• 对象成员（实例属性） ：定义在 __init__ 中，通过 self.属性名 绑定，每个对象拥有独立值，仅能通过对象访问。

• 实例方法 ：第一个参数为 self，可访问实例属性和类属性，仅能通过对象调用。
  示例：

  class Point:
      def __init__(self, x=0):
          self.x = x  # 实例属性（对象成员）
      
      def show_x(self):  # 实例方法
          print(self.x)  # 访问实例属性
  
  p1 = Point(3)
  p2 = Point(5)
  print(p1.x)  # 输出：3（p1的实例属性）
  print(p2.x)  # 输出：5（p2的实例属性，与p1独立）
  p1.show_x()  # 输出：3（调用实例方法）

5.3.2 类成员（类属性）和类方法

• 类成员（类属性） ：定义在类内部、方法外部，所有对象共享同一值，可通过 类名.属性名 或 对象名.属性名 访问（推荐类名访问）。

• 类方法 ：用 @classmethod 装饰，第一个参数为 cls（代表类本身），仅能访问类属性，可通过类名或对象调用。
  示例：

  class Point:
      count = 0  # 类属性（所有对象共享）
      
      def __init__(self):
          Point.count += 1  # 每次创建实例，类属性计数+1
      
      # 类方法：访问类属性
      @classmethod
      def get_count(cls):
          return cls.count
  
  p1 = Point()
  p2 = Point()
  print(Point.count)         # 输出：2（访问类属性）
  print(Point.get_count())  # 输出：2（调用类方法）

5.3.3 静态成员（静态方法）

• 静态方法 ：用 @staticmethod 装饰，无 self 或 cls 参数，与普通函数类似，仅挂载在类命名空间下。

• 特性：不访问实例属性和类属性，提供与类相关的辅助功能，可通过类名或对象调用。
  示例：

  class Point:
      @staticmethod
      def print_sep():  # 静态方法：辅助打印分隔线
          print("-" * 20)
  
  Point.print_sep()  # 输出：--------------------（类名调用）
  p = Point()
  p.print_sep()      # 输出：--------------------（对象调用）

5.4 Python 的动态特性

• 核心特点：运行时可动态给类/对象添加、修改、删除属性和方法，无需预先定义。
• 常见操作：

  1. 动态给对象添加属性/方法：

     class Point:
         pass
     
     p = Point()
     p.x = 3  # 动态给对象添加属性
     print(p.x)  # 输出：3
     
     # 动态给对象添加方法
     def show(self):
         print(self.x)
     p.show = show.__get__(p)  # 绑定实例
     p.show()  # 输出：3

  2. 动态给类添加属性/方法：

     class Point:
         pass
     
     Point.y = 5  # 动态给类添加类属性
     print(Point.y)  # 输出：5
     
     # 动态给类添加实例方法
     def set_x(self, x):
         self.x = x
     Point.set_x = set_x
     
     p = Point()
     p.set_x(4)
     print(p.x)  # 输出：4

5.5 实战代码

5.5.0 综合案例：图形计算（封装+继承+多态）

import math

# 父类：Shape（图形）
class Shape:
    def __init__(self, color):
        self.__color = color  # 私有属性：颜色（封装）
    
    # 公有接口：获取颜色
    def get_color(self):
        return self.__color
    
    # 虚方法：子类需重写
    def get_area(self):
        pass

# 子类：Circle（圆形）继承Shape
class Circle(Shape):
    def __init__(self, color, radius):
        super().__init__(color)  # 调用父类构造方法（继承）
        self.radius = radius
    
    # 重写父类方法（多态）
    def get_area(self):
        return math.pi * self.radius ** 2

# 子类：Rectangle（矩形）继承Shape
class Rectangle(Shape):
    def __init__(self, color, width, height):
        super().__init__(color)
        self.width = width
        self.height = height
    
    # 重写父类方法（多态）
    def get_area(self):
        return self.width * self.height

# 多态调用：同一函数处理不同图形
def print_area(shape):
    print(f"{shape.get_color()}图形的面积：{shape.get_area():.2f}")

# 测试
circle = Circle("红色", 5)
rect = Rectangle("蓝色", 4, 6)
print_area(circle)  # 输出：红色图形的面积：78.54
print_area(rect)    # 输出：蓝色图形的面积：24.00

5.5.1 案例说明

• 封装：Shape 类的 __color 为私有属性，通过 get_color() 公有接口访问。
• 继承：Circle 和 Rectangle 继承 Shape，复用颜色属性和接口。
• 多态：print_area 函数接收任意 Shape 子类对象，自动调用对应类的 get_area 方法。

6. Python 常用内置函数分类汇总

内置函数是 Python 自带的基础工具，无需导入任何库即可直接使用，底层由 C 实现，执行效率高，以下按场景分类覆盖 90%+ 开发需求：

6.1 数据类型转换函数

函数名	作用	示例
int(x)	转换为整数（支持字符串/浮点数/进制串）	int("123") → 123、int(3.9) → 3、int("0b101") → 5
float(x)	转换为浮点数	float("3.14") → 3.14、float(5) → 5.0
str(x)	转换为字符串（任意类型均可）	str(123) → "123"、str([1,2]) → "[1,2]"
bool(x)	转换为布尔值（0/None/空对象→False）	bool(0) → False、bool([1]) → True、bool("") → False
list(x)	转换为列表（支持可迭代对象）	list((1,2,3)) → [1,2,3]、list("abc") → ["a","b","c"]
tuple(x)	转换为元组（支持可迭代对象）	tuple([1,2,3]) → (1,2,3)、tuple("abc") → ("a","b","c")
dict(x)	转换为字典（支持键值对序列/映射）	dict([("a",1), ("b",2)]) → {"a":1, "b":2}
set(x)	转换为集合（去重，支持可迭代对象）	set([1,2,2,3]) → {1,2,3}、set("aabbcc") → {"a","b","c"}
complex(real, imag)	转换为复数	complex(2, 3) → (2+3j)、complex("1+2j") → (1+2j)

6.2 序列/集合操作函数

函数名	作用	示例
len(obj)	获取对象长度（字符串/列表/字典等）	len("abc") → 3、len([1,2,3]) → 3、len({"a":1}) → 1
max(iter, key=None)	获取可迭代对象最大值（支持自定义键）	max([1,3,2]) → 3、max([(1,3), (2,1)], key=lambda x: x[1]) → (1,3)
min(iter, key=None)	获取可迭代对象最小值（支持自定义键）	min([1,3,2]) → 1、min("abc") → "a"
sum(iter, start=0)	数值型可迭代对象求和（start为初始值）	sum([1,2,3]) → 6、sum([1,2,3], start=10) → 16
sorted(iter, key=None, reverse=False)	排序（返回新列表，不修改原对象）	sorted([3,1,2]) → [1,2,3]、sorted("cba", reverse=True) → ["c","b","a"]
reversed(iter)	反转（返回迭代器，需转列表查看）	list(reversed([1,2,3])) → [3,2,1]
enumerate(iter, start=0)	枚举（返回 (索引, 值) 迭代器）	list(enumerate(["a","b"])) → [(0,"a"), (1,"b")]
zip(*iters)	打包多个可迭代对象（返回元组迭代器）	list(zip([1,2], ["a","b"])) → [(1,"a"), (2,"b")]
all(iter)	所有元素为True则返回True	all([1,2,3]) → True、all([1,0]) → False
any(iter)	任意元素为True则返回True	any([0,1]) → True、any([0,False]) → False

6.3 迭代器/生成器函数

函数名	作用	示例
range(start, end, step)	生成整数序列（左闭右开，默认start=0、step=1）	range(5) → [0,1,2,3,4]、range(1,5,2) → [1,3]
iter(obj)	将对象转为迭代器	it = iter([1,2])、next(it) → 1
next(it, default=None)	获取迭代器下一个元素（无元素返回默认值）	it = iter([1,2])、next(it) → 1、next(it, 0) → 2

6.4 文件/输入输出函数

函数名	作用	示例
open(file, mode='r', encoding=None)	打开文件（返回文件对象，需关闭）	f = open("test.txt", "r", encoding="utf-8")
print(*args, sep=' ', end='\n')	打印输出（支持多参数、自定义分隔符）	print("Hello", "Python", sep='-') → Hello-Python
input(prompt='')	读取用户输入（返回字符串）	name = input("请输入姓名：")

6.5 函数/对象工具函数

函数名	作用	示例
type(obj)	获取对象的类型	type(123) → int、type([1]) → list
isinstance(obj, cls)	判断对象是否是指定类（或元组）的实例	isinstance(123, (int, float)) → True
id(obj)	获取对象的唯一内存地址	id("abc") → 140708992345672
dir(obj)	获取对象的所有属性/方法（返回列表）	dir([1,2,3])（查看列表的所有方法）
help(obj)	查看对象的帮助文档（交互式）	help(list.append)（查看append用法）
callable(obj)	判断对象是否可调用（函数/类→True）	callable(print) → True、callable(123) → False

6.6 其他常用函数

6.6.1 eval() 函数核心定义

eval() 是 Python 内置的 表达式执行函数 ，核心作用是「将字符串作为合法的 Python 表达式解析并执行，返回执行结果」。它不属于专门的"数据类型转换函数"，类型转换仅为其副作用（当输入字符串是某种数据类型的字面量时）。

6.6.1.1 语法格式

eval(expression, globals=None, locals=None)

• 参数说明 ：
  • expression：必传参数，需执行的 Python 表达式字符串（如 "1+2*3"、"-120, 30"）；
  • globals：可选参数，指定执行表达式时的全局命名空间（字典格式），默认使用当前全局环境；
  • locals：可选参数，指定执行表达式时的局部命名空间（字典格式），默认使用当前局部环境；
• 返回值：表达式执行后的结果（类型由表达式本身决定，如整数、元组、字典等）。

6.6.1.2 eval() 实用使用示例（按场景分类）

直接解析并计算字符串格式的数学公式，支持基础运算、函数调用、变量参与：

# 示例1：基础运算符计算
expr1 = "1 + 2 * 3 - 4 / 2"
result1 = eval(expr1)
print(result1)  # 输出：5.0（按运算符优先级计算）

# 示例2：结合数学库函数
import math
expr2 = "math.sqrt(16) + math.pi * 2"  # 平方根（4）+ 2π（6.283...）
result2 = eval(expr2)
print(result2)  # 输出：10.283185307179586

# 示例3：变量参与表达式
a = 10
b = 5
expr3 = "a ** 2 + b * 3"  # 10²（100）+ 5×3（15）
result3 = eval(expr3)
print(result3)  # 输出：115

函数名	作用	示例
abs(x)	获取绝对值（支持整数/浮点数/复数）	abs(-3.14) → 3.14、abs(2+3j) → 3.605...
round(x, n=0)	四舍五入（n为小数位数，默认0）	round(3.1415, 2) → 3.14、round(2.5) → 2（银行家舍入）
pow(x, y, mod=None)	幂运算（x^y，mod存在则返回 (x^y)%mod）	pow(2, 3) → 8、pow(2, 3, 5) → 3
divmod(x, y)	返回 (商, 余数) 元组	divmod(7, 3) → (2, 1)、divmod(10, 4) → (2, 2)
ord(c)	获取字符的ASCII/Unicode码	ord("a") → 97、ord("中") → 20013
chr(n)	根据ASCII/Unicode码获取字符	chr(97) → "a"、chr(20013) → "中"
hex(n)	转换为十六进制字符串	hex(255) → "0xff"、hex(10) → "0xa"
oct(n)	转换为八进制字符串	oct(8) → "0o10"、oct(10) → "0o12"
bin(n)	转换为二进制字符串	bin(8) → "0b1000"、bin(10) → "0b1010"

7. 基本库的了解

7.1 Random 库：随机数生成（内置库，无需安装）

核心功能 ：生成随机整数、浮点数，随机选择、打乱序列等，适用于随机抽样、模拟场景。
常用方法+示例：

import random

random.seed(10)
random.random()          # 生成 [0.0, 1.0) 随机浮点数：0.3456789
random.randint(1, 10)    # 生成 [1,10] 随机整数：7
random.choice(["苹果", "香蕉"])  # 随机选择1个元素：香蕉
random.sample([1,2,3,4,5], 3)  # 随机选择3个不重复元素：[3,1,5]
lst = [1,2,3,4]; random.shuffle(lst)  # 打乱序列（原地修改）
random.uniform(2.0, 5.0)  # 生成 [2.0,5.0) 随机浮点数：3.789

7.2 os 库：操作系统交互（内置库，无需安装）

核心功能 ：文件/目录操作、路径处理、执行系统命令等，实现 Python 与操作系统的交互。
常用方法+示例：

import os

# 路径处理（跨平台兼容）
os.path.join("dir1", "file.txt")  # 拼接路径："dir1/file.txt"（Windows为"dir1\file.txt"）
os.path.exists("test.txt")        # 判断路径是否存在：True/False
os.path.isfile("test.txt")        # 判断是否为文件：True/False
os.getcwd()                       # 获取当前工作目录

# 文件/目录操作
os.mkdir("new_dir")               # 创建单个目录（父目录需存在）
os.makedirs("a/b/c")              # 递归创建多级目录
os.rmdir("new_dir")               # 删除空目录
os.listdir("dir1")                # 列出目录下所有内容（返回列表）
os.remove("test.txt")             # 删除文件

# 执行系统命令（返回状态码，0=成功）
os.system("dir")  # Windows：列出当前目录；Linux/Mac：替换为 "ls"

7.3 Math 库：数学运算（内置库，无需安装）

核心功能 ：提供基本数学运算、三角函数、常数、取整等（仅支持浮点数/整数，不支持复数）。
常用方法+常数：

import math

# ===================== 一、基础运算=====================
math.sqrt(16)        # 平方根（√x）：4.0（仅支持非负数）
math.pow(2, 3)       # 幂运算（x^y）：8.0（支持小数指数，如 math.pow(4, 0.5)=2.0）
math.pow(2, -1)      # 负指数（1/x^y）：0.5
math.exp(2)          # 自然常数幂（e^x）：7.389...（e≈2.71828）
math.log(10)         # 自然对数（lnx，以e为底）：2.302...
math.log(100, 10)    # 自定义底对数（log_b(x)）：2.0（第二个参数指定底数）
math.log10(100)      # 10进制对数（log10(x)）：2.0
math.log2(8)         # 2进制对数（log2(x)）：3.0
math.hypot(3, 4)     # 欧几里得距离（√(x²+y²)）：5.0（适用于直角三角形斜边、两点距离）

# ===================== 二、三角函数=====================
# 1. 基础三角函数（参数必须为弧度）
math.sin(math.pi/2)  # 正弦（sinx）：1.0
math.cos(math.pi)    # 余弦（cosx）：-1.0
math.tan(math.pi/4)  # 正切（tanx）：1.0（sinx/cosx）
math.csc(math.pi/2)  # 余割（cscx=1/sinx）：1.0
math.sec(math.pi)    # 正割（secx=1/cosx）：-1.0
math.cot(math.pi/4)  # 余切（cotx=1/tanx）：1.0

# 2. 反三角函数（返回值为弧度，范围符合数学定义）
math.asin(1)         # 反正弦（arcsinx）：1.5708...（π/2，范围[-π/2, π/2]）
math.acos(-1)        # 反余弦（arccosx）：3.1415...（π，范围[0, π]）
math.atan(1)         # 反正切（arctanx）：0.7854...（π/4，范围[-π/2, π/2]）
math.atan2(3, 4)     # 四象限反正切（arctan(y/x)）：0.6435...（自动处理x/y符号，确定象限）
math.acsc(1)         # 反余割（arccscx）：1.5708...（π/2）
math.asec(-1)        # 反正割（arcsecx）：3.1415...（π）
math.acot(1)         # 反余切（arccotx）：0.7854...（π/4）

# 3. 单位转换（角度↔弧度）
math.radians(90)     # 角度转弧度：1.5708...（π/2，公式：弧度=角度×π/180）
math.degrees(math.pi)# 弧度转角度：180.0（公式：角度=弧度×180/π）

# ===================== 三、取整与数值处理函数=====================
math.ceil(2.1)       # 向上取整（向正无穷取整）：3
math.ceil(-2.1)      # 向上取整（负数值）：-2
math.floor(2.9)      # 向下取整（向负无穷取整）：2
math.floor(-2.9)     # 向下取整（负数值）：-3
math.trunc(2.9)      # 截断取整（直接舍弃小数部分）：2
math.trunc(-2.9)     # 截断取整（负数值）：-2
math.round(2.4)      # 四舍五入（默认保留整数）：2
math.round(2.5)      # 四舍五入（偶数优先）：2（Python 特性：2.5→2，3.5→4）
math.round(3.1415, 2)# 四舍五入（保留2位小数）：3.14

# ===================== 四、常数=====================
math.pi              # 圆周率 π：3.141592653589793
math.e               # 自然常数 e：2.718281828459045
math.inf             # 正无穷大（float类型）：inf（负无穷：-math.inf）
math.nan             # 非数字（Not a Number）：nan（如 0/0、sqrt(-1) 结果）
math.tau             # 2π（圆周长与半径的比值）：6.283185307179586

# ===================== 五、双曲函数=====================
# 双曲函数（基于指数函数，适用于工程、物理场景）
math.sinh(1)         # 双曲正弦（sinhx=(e^x - e^(-x))/2）：1.1752...
math.cosh(1)         # 双曲余弦（coshx=(e^x + e^(-x))/2）：1.5431...
math.tanh(1)         # 双曲正切（tanhx=sinhx/coshx）：0.7616...
# 反双曲函数
math.asinh(1)        # 反双曲正弦（arsinhx）：0.8814...
math.acosh(1)        # 反双曲余弦（arcoshx）：0.0（范围[0, +inf)）
math.atanh(0.5)      # 反双曲正切（artanhx）：0.5493...

# ===================== 六、其他实用工具函数=====================
math.fabs(-3.14)     # 绝对值（返回float类型，支持小数）：3.14（区别于abs()：abs(-3)返回int）
math.fmod(7, 3)      # 浮点数取模（x - (y * floor(x/y))）：1.0（区别于%：7%3=1，结果一致；负数值有差异）
math.gcd(12, 18)     # 最大公约数（Greatest Common Divisor）：6（仅支持非负整数）
math.lcm(12, 18)     # 最小公倍数（Least Common Multiple）：36（Python 3.9+支持）
math.isinf(math.inf) # 判断是否为无穷大：True
math.isnan(math.nan) # 判断是否为非数字：True

7.4 Time 库：时间处理（内置库，无需安装）

核心功能 ：获取当前时间、时间格式转换、延时等（处理「时间戳」「结构化时间」「字符串时间」三类格式）。
常用方法+示例：

import time

# 获取时间
time.time()          # 当前时间戳（1970-01-01 UTC到现在的秒数）：1735678901.234
time.ctime()         # 时间戳转字符串时间："Fri Nov 28 10:23:45 2025"
time.localtime()     # 时间戳转本地结构化时间（元组格式）

# 时间格式化（结构化时间 ↔ 字符串时间）
t = time.localtime()
time.strftime("%Y-%m-%d %H:%M:%S", t)  # 结构化转字符串："2025-11-28 10:25:30"
time.strptime("2025-11-28", "%Y-%m-%d")# 字符串转结构化时间

# 延时/计时
time.sleep(2)        # 程序暂停2秒
start = time.time()
# 耗时操作...
end = time.time()
print(f"耗时：{end - start:.2f}秒")  # 计算执行时间

常用时间格式符 ：%Y（4位年份）、%m（2位月份）、%d（2位日期）、%H（24小时制）、%M（分钟）、%S（秒）。

7.5 Jieba 库：中文分词（第三方库，需安装）

核心功能 ：将中文文本拆分为单个词语（中文 NLP 基础工具），支持多分词模式和自定义词典。
安装命令 ：pip install jieba
常用方法+示例：

import jieba

text = "我爱Python编程，也喜欢数据分析"

# 精确模式（默认）：无冗余，适合正式文本
words1 = jieba.lcut(text)  # 输出：['我', '爱', 'Python', '编程', '，', '也', '喜欢', '数据', '分析']

# 全模式：所有可能词语组合，有冗余，适合关键词提取
words2 = jieba.lcut(text, cut_all=True)  # 输出含"欢喜"等冗余词

# 搜索引擎模式：拆分长词，适合搜索引擎
words3 = jieba.lcut_for_search(text)

# 自定义词典（解决未收录词分词问题）
jieba.load_userdict("my_dict.txt")  # 词典格式：词语 词频 词性（每行一个）

7.6 Matplotlib 库：数据可视化（第三方库，需安装）

核心功能 ：绘制折线图、直方图、散点图等各类图表（Python 数据可视化首选库），支持自定义样式和中文显示。
安装命令 ：pip install matplotlib
常用模块+示例：

import matplotlib.pyplot as plt
import numpy as np

# 中文显示配置（按需调整）
plt.rcParams['font.sans-serif'] = ['SimHei']  # Windows：黑体；Mac：'Arial Unicode MS'
plt.rcParams['axes.unicode_minus'] = False    # 解决负号显示异常

# 1. 折线图（最常用）
x = np.linspace(0, 10, 100)  # 0-10生成100个均匀点
y = np.sin(x)
plt.plot(x, y, label="sin(x)", color="red", linewidth=2)
plt.xlabel("x轴"), plt.ylabel("y轴"), plt.title("正弦函数图像")
plt.legend(), plt.grid(True, alpha=0.3), plt.show()

# 2. 直方图（数据分布）
data = np.random.randn(1000)  # 1000个正态分布随机数
plt.hist(data, bins=30, color="skyblue", edgecolor="black")
plt.xlabel("数值区间"), plt.ylabel("频数"), plt.title("正态分布直方图"), plt.show()

# 3. 散点图（变量相关性）
x = np.random.rand(50), y = np.random.rand(50)
plt.scatter(x, y, color="orange", s=50, alpha=0.7)
plt.xlabel("x"), plt.ylabel("y"), plt.title("随机散点图"), plt.show()

核心模块 ：matplotlib.pyplot（简称 plt），支持子图（plt.subplot）、保存图片（plt.savefig("fig.png", dpi=300)）等功能。