Python相关
Python 编程语言 系统学习大纲
一、 Python 语言概述
- 1.1 Python 简介
- 历史与发展：Guido van Rossum 创建，Python 2 和 Python 3
- 设计哲学：简洁、易读、明确
- 特点：解释型、动态类型、面向对象、跨平台
- 应用领域：Web开发、数据分析、人工智能、自动化运维、科学计算
- 1.2 Python 版本与生态系统
- Python 2 与 Python 3 的主要区别
- CPython、Jython、IronPython、PyPy 解释器
- Python 包索引 (PyPI) 和 pip 包管理器
- 1.3 开发环境搭建
- 安装 Python 解释器
- 配置环境变量
- 使用 IDLE
- 安装和使用 pip
- 虚拟环境：venv、virtualenv、conda
- 开发工具：PyCharm、VS Code、Jupyter Notebook
二、 基础语法
- 2.1 第一个 Python 程序
print("Hello, World!") - 2.2 变量与数据类型
- 变量的定义与命名规则
- 基本数据类型：
- 数字类型：int、float、complex
- 布尔类型：bool
- 字符串类型：str
- 类型检查与转换
- 2.3 运算符
- 算术运算符：
+、-、*、/、//、%、** - 比较运算符：
==、!=、>、<、>=、<= - 赋值运算符：
=、+=、-=等 - 逻辑运算符：
and、or、not - 位运算符：
&、|、^、~、<<、>> - 成员运算符：
in、not in - 身份运算符：
is、is not
- 算术运算符：
- 2.4 输入与输出
- 输入函数：
input() - 输出函数：
print() - 格式化输出：
%格式化、str.format()、f-string详情关于格式化输出
一、格式化方法概览
方法 Python版本 特点 示例 %-格式化 所有版本 类似C语言printf，简单但功能有限 "Name: %s, Age: %d" % ("Alice", 25)str.format() 2.6+ 功能强大，支持位置、关键字、索引 "Name: {}, Age: {}".format("Alice", 25)f-string 3.6+ 语法简洁，性能好，推荐使用 f"Name: {name}, Age: {age}"Template字符串 所有版本 安全，适合用户输入 Template('Hello $name').substitute(name='Alice')二、%-格式化（旧式格式化）
-
基本格式说明符
格式符 说明 示例 输出 %s 字符串 "%s" % "hello"hello %d 十进制整数 "%d" % 4242 %f 浮点数 "%.2f" % 3.141593.14 %e 科学计数法 "%.2e" % 1234.56781.23e+03 %x 十六进制整数 "%x" % 255ff %o 八进制整数 "%o" % 64100 %% 百分号 "%.1f%%" % 99.599.5% -
格式化控制参数
参数 含义 示例 输出 宽度 最小字段宽度 "%10s" % "hello"（前面五个空格）hello精度 小数位数/最大字符数 "%.3f" % 3.141593.142 对齐 -左对齐，默认右对齐 "%-10s" % "hello"hello（后面五个空格）填充 指定填充字符 "%010d" % 420000000042 符号 +强制显示符号 "%+d" % 42+42 空格 正数前加空格 "% d" % 42` 42`
三、str.format()方法
-
基本语法对照表
类型 语法 示例 输出 位置参数 {}"{}, {}".format("A", "B")A, B 索引参数 {0}"{1}, {0}".format("A", "B")B, A 关键字参数 {key}"{name}, {age}".format(name="Alice", age=25)Alice, 25 属性访问 {obj.attr}"{0.name}".format(person)Alice 下标访问 {list[0]}"{0[0]}".format(lst)1 -
格式控制语法
# 完整格式: {[索引/键]:[[填充]对齐][符号][#][0][宽度][,][.精度][类型]}控制项 语法 描述 示例 输出 对齐 <,>,^,=左、右、居中、符号后填充 "{:>10}".format("test")（前面6个空格）test填充 任何字符 填充字符 "{:*^10}".format("test")***test***符号 +,-, 空格显示符号 "{:+}".format(42)+42 宽度 数字 最小宽度 "{:5}".format(42)（前面三个空格）42精度 .数字小数位数/字符数 "{:.2f}".format(3.14159)3.14 类型 s,d,f等 数据类型 "{:d}".format(42)42 -
类型说明符对照表
类型符 含义 示例 输出 s 字符串（默认） "{:s}".format("test")test d 十进制整数 "{:d}".format(42)42 b 二进制 "{:b}".format(10)1010 o 八进制 "{:o}".format(10)12 x 十六进制小写 "{:x}".format(255)ff X 十六进制大写 "{:X}".format(255)FF e 科学计数法小写 "{:.2e}".format(1000)1.00e+03 E 科学计数法大写 "{:.2E}".format(1000)1.00E+03 f 定点小数 "{:.2f}".format(3.14159)3.14 F 定点小数大写 "{:.2F}".format(float('inf'))INF g 通用格式 "{:g}".format(1000)1000 G 通用格式大写 "{:G}".format(1000)1000 % 百分比 "{:.1%}".format(0.85)85.0% c 字符 "{:c}".format(65)A
四、f-string（格式化字符串字面值）
-
基本用法对比
功能 f-string语法 等效的format() 变量 f"{name}""{}".format(name)表达式 f"{a + b}""{}".format(a + b)函数调用 f"{name.upper()}""{}".format(name.upper())条件表达式 f"{'偶数' if n%2==0 else '奇数'}""{}".format('偶数' if n%2==0 else '奇数')字典键 f"{d['key']}""{}".format(d['key'])列表索引 f"{lst[0]}""{}".format(lst[0]) -
格式控制示例
# 对齐和宽度 f"{'hello':<10}" # 左对齐，宽度10 f"{'hello':>10}" # 右对齐，宽度10 f"{'hello':^10}" # 居中对齐，宽度10 f"{'hello':*^10}" # 居中，宽度10，用*填充 # 数字格式化 f"{3.14159:.2f}" # 保留2位小数 f"{1000:,.2f}" # 千位分隔符 f"{0.85:.1%}" # 百分比 f"{255:#x}" # 带前缀的十六进制 -
等号扩展（Python 3.8+）
# 调试输出变量名和值 x = 10 y = 20 print(f"{x=}, {y=}") # 输出: x=10, y=20 print(f"{x + y=}") # 输出: x + y=30
五、数字格式化特例
-
千位分隔符对比
方法 语法 示例输出 %-格式化 "%,d"不支持 format() "{:,}"1,000,000 f-string f"{value:,}"1,000,000 -
不同进制输出
进制 format() f-string 二进制 "{:b}".format(10)f"{10:b}"八进制 "{:o}".format(10)f"{10:o}"十六进制 "{:x}".format(255)f"{255:x}"带前缀 "{:#x}".format(255)f"{255:#x}"
六、格式化选项对比表
功能需求 %-格式化 str.format() f-string 简单替换 ✓ 简单 ✓ 较复杂 ✓ 最简单 位置参数 ✓ 支持 ✓ 灵活 ✓ 支持 关键字参数 ✗ 不支持 ✓ 支持 ✓ 支持 表达式计算 ✗ 不支持 ✗ 不支持 ✓ 支持 性能 一般 较慢 最快 可读性 较差 一般 最好 类型安全 较差 较好 最好 调试支持 ✗ 不支持 ✗ 不支持 ✓ Python 3.8+ 七、高级格式化技巧
-
日期时间格式化
from datetime import datetime now = datetime.now() # 各种方法的日期格式化 print("%Y-%m-%d %H:%M:%S" % (now.year, now.month, now.day, now.hour, now.minute, now.second)) print("{:%Y-%m-%d %H:%M:%S}".format(now)) print(f"{now:%Y-%m-%d %H:%M:%S}") # 常用日期格式符 # %Y: 四位数年份 %y: 两位数年份 # %m: 月份(01-12) %B: 月份全名 # %d: 日(01-31) %A: 星期全名 -
嵌套格式化
# format() 嵌套 width = 10 precision = 2 value = 12.3456 print("{:{width}.{precision}f}".format(value, width=width, precision=precision)) # f-string 嵌套 print(f"{value:{width}.{precision}f}") -
自定义格式化
class Person: def __init__(self, name, age): self.name = name self.age = age def __format__(self, format_spec): if format_spec == "long": return f"Person(name={self.name}, age={self.age})" elif format_spec == "short": return f"{self.name}({self.age})" else: return str(self) p = Person("Alice", 25) print(f"{p:long}") # Person(name=Alice, age=25) print(f"{p:short}") # Alice(25)
八、最佳实践建议
场景 推荐方法 理由 Python 3.6+ 新项目 f-string 语法简洁，性能好，可读性强 需要兼容旧版本 str.format() 功能强大，兼容性好 简单临时输出 print() 直接打印 快速调试 用户输入模板 string.Template 安全性高，防止注入 C语言背景开发者 %-格式化 熟悉度高，但建议迁移 - 代码示例汇总
# 各种方法的完整示例 name = "Alice" age = 25 height = 1.68 salary = 50000.50 # 1. %-格式化 print("Name: %s, Age: %d, Height: %.2f" % (name, age, height)) # 2. str.format() print("Name: {0}, Age: {1}, Salary: {2:,.2f}".format(name, age, salary)) print("Name: {name}, Age: {age}, Salary: {salary:,.2f}".format( name=name, age=age, salary=salary)) # 3. f-string (推荐) print(f"Name: {name}, Age: {age}, Salary: {salary:,.2f}") print(f"Name: {name:<10} Age: {age:>3} Height: {height:6.2f}m") # 4. 多行f-string message = ( f"个人信息：\n" f" 姓名：{name}\n" f" 年龄：{age}\n" f" 身高：{height:.2f}m" )
总结建议
- 优先使用f-string（Python 3.6+），语法最简洁，性能最好
- 需要兼容旧版本时使用str.format()
- 避免在新代码中使用%-格式化，除非维护旧代码
- 处理用户提供的模板时考虑string.Template以保证安全
- 复杂的格式化需求可结合多种方法使用
-
- 文件输入输出基础
- 输入函数：
三、 流程控制
- 3.1 条件语句
if condition1: # 代码块1 elif condition2: # 代码块2 else: # 代码块3 - 3.2 循环语句
while循环while condition: # 循环体for循环for item in iterable: # 循环体range()函数- 循环控制语句：
break、continue、pass - 循环的
else子句
- 3.3 异常处理
try、except、else、finallytry: # 可能引发异常的代码 except SomeException as e: # 异常处理 else: # 无异常时执行 finally: # 无论是否异常都执行- 常见内置异常类型
- 抛出异常：
raise - 自定义异常
四、 数据结构
- 4.1 列表 (List)
- 创建：
[]或list() - 访问：索引、切片
- 常用方法：
append()、extend()、insert()、remove()、pop()、sort()、reverse() - 列表推导式
[x**2 for x in range(10) if x % 2 == 0]
详情关于列表
一、列表创建与基本操作
类别 方法/操作 描述 示例 结果 创建列表 []创建空列表 lst = [][]list()从可迭代对象创建 list('abc')['a','b','c']列表推导式 快速生成列表 [x**2 for x in range(5)][0,1,4,9,16]索引访问 lst[index]访问指定位置元素 lst[0]第一个元素 lst[-1]访问倒数第一个元素 lst[-1]最后一个元素 切片操作 lst[start:end]获取子列表 lst[1:4]索引1-3的元素 lst[start:end:step]带步长的切片 lst[::2]每隔一个元素 lst[::-1]反转列表 lst[::-1]反向列表 修改元素 lst[index] = value修改指定位置元素 lst[0] = 10修改第一个元素 切片赋值 修改子列表 lst[1:3] = [20,30]替换1-2位置元素 二、列表常用方法
类别 方法 描述 示例 结果 添加元素 append(x)末尾添加元素 lst.append(4)[1,2,3,4]insert(i, x)指定位置插入 lst.insert(1, 10)[1,10,2,3]extend(iterable)合并列表 lst.extend([4,5])[1,2,3,4,5]删除元素 remove(x)删除第一个匹配元素 lst.remove(2)[1,3]pop([i])删除并返回指定位置元素 lst.pop(1)返回 2，列表变[1,3]clear()清空列表 lst.clear()[]查找元素 index(x)返回元素索引 lst.index(2)1count(x)统计元素出现次数 lst.count(2)1in操作符检查元素是否存在 2 in lstTrue排序操作 sort()原地排序 lst.sort()升序排列 reverse()原地反转 lst.reverse()反转列表 sorted()返回排序后的新列表 sorted(lst)新排序列表 reversed()返回反转迭代器 list(reversed(lst))新反转列表 列表运算 +列表连接 [1,2] + [3,4][1,2,3,4]*列表重复 [1,2] * 2[1,2,1,2]列表复制 copy()浅拷贝 lst.copy()新列表对象 list()浅拷贝 list(lst)新列表对象 [:]浅拷贝 lst[:]新列表对象 列表信息 len()列表长度 len(lst)元素个数 max()最大值 max(lst)最大元素 min()最小值 min(lst)最小元素 sum()元素求和 sum(lst)所有元素和 三、列表推导式与高级操作
类别 语法 描述 示例 结果 基本推导式 [expr for x in iterable]对每个元素应用表达式 [x*2 for x in [1,2,3]][2,4,6]带条件 [expr for x in iterable if cond]筛选满足条件的元素 [x for x in range(5) if x%2==0][0,2,4]嵌套循环 [expr for x in A for y in B]嵌套循环 [(x,y) for x in [1,2] for y in [3,4]][(1,3),(1,4),(2,3),(2,4)]条件表达式 [expr1 if cond else expr2 for x in iterable]根据条件选择不同表达式 [x if x>0 else 0 for x in [-1,0,1]][0,0,1]嵌套列表推导式 [[expr for y in iterable2] for x in iterable1]创建嵌套列表 [[0 for _ in range(3)] for _ in range(2)][[0,0,0],[0,0,0]]四、列表与迭代器
类别 方法/函数 描述 示例 结果 迭代 for循环遍历列表 for x in lst: print(x)依次输出每个元素 enumerate()同时获取索引和值 list(enumerate(['a','b']))[(0,'a'),(1,'b')]zip()并行迭代多个列表 list(zip([1,2],['a','b']))[(1,'a'),(2,'b')]迭代器 iter()获取迭代器 it = iter(lst)列表迭代器 next()获取下一个元素 next(it)第一个元素 函数式编程 map()对每个元素应用函数 list(map(str, [1,2,3]))['1','2','3']filter()筛选满足条件的元素 list(filter(lambda x:x>0, [-1,0,1]))[1]reduce()累积计算 from functools import reduce; reduce(lambda x,y:x+y, [1,2,3])6五、列表性能与最佳实践
建议 原因 好例子 坏例子 使用 append()添加元素O(1)时间复杂度 lst.append(x)lst = lst + [x]使用列表推导式 简洁高效 [x**2 for x in range(10)]手动循环创建列表 使用 in检查成员清晰可读 if x in lst:手动遍历检查 避免在循环中修改列表 可能导致意外结果 创建新列表 在循环中删除元素 使用切片复制列表 避免修改原列表 new = lst[:]new = lst（同一对象）排序时使用 key参数灵活指定排序规则 lst.sort(key=lambda x:x[1])手动实现排序逻辑 使用 collections.deque处理队列高效的两端操作 from collections import deque用列表实现队列（pop(0)效率低） 六、常见问题与解决方案
问题 解决方案 代码示例 列表去重 使用 set或字典list(set(lst))或list(dict.fromkeys(lst))展平嵌套列表 使用列表推导式 [item for sublist in lst for item in sublist]查找最大/最小元素索引 使用 max/min的key参数max_index = max(range(len(lst)), key=lst.__getitem__)按多个条件排序 使用 sort的key参数返回元组lst.sort(key=lambda x: (x[0], x[1]))分组操作 使用 itertools.groupbyfrom itertools import groupby; {k:list(v) for k,v in groupby(lst, key=func)}列表分块 使用切片 [lst[i:i+n] for i in range(0, len(lst), n)]合并多个列表 使用 itertools.chainfrom itertools import chain; list(chain(list1, list2, list3))计算列表差异 使用集合运算 list(set(lst1) - set(lst2))七、性能注意事项
操作 时间复杂度 说明 索引访问 lst[i]O(1) 随机访问，常数时间 追加元素 append()O(1) 平均情况，可能需要扩容 插入元素 insert()O(n) 需要移动后续元素 删除元素 remove()/pop(i)O(n) 需要移动元素 成员检查 x in lstO(n) 需要遍历列表 切片 lst[i:j]O(k) k是切片长度 排序 sort()O(n log n) Timsort算法 列表连接 lst1 + lst2O(m+n) 创建新列表，复制所有元素 八、实用代码片段
# 1. 列表去重并保持顺序 def unique_preserve_order(lst): seen = set() return [x for x in lst if not (x in seen or seen.add(x))] # 2. 展平嵌套列表 def flatten(lst): return [item for sublist in lst for item in (sublist if isinstance(sublist, list) else [sublist])] # 3. 列表分块 def chunk_list(lst, chunk_size): return [lst[i:i+chunk_size] for i in range(0, len(lst), chunk_size)] # 4. 查找出现次数最多的元素 def most_common(lst): from collections import Counter return Counter(lst).most_common(1)[0][0] # 5. 列表元素频率统计 def frequency_count(lst): freq = {} for item in lst: freq[item] = freq.get(item, 0) + 1 return freq # 6. 合并多个列表 def merge_lists(*lists): from itertools import chain return list(chain(*lists)) # 7. 列表元素分组 def group_by_key(lst, key_func): grouped = {} for item in lst: key = key_func(item) grouped.setdefault(key, []).append(item) return grouped九、最佳实践总结
- 选择合适的数据结构：列表适合有序、可重复的集合，需要快速随机访问
- 注意性能特征：了解常见操作的时间复杂度，避免在大列表上频繁使用O(n)操作
- 使用列表推导式：简洁高效，Pythonic风格
- 避免在循环中修改列表：如需修改，考虑创建新列表或使用倒序遍历
- 合理使用切片：复制、反转、获取子列表的利器
- 善用内置函数和方法：Python提供了丰富的列表操作方法
- 考虑使用其他数据结构：
- 频繁插入/删除：考虑
collections.deque - 快速成员检查：考虑
set - 键值对：考虑
dict
- 频繁插入/删除：考虑
Python列表是动态数组，支持任意类型的元素，是Python中最灵活、最常用的数据结构之一。掌握列表的操作和特性，是编写高效Python代码的基础。
- 创建：
- 4.2 元组 (Tuple)
- 创建：
()或tuple() - 不可变性
- 元组拆包
详情关于元组
一、元组基础
- 什么是元组？
- 不可变的有序序列
- 一旦创建，不能修改、添加或删除元素
- 用圆括号
()表示 - 支持任意类型的元素
- 元组的特点 | 特性 | 说明 | |——|——| | 不可变性 | 创建后不能修改元素（但可包含可变元素） | | 有序性 | 元素有固定顺序，可通过索引访问 | | 可哈希性 | 不可变元组可用作字典键 | | 内存效率 | 比列表占用更少内存 | | 性能优势 | 某些操作比列表更快 |
二、元组创建
# 创建空元组 t1 = () t2 = tuple() # 单元素元组（必须加逗号） t3 = (1,) t4 = 1, # 括号可选，但推荐加括号 # 多元素元组 t5 = (1, 2, 3) t6 = 1, 2, 3 # 括号可选 # 从可迭代对象创建 t7 = tuple([1, 2, 3]) # 从列表 t8 = tuple("abc") # 从字符串 → ('a', 'b', 'c')三、元组基本操作
- 访问元素
t = (10, 20, 30, 40, 50) # 索引访问 print(t[0]) # 10 print(t[-1]) # 50 (倒数第一个) # 切片操作 print(t[1:4]) # (20, 30, 40) print(t[::2]) # (10, 30, 50) 步长为2 print(t[::-1]) # (50, 40, 30, 20, 10) 反转 - 元组操作
# 连接 t1 = (1, 2) t2 = (3, 4) t3 = t1 + t2 # (1, 2, 3, 4) # 重复 t4 = t1 * 3 # (1, 2, 1, 2, 1, 2) # 成员检查 print(2 in t1) # True print(5 not in t1) # True # 长度 print(len(t1)) # 2
四、元组方法（只有2个）
方法 描述 示例 结果 count(x)统计元素x出现次数 (1,2,2,3).count(2)2index(x)返回元素x首次出现的索引 (1,2,3,2).index(2)1五、元组解包
# 基本解包 x, y, z = (1, 2, 3) print(x, y, z) # 1 2 3 # 星号解包 a, *b, c = (1, 2, 3, 4, 5) print(a, b, c) # 1 [2, 3, 4] 5 # 交换变量 x, y = 1, 2 x, y = y, x print(x, y) # 2 1 # 函数返回多个值 def get_stats(numbers): return min(numbers), max(numbers), sum(numbers)/len(numbers) minimum, maximum, average = get_stats([1, 2, 3, 4, 5])六、命名元组
from collections import namedtuple # 定义命名元组类型 Point = namedtuple('Point', ['x', 'y']) Color = namedtuple('Color', 'red green blue') # 也可以传字符串 # 创建实例 p1 = Point(10, 20) p2 = Point(x=5, y=15) # 访问字段 print(p1.x, p1.y) # 10 20 print(p1[0], p1[1]) # 10 20 (也可以用索引) # 命名元组方法 print(Point._fields) # ('x', 'y') print(p1._asdict()) # {'x': 10, 'y': 20} print(p1._replace(x=100)) # Point(x=100, y=20)七、元组 vs 列表
对比项 元组 列表 可变性 ❌ 不可变 ✅ 可变 语法 圆括号 ()方括号 []性能 创建和访问更快 修改操作更多 内存占用 较少 较多 使用场景 数据记录、字典键 动态集合 方法数量 2个 11+个 哈希性 ✅ 可哈希 ❌ 不可哈希 八、实用技巧
- 元组作为字典键
# 元组可哈希，可作为字典键 points = { (0, 0): "原点", (1, 0): "X轴上", (0, 1): "Y轴上" } print(points[(1, 0)]) # "X轴上" - 元组包含可变对象
# 元组不可变，但元素可以是可变对象 t = ([1, 2], [3, 4]) t[0].append(3) # 可以修改元组中的列表 print(t) # ([1, 2, 3], [3, 4]) # t[0] = [5, 6] # 错误！不能替换整个元素 - 元组推导式
# 元组推导式返回的是生成器 gen = (x**2 for x in range(5)) t = tuple(gen) # 转为元组: (0, 1, 4, 9, 16)
九、最佳实践
- 何时使用元组：
- 数据不应该被修改时
- 用作字典键
- 函数返回多个值
- 保证数据安全
- 何时使用列表：
- 需要频繁修改数据
- 需要排序、添加、删除等操作
- 数据集合大小会变化
- 性能考虑：
- 元组创建和访问更快
- 元组内存占用更小
- 大量只读数据时用元组
- 可读性：
- 命名元组提高代码可读性
- 元组解包使代码更简洁
- 使用合适的命名表示数据含义
十、常见误区
- 单元素元组必须加逗号：
(1,)不是(1) - 元组不可变：但可以包含可变对象
- 元组方法少：只有
count()和index() - 元组推导式：实际返回生成器，需用
tuple()转换
- 创建：
- 4.3 集合 (Set)
- 创建：
{}或set() - 无序、不重复
- 集合运算：并集、交集、差集、对称差集
- 集合推导式
详情关于集合
一、集合基础
- 什么是集合？
- 无序的唯一元素集合
- 用花括号
{}表示，但空集合用set() - 元素必须是可哈希的（不可变类型）
- 支持数学集合运算
-
集合的特点
特性 说明 无序性 元素没有固定顺序 唯一性 自动去重，每个元素只出现一次 可哈希性 元素必须是不可变类型 高效查找 成员检查为 O(1) 时间复杂度 可变性 集合本身可变，但元素必须不可变
二、集合创建
# 创建空集合（不能用 {}，那是空字典） empty_set = set() # 从列表创建 set1 = {1, 2, 3, 3, 2} # 自动去重：{1, 2, 3} set2 = set([1, 2, 3, 4, 4]) # 从列表：{1, 2, 3, 4} # 从字符串创建（获取唯一字符） char_set = set("hello") # {'h', 'e', 'l', 'o'} # 集合推导式 square_set = {x**2 for x in range(5)} # {0, 1, 4, 9, 16}三、集合基本操作
- 增删元素
s = {1, 2, 3} # 添加元素 s.add(4) # {1, 2, 3, 4} s.add(2) # 已存在，不变 # 添加多个元素 s.update([5, 6, 7]) # {1, 2, 3, 4, 5, 6, 7} s.update({8, 9}) # 也可以从其他集合添加 # 删除元素 s.remove(3) # 移除3，如果不存在则报错 s.discard(10) # 移除10，不存在也不报错 s.pop() # 随机移除一个元素并返回 s.clear() # 清空集合 - 查询操作
s = {1, 2, 3, 4, 5} # 成员检查 print(3 in s) # True print(6 not in s) # True # 长度 print(len(s)) # 5 # 遍历 for item in s: print(item) # 顺序不确定
四、集合运算
运算 方法 运算符 描述 并集 union()|所有元素 交集 intersection()&共同元素 差集 difference()-在A不在B的元素 对称差集 symmetric_difference()^只在一个集合中的元素 子集检查 issubset()<=是否为子集 真子集检查 <是否为真子集 超集检查 issuperset()>=是否为超集 真超集检查 >是否为真超集 无交集检查 isdisjoint()是否没有共同元素 A = {1, 2, 3, 4} B = {3, 4, 5, 6} # 并集 print(A | B) # {1, 2, 3, 4, 5, 6} print(A.union(B)) # 同上 # 交集 print(A & B) # {3, 4} print(A.intersection(B)) # 同上 # 差集 print(A - B) # {1, 2} (在A中但不在B中) print(A.difference(B)) # 同上 # 对称差集 print(A ^ B) # {1, 2, 5, 6} (只在其中一个集合中) print(A.symmetric_difference(B)) # 同上 # 子集/超集检查 C = {1, 2} print(C <= A) # True (C是A的子集) print(A >= C) # True (A是C的超集) print(C < A) # True (C是A的真子集) print(A.isdisjoint({7, 8})) # True (没有共同元素)五、不可变集合（frozenset）
# 创建不可变集合 fs = frozenset([1, 2, 3, 3, 2]) # frozenset({1, 2, 3}) # 不可变集合操作 fs2 = frozenset([2, 3, 4]) print(fs & fs2) # frozenset({2, 3}) 可进行集合运算 # fs.add(4) # 错误！不可变集合不能修改 # 作为字典键 dict_with_frozenset = { frozenset([1, 2]): "set1", frozenset([3, 4]): "set2" }六、集合常用方法
方法 描述 示例 copy()返回浅拷贝 s2 = s1.copy()update()添加多个元素 s.update([1,2,3])intersection_update()原地交集 s.intersection_update(t)difference_update()原地差集 s.difference_update(t)symmetric_difference_update()原地对称差集 s.symmetric_difference_update(t)pop()随机移除并返回一个元素 elem = s.pop()remove()移除指定元素（不存在则报错） s.remove(1)discard()移除指定元素（不存在不报错） s.discard(1)clear()清空集合 s.clear()七、集合推导式
# 基本集合推导式 numbers = {x for x in range(10) if x % 2 == 0} # {0, 2, 4, 6, 8} # 从字典创建（获取键的集合） data = {'a': 1, 'b': 2, 'c': 3} keys_set = {key for key in data} # {'a', 'b', 'c'} # 复杂推导式 pairs = {(x, y) for x in range(3) for y in range(3)} # 9个坐标对八、集合与列表/元组转换
# 列表去重（保持顺序） lst = [3, 1, 2, 1, 3, 2, 4] unique_ordered = list(dict.fromkeys(lst)) # [3, 1, 2, 4] # 列表去重（不关心顺序） unique_set = list(set(lst)) # 顺序可能变化 # 检查列表是否有重复 has_duplicates = len(lst) != len(set(lst)) # 获取两个列表的共同元素 list1 = [1, 2, 3, 4] list2 = [3, 4, 5, 6] common = set(list1) & set(list2) # {3, 4}九、集合使用场景
- 数据去重
# 去除重复项 emails = ["a@test.com", "b@test.com", "a@test.com", "c@test.com"] unique_emails = set(emails) # 去重 - 成员快速检查
# 高效检查元素是否存在 valid_users = {"alice", "bob", "charlie"} username = "alice" if username in valid_users: # O(1)时间复杂度 print("用户存在") - 数据对比
# 比较两个数据集 old_data = {1, 2, 3, 4, 5} new_data = {3, 4, 5, 6, 7} added = new_data - old_data # {6, 7} 新增的 removed = old_data - new_data # {1, 2} 删除的 common = old_data & new_data # {3, 4, 5} 共同的
十、性能比较
操作 列表/元组 集合 成员检查 (x in s) O(n) O(1) 添加元素 O(1) (列表末尾) O(1) 删除元素 O(n) O(1) 遍历 O(n) O(n) 交集/并集 O(n²) O(min(len(a), len(b))) 十一、注意事项
- 元素必须可哈希：不能包含列表、字典等可变对象
- 集合推导式返回集合：
{x for x in ...} - 集合运算返回新集合：原始集合不变
- frozenset可用作字典键：普通集合不可以
- 集合顺序不确定：Python 3.7+ 中字典有序，但集合仍无序
十二、实用代码片段
# 1. 统计不同单词数量 text = "hello world hello python world python programming" words = text.split() unique_words = len(set(words)) # 5 # 2. 查找两个列表的不同元素 list1 = [1, 2, 3, 4, 5] list2 = [4, 5, 6, 7, 8] only_in_list1 = set(list1) - set(list2) # {1, 2, 3} only_in_list2 = set(list2) - set(list1) # {6, 7, 8} # 3. 检查多个列表是否有共同元素 lists = [[1, 2, 3], [3, 4, 5], [5, 6, 7]] common_elements = set.intersection(*map(set, lists)) # 空集 # 4. 获取列表中出现频率最高的元素 from collections import Counter lst = [1, 2, 2, 3, 3, 3, 4] most_common = Counter(lst).most_common(1)[0][0] # 3十三、最佳实践
- 使用场景选择：
- 需要快速成员检查 → 集合
- 需要去重 → 集合
- 需要集合运算 → 集合
- 需要顺序或重复元素 → 列表
- 性能优化：
- 大量成员检查时，先将列表转为集合
- 多次集合运算时，使用集合方法
- 大型集合考虑内存占用
- 代码可读性：
- 使用集合运算符号（| & - ^）更简洁
- 命名有意义，如
valid_users而不是s - 适当添加注释说明集合操作逻辑
- 创建：
- 4.4 字典 (Dictionary)
- 创建：
{}或dict() - 键值对映射
- 访问：
dict[key]、dict.get() - 常用方法：
keys()、values()、items()、update()、pop() - 字典推导式
{x: x**2 for x in range(5)}
详情关于字典
一、字典基础
- 什么是字典？
- 键值对（key-value）的无序集合（Python 3.7+ 变为有序）
- 键必须是不可变类型（字符串、数字、元组）
- 值可以是任意类型
- 用花括号
{}表示，键值对用冒号:分隔
-
字典的特点
特性 说明 键的唯一性 键不能重复，后出现的覆盖前面的 可哈希键 键必须是不可变类型 无序性 Python 3.6 前无序，3.7+ 保持插入顺序 动态性 可动态添加、删除键值对 高效查找 基于哈希表，查找速度为 O(1)
二、字典创建
# 创建空字典 d1 = {} d2 = dict() # 直接创建 d3 = {'name': 'Alice', 'age': 25, 'city': 'Beijing'} # 使用dict()构造函数 d4 = dict(name='Bob', age=30) # 关键字参数 d5 = dict([('name', 'Charlie'), ('age', 35)]) # 可迭代对象 d6 = dict(zip(['name', 'age'], ['David', 40])) # zip函数 # 字典推导式 d7 = {x: x**2 for x in range(5)} # {0:0, 1:1, 2:4, 3:9, 4:16}三、字典基本操作
- 访问元素
person = {'name': 'Alice', 'age': 25, 'city': 'Beijing'} # 通过键访问 print(person['name']) # 'Alice' # 通过get()方法访问（推荐） print(person.get('age')) # 25 print(person.get('email')) # None print(person.get('email', '未设置')) # '未设置'（默认值） # 检查键是否存在 if 'name' in person: print("键存在") # 获取所有键、值、键值对 keys = person.keys() # dict_keys(['name', 'age', 'city']) values = person.values() # dict_values(['Alice', 25, 'Beijing']) items = person.items() # dict_items([('name','Alice'), ('age',25), ...]) - 修改元素
# 添加/修改键值对 person['email'] = 'alice@example.com' # 添加 person['age'] = 26 # 修改 # 使用update()更新多个键值对 person.update({'city': 'Shanghai', 'gender': 'female'}) # 设置默认值 person.setdefault('country', 'China') # 如果不存在则设置 - 删除元素
# 删除指定键 del person['city'] # pop()删除并返回值 age = person.pop('age') # 返回25，从字典删除 email = person.pop('email', '默认值') # 提供默认值 # popitem()删除最后一个键值对（Python 3.7+） key, value = person.popitem() # 返回最后一个键值对 # 清空字典 person.clear() # 清空所有键值对
四、字典常用方法
方法 描述 示例 get(key[, default])安全获取值 d.get('key', 0)setdefault(key[, default])键不存在时设置默认值 d.setdefault('key', [])update([other])更新多个键值对 d.update({'a':1})pop(key[, default])删除并返回值 d.pop('key')popitem()删除最后一个键值对 d.popitem()clear()清空字典 d.clear()copy()浅拷贝 d2 = d.copy()keys()返回所有键 d.keys()values()返回所有值 d.values()items()返回所有键值对 d.items()fromkeys(seq[, value])从序列创建字典 dict.fromkeys(['a','b'], 0)五、字典遍历
person = {'name': 'Alice', 'age': 25, 'city': 'Beijing'} # 遍历键 for key in person: print(key, person[key]) # 遍历键值对 for key, value in person.items(): print(f"{key}: {value}") # 只遍历值 for value in person.values(): print(value) # 使用enumerate()获取索引 for i, (key, value) in enumerate(person.items()): print(f"{i}. {key}={value}")六、字典推导式
# 基本字典推导式 squares = {x: x**2 for x in range(5)} # {0:0, 1:1, 2:4, 3:9, 4:16} # 带条件的字典推导式 even_squares = {x: x**2 for x in range(10) if x % 2 == 0} # 键值交换 original = {'a': 1, 'b': 2, 'c': 3} reversed_dict = {value: key for key, value in original.items()} # 合并两个列表为字典 keys = ['a', 'b', 'c'] values = [1, 2, 3] merged = {k: v for k, v in zip(keys, values)} # {'a':1, 'b':2, 'c':3}七、嵌套字典
# 创建嵌套字典 students = { 'Alice': { 'age': 20, 'grade': 'A', 'courses': ['Math', 'Physics'] }, 'Bob': { 'age': 21, 'grade': 'B', 'courses': ['Chemistry', 'Biology'] } } # 访问嵌套字典 print(students['Alice']['age']) # 20 print(students.get('Bob', {}).get('grade', '未知')) # 'B' # 修改嵌套字典 students['Alice']['grade'] = 'A+' students['Alice']['courses'].append('English') # 遍历嵌套字典 for name, info in students.items(): print(f"姓名: {name}") for key, value in info.items(): print(f" {key}: {value}")八、特殊字典类型
- 默认字典（defaultdict）
from collections import defaultdict # 自动为不存在的键创建默认值 word_count = defaultdict(int) # 默认值为0 for word in ["apple", "banana", "apple", "cherry"]: word_count[word] += 1 # 结果: {'apple': 2, 'banana': 1, 'cherry': 1} # 默认值为列表 group_by_letter = defaultdict(list) words = ["apple", "banana", "apricot", "cherry", "blueberry"] for word in words: group_by_letter[word[0]].append(word) # 结果: {'a':['apple','apricot'], 'b':['banana','blueberry'], 'c':['cherry']} - 有序字典（OrderedDict）
from collections import OrderedDict # 保持插入顺序（Python 3.7+ 普通字典也有序，但OrderedDict有额外功能） ordered = OrderedDict() ordered['z'] = 1 ordered['a'] = 2 ordered['c'] = 3 print(list(ordered.keys())) # ['z', 'a', 'c'] 保持插入顺序 # 移动到开头或结尾 ordered.move_to_end('z') # 将'z'移动到最后 ordered.move_to_end('a', last=False) # 将'a'移动到开头 - 计数器（Counter）
from collections import Counter # 统计元素出现次数 words = ["apple", "banana", "apple", "cherry", "banana", "apple"] word_count = Counter(words) print(word_count) # Counter({'apple': 3, 'banana': 2, 'cherry': 1}) # 常见操作 print(word_count.most_common(2)) # [('apple', 3), ('banana', 2)] print(word_count.total()) # 6 (总计数) # 合并计数器 counter1 = Counter(['a', 'b', 'c', 'a']) counter2 = Counter(['a', 'b', 'd']) print(counter1 + counter2) # Counter({'a': 3, 'b': 2, 'c': 1, 'd': 1})
九、字典与JSON
import json # 字典转JSON字符串 data = {'name': 'Alice', 'age': 25, 'city': 'Beijing'} json_str = json.dumps(data, ensure_ascii=False, indent=2) # 结果: 格式化的JSON字符串 # JSON字符串转字典 parsed_data = json.loads(json_str) # 结果: 恢复为字典 # 字典与文件 with open('data.json', 'w', encoding='utf-8') as f: json.dump(data, f, ensure_ascii=False, indent=2) with open('data.json', 'r', encoding='utf-8') as f: loaded_data = json.load(f)十、字典排序
scores = {'Alice': 85, 'Bob': 92, 'Charlie': 78, 'David': 95} # 按键排序 sorted_by_key = dict(sorted(scores.items())) # 结果: {'Alice':85, 'Bob':92, 'Charlie':78, 'David':95}（按字母顺序） # 按值排序（降序） sorted_by_value = dict(sorted(scores.items(), key=lambda x: x[1], reverse=True)) # 结果: {'David':95, 'Bob':92, 'Alice':85, 'Charlie':78} # 获取前N个最高分 top_2 = dict(sorted(scores.items(), key=lambda x: x[1], reverse=True)[:2]) # 结果: {'David':95, 'Bob':92}十一、字典合并
dict1 = {'a': 1, 'b': 2} dict2 = {'b': 3, 'c': 4} dict3 = {'c': 5, 'd': 6} # 方法1: update()（修改原字典） merged1 = dict1.copy() merged1.update(dict2) # dict1的'b'被dict2的'b'覆盖 # 方法2: 字典解包（Python 3.5+） merged2 = {**dict1, **dict2, **dict3} # 后面的字典覆盖前面的相同键 # 方法3: collections.ChainMap from collections import ChainMap chain = ChainMap(dict1, dict2, dict3) # 查询时按顺序查找，不创建新字典 print(chain['b']) # 2（来自dict1） # 方法4: 使用 | 运算符（Python 3.9+） merged3 = dict1 | dict2 # {'a':1, 'b':3, 'c':4}十二、实用代码片段
# 1. 反转字典（值:键列表） original = {'a':1, 'b':2, 'c':1, 'd':3} reversed_dict = {} for key, value in original.items(): reversed_dict.setdefault(value, []).append(key) # 结果: {1:['a','c'], 2:['b'], 3:['d']} # 2. 字典扁平化 nested = {'a':{'b':1, 'c':2}, 'd':{'e':3, 'f':{'g':4}}} def flatten_dict(d, parent_key='', sep='.'): items = [] for k, v in d.items(): new_key = f"{parent_key}{sep}{k}" if parent_key else k if isinstance(v, dict): items.extend(flatten_dict(v, new_key, sep=sep).items()) else: items.append((new_key, v)) return dict(items) # 结果: {'a.b':1, 'a.c':2, 'd.e':3, 'd.f.g':4} # 3. 过滤字典 data = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5} filtered = {k:v for k,v in data.items() if v > 2} # {'c':3, 'd':4, 'e':5} # 4. 按多个条件排序字典列表 students = [ {'name':'Alice', 'score':85, 'age':20}, {'name':'Bob', 'score':92, 'age':19}, {'name':'Charlie', 'score':85, 'age':21} ] sorted_students = sorted(students, key=lambda x: (-x['score'], x['age'])) # 按分数降序，年龄升序十三、性能与注意事项
-
时间复杂度
操作 平均时间复杂度 说明 查找键 O(1) 基于哈希表 插入键值对 O(1) 可能需要扩容 删除键值对 O(1) 遍历 O(n) 遍历所有元素 - 注意事项
- 键必须可哈希：不能使用列表、字典等可变对象作为键
- 字典无序：Python 3.6 前无序，3.7+ 保持插入顺序
- 内存使用：字典比列表占用更多内存
- 哈希冲突：当哈希冲突严重时，性能会下降
- 并发安全：字典不是线程安全的，多线程访问需要加锁
- 最佳实践
- 使用
get()方法安全访问 - 使用
setdefault()设置默认值 - 使用字典推导式简化代码
- 大量数据时考虑使用
defaultdict或Counter - 需要保持顺序时使用
OrderedDict（Python 3.7+ 普通字典也有序）
- 使用
十四、字典与其它数据结构转换
# 字典 ↔ 列表 data = {'a':1, 'b':2, 'c':3} keys_list = list(data.keys()) # ['a', 'b', 'c'] values_list = list(data.values()) # [1, 2, 3] items_list = list(data.items()) # [('a',1), ('b',2), ('c',3)] # 列表 → 字典 pairs = [('a',1), ('b',2), ('c',3)] dict_from_list = dict(pairs) # {'a':1, 'b':2, 'c':3} # 两个列表 → 字典 keys = ['a', 'b', 'c'] values = [1, 2, 3] dict_from_two_lists = dict(zip(keys, values)) # {'a':1, 'b':2, 'c':3} - 创建：
- 4.5 字符串操作
- 字符串方法：
split()、join()、strip()、replace()、find()、startswith()、endswith() - 字符串格式化->详情见2.4-输入与输出
- 原始字符串：
r"string"
python字符串常用方法：
类别 方法 描述 示例 大小写 upper()转大写 "hi".upper()→'HI'lower()转小写 "HI".lower()→'hi'title()单词首字母大写 "hello world".title()→'Hello World'查找 find()查找子串位置 "hello".find('l')→2count()统计出现次数 "hello".count('l')→2startswith()是否以指定开头 "file.txt".startswith('file')→Trueendswith()是否以指定结尾 "file.txt".endswith('.txt')→True替换 replace()替换子串 "hello".replace('l', 'x')→'hexxo'分割 split()分割字符串 "a,b,c".split(',')→['a','b','c']join()连接字符串 '-'.join(['a','b'])→'a-b'修剪 strip()去除两侧空白 " hi ".strip()→'hi'lstrip()/rstrip()去除左/右侧空白 " hi ".lstrip()→'hi '检查 isdigit()是否全数字 "123".isdigit()→Trueisalpha()是否全字母 "abc".isalpha()→Trueisalnum()是否字母或数字 "abc123".isalnum()→True - 字符串方法：
五、 函数
- 5.1 函数定义与调用
def function_name(parameters): """文档字符串""" # 函数体 return value - 5.2 参数传递
- 位置参数
- 关键字参数
- 默认参数
- 可变参数：
*args - 关键字可变参数：
**kwargs
- 5.3 返回值
return语句- 返回多个值
- 5.4 变量作用域
- 局部变量 vs 全局变量
global关键字nonlocal关键字
- 5.5 函数高级特性
- 匿名函数：
lambdalambda x, y: x + y - 高阶函数：
map()、filter()、reduce() - 闭包
- 装饰器
def decorator(func): def wrapper(*args, **kwargs): # 装饰逻辑 return func(*args, **kwargs) return wrapper
- 匿名函数：
- 5.6 生成器与迭代器
- 迭代器协议：
__iter__()和__next__() - 生成器：
yield关键字 - 生成器表达式
- 迭代器协议：
python函数进阶：pyhon函数
六、 模块与包
- 6.1 模块导入
import modulefrom module import nameimport module as alias- 模块搜索路径
- 6.2 模块编写
if __name__ == "__main__":- 模块文档字符串
- 6.3 包结构
__init__.py文件- 子包
- 相对导入与绝对导入
- 6.4 常用标准库模块
os：操作系统接口sys：系统相关参数和函数math：数学函数random：生成随机数datetime：日期和时间处理json：JSON 编解码re：正则表达式collections：容器数据类型itertools：迭代器工具functools：高阶函数工具
七、 面向对象编程
- 7.1 类与对象
class MyClass: def __init__(self, param): self.param = param def method(self): return self.param - 7.2 属性与方法
- 实例属性
- 类属性
- 实例方法
- 类方法：
@classmethod - 静态方法：
@staticmethod
- 7.3 继承
class ChildClass(ParentClass): def __init__(self, param): super().__init__(param)- 单继承与多继承
- 方法重写
super()函数
- 7.4 特殊方法
__init__()：构造方法__str__()、__repr__()：字符串表示__len__()、__getitem__()、__setitem__()：容器方法__eq__()、__lt__()等：比较方法__add__()、__mul__()等：运算符重载
- 7.5 属性访问控制
- 公有属性
- 私有属性：
_和__前缀 @property装饰器
- 7.6 高级主题
- 抽象基类
- 元类
- 描述符
- 混入类
八、 文件操作
- 8.1 文件打开与关闭
open()函数- 文件模式：
'r'、'w'、'a'、'b'、'+' close()方法with语句
- 8.2 文件读写
- 读取：
read()、readline()、readlines() - 写入：
write()、writelines()
- 读取：
- 8.3 文件指针操作
seek()方法tell()方法
- 8.4 文件与目录管理
os模块：listdir()、mkdir()、remove()、rename()os.path模块：exists()、isdir()、isfile()、join()shutil模块：文件复制、移动、删除
九、 异常处理进阶
- 9.1 异常层次结构
- BaseException
- Exception
- 标准异常类
- 9.2 自定义异常
class MyException(Exception): def __init__(self, message): self.message = message - 9.3 异常链
raise ... from ...
- 9.4 警告处理
warnings模块
十、 并发编程
- 10.1 多线程
threading模块- 创建线程
- 线程同步：
Lock、RLock、Semaphore、Event、Condition - 线程间通信：
Queue
- 10.2 多进程
multiprocessing模块- 创建进程
- 进程间通信：
Pipe、Queue、Manager - 进程池
- 10.3 异步编程
asyncio模块async/await语法- 协程
- 异步IO操作
十一、 网络编程
- 11.1 Socket 编程
socket模块- TCP 客户端/服务器
- UDP 客户端/服务器
- 11.2 HTTP 编程
http.client模块urllib模块requests第三方库
- 11.3 Web 框架基础
- Flask 简介
- Django 简介
- FastAPI 简介
十二、 数据库编程
- 12.1 SQLite
sqlite3模块
- 12.2 MySQL
mysql-connector-pythonpymysql
- 12.3 PostgreSQL
psycopg2
- 12.4 ORM
- SQLAlchemy
- Django ORM
- 12.5 NoSQL
- MongoDB：
pymongo - Redis：
redis
- MongoDB：
十三、 测试与调试
- 13.1 调试工具
pdb调试器logging模块assert语句
- 13.2 单元测试
unittest框架pytest框架
- 13.3 性能分析
timeit模块cProfile模块line_profiler第三方库
十四、 代码规范与工程化
- 14.1 代码规范
- PEP 8
- 代码格式化工具：
black、autopep8 - 代码检查工具：
pylint、flake8
- 14.2 项目结构
- 模块化设计
- 包管理
- 配置文件
- 14.3 文档
- 文档字符串
- Sphinx 文档生成
- 14.4 版本控制
- Git 基础
- GitHub/GitLab 使用
- 14.5 打包与发布
setuptoolswheel- 发布到 PyPI
十五、 高级主题
- 15.1 元编程
- 装饰器高级用法
- 元类
- 描述符协议
- 15.2 类型注解
- 类型提示
typing模块mypy静态类型检查
- 15.3 并发模式
- 生产者-消费者模式
- 线程池/进程池模式
- 异步模式
- 15.4 内存管理
- 引用计数
- 垃圾回收
- 内存分析工具
- 15.5 C 扩展
- Cython
- ctypes
- CFFI
十六、 应用领域
- 16.1 Web 开发
- Django/Flask/FastAPI
- RESTful API
- WebSocket
- 16.2 数据分析
- NumPy
- pandas
- Matplotlib
- SciPy
- 16.3 机器学习
- scikit-learn
- TensorFlow
- PyTorch
- 16.4 网络爬虫
- Requests
- BeautifulSoup
- Scrapy
- 16.5 自动化运维
- 系统管理
- 网络管理
- 监控告警
- 16.6 游戏开发
- Pygame
- PyOpenGL
十七、 学习资源
- 17.1 官方文档
- Python 官方文档
- PEP 索引
- 17.2 在线学习平台
- Coursera
- edX
- 中国大学 MOOC
- 17.3 书籍推荐
- 入门：《Python编程：从入门到实践》
- 进阶：《流畅的Python》
- 算法：《Python算法教程》
- 17.4 社区与论坛
- Stack Overflow
- GitHub
- Python 中文社区
- 17.5 实践项目
- Web 应用开发
- 数据分析项目
- 自动化脚本编写
- 开源项目贡献