Python核心元素表

OpenTK 2026-01-16 11:12:34
核心元素定义使用示例适用场景拓展知识点
argparse（命令行参数解析模块）Python标准库模块，用于解析命令行参数，支持位置参数、可选参数、默认值设置、参数类型转换、帮助信息自动生成等功能，可让程序通过命令行接收自定义参数，提升程序的灵活性和可扩展性，是命令行工具开发的核心模块。```python # 1. 导入argparse模块 import argparse # 2. 基础用法：解析位置参数和可选参数 # 创建参数解析器对象 parser = argparse.ArgumentParser( description="这是一个命令行参数解析示例程序", # 程序描述 epilog="使用示例：python script.py 10 --name 张三 --debug" # 示例说明 ) # 添加位置参数（必选，不指定-或--） parser.add_argument( "count", # 参数名 type=int, # 参数类型 help="要处理的数量（整数）" # 帮助信息 ) # 添加可选参数（指定-或--，短选项和长选项） parser.add_argument( "-n", "--name", # 短选项（-n）和长选项（--name） type=str, required=True, # 是否必选 help="用户姓名（必选参数）" ) parser.add_argument( "-d", "--debug", action="store_true", # 无需参数，指定则为True，否则为False help="是否开启调试模式（默认关闭）" ) parser.add_argument( "-t", "--timeout", type=int, default=30, # 默认值 help="超时时间（秒），默认30秒" ) parser.add_argument( "-l", "--levels", type=int, nargs="+", # 接收多个值，存储为列表 help="多个等级值（如：-l 1 2 3）" ) # 解析命令行参数 args = parser.parse_args() # 访问解析后的参数 print("处理数量：", args.count) print("用户姓名：", args.name) print("调试模式：", args.debug) print("超时时间：", args.timeout) print("等级值：", args.levels if args.levels else "未指定") # 3. 高级用法：子命令（类似git commit、git push的子命令结构） # 创建父解析器（公共参数） parent_parser = argparse.ArgumentParser(add_help=False) parent_parser.add_argument( "--verbose", action="store_true", help="显示详细输出信息" ) # 创建主解析器 main_parser = argparse.ArgumentParser(description="支持子命令的示例程序") # 添加子命令解析器 subparsers = main_parser.add_subparsers( dest="command", # 存储子命令名称的变量名 required=True, # 必须指定子命令 help="可用子命令：create、delete" ) # 子命令1：create create_parser = subparsers.add_parser( "create", parents=[parent_parser], # 继承父解析器的公共参数 help="创建资源" ) create_parser.add_argument( "resource", type=str, choices=["file", "dir", "user"], # 限制可选值 help="要创建的资源类型（file/dir/user）" ) create_parser.add_argument( "--path", type=str, help="资源路径（创建file/dir时必填）" ) # 子命令2：delete delete_parser = subparsers.add_parser( "delete", parents=[parent_parser], help="删除资源" ) delete_parser.add_argument( "resource_id", type=int, help="要删除的资源ID" ) delete_parser.add_argument( "--force", action="store_true", help="强制删除（忽略确认）" ) # 解析子命令参数（实际运行时通过命令行传入，此处模拟） # 模拟命令：python script.py create file --path ./test.txt --verbose args_sub = main_parser.parse_args(["create", "file", "--path", "./test.txt", "--verbose"]) print("\n子命令解析结果：") print("子命令：", args_sub.command) print("资源类型：", args_sub.resource) print("资源路径：", args_sub.path) print("详细输出：", args_sub.verbose) # 4. 生成帮助信息（程序运行时执行 -h 或 --help 自动生成） # main_parser.print_help() ```1. 命令行工具开发（如批量处理脚本、数据迁移工具、系统管理工具等）；2. 程序多模式运行（通过命令行参数控制程序执行不同功能，如启动、停止、重启服务）；3. 自定义程序行为（如通过参数指定输入输出文件路径、配置文件路径、运行参数等）；4. 自动化脚本参数配置（如CI/CD流程中的自动化脚本，通过命令行接收环境、版本等参数）；5. 子命令结构工具（如类似git、docker的多子命令工具）；6. 调试与测试（通过命令行参数快速切换调试模式、测试数据等）1. 核心组件：ArgumentParser（参数解析器对象，负责定义和解析参数）；add_argument()（添加参数，支持位置参数、可选参数、子命令等）；parse_args()（解析命令行参数，返回包含参数值的命名空间对象）；2. 关键参数说明：action（参数动作，如store_true存储布尔值、store存储值、append存储为列表）；type（参数类型，如int、str、float，可自定义类型）；required（是否必选）；default（默认值）；nargs（接收参数的数量，如+接收多个、?接收0或1个）；choices（限制参数的可选值）；3. 子命令功能：通过add_subparsers()添加子命令解析器，实现多命令结构；子命令可继承父解析器的公共参数（减少重复定义）；4. 帮助信息：通过description、epilog参数设置程序描述和示例；添加参数时的help参数设置单个参数的帮助信息；运行程序时添加-h或--help可自动生成完整帮助文档；5. 与sys.argv的区别：sys.argv仅获取命令行参数列表，需手动解析；argparse自动完成参数解析、类型转换、错误提示、帮助信息生成，功能更强大；6. 最佳实践：位置参数用于必选的核心参数；可选参数用于非核心的配置项；子命令用于程序的不同功能模块；为每个参数添加清晰的help说明；合理设置默认值，减少用户输入成本；7. 扩展功能：支持自定义参数类型（通过type指定自定义函数）；支持自定义参数验证（通过add_argument()的validators参数或解析后手动验证）；支持从配置文件加载参数（结合configparser/toml模块）。
asyncio（异步I/O框架）Python标准库中的异步I/O框架，用于编写单线程并发代码，基于事件循环（Event Loop）实现，通过async/await语法定义异步函数，支持异步网络请求、文件操作等I/O密集型任务```python # 1. 基本异步函数和事件循环 import asyncio # 定义异步函数（async关键字） async def hello(name): print(f"Hello, {name}") # 模拟I/O操作（如网络请求、文件读取） await asyncio.sleep(1) # 暂停1秒，不阻塞线程 print(f"Goodbye, {name}") # 运行异步函数 async def main(): # 并发运行多个异步任务 task1 = asyncio.create_task(hello("张三")) task2 = asyncio.create_task(hello("李四")) # 等待所有任务完成 await task1 await task2 # 启动事件循环 if __name__ == "__main__": asyncio.run(main()) # Python 3.7+推荐方式 # 输出： # Hello, 张三 # Hello, 李四 # （等待1秒） # Goodbye, 张三 # Goodbye, 李四 # 2. 异步任务的状态管理 async def task_func(num): await asyncio.sleep(num) return num * 2 async def main2(): # 创建任务 task = asyncio.create_task(task_func(2)) print(f"任务状态：{task.done()}") # False（未完成） # 等待任务完成并获取结果 result = await task print(f"任务结果：{result}") # 4 print(f"任务状态：{task.done()}") # True（已完成） asyncio.run(main2()) # 3. 并发任务组（Python 3.11+） async def main3(): # 同时运行多个任务，返回结果列表 results = await asyncio.gather( task_func(1), task_func(2), task_func(3) ) print(results) # [2, 4, 6]（按传入顺序返回结果） asyncio.run(main3()) # 4. 异步文件操作（需要aiofiles库） # pip install aiofiles import aiofiles async def async_write_file(file_path, content): async with aiofiles.open(file_path, "w", encoding="utf-8") as f: await f.write(content) async def async_read_file(file_path): async with aiofiles.open(file_path, "r", encoding="utf-8") as f: return await f.read() async def main4(): await async_write_file("async_test.txt", "Hello async!") content = await async_read_file("async_test.txt") print(content) # Hello async! asyncio.run(main4()) ```1. I/O密集型任务（如网络请求、文件操作、数据库查询）；2. 单线程并发场景（避免多线程的上下文切换开销）；3. 高并发服务开发（如异步Web服务、爬虫、消息队列消费者）；4. 需要同时处理多个I/O任务的场景（如批量网络请求）1. 核心概念：事件循环（Event Loop，管理和调度异步任务）、协程（Coroutine，异步函数执行的载体）、任务（Task，包装协程并管理其生命周期）；2. 语法基础：async定义异步函数，await暂停执行并等待异步任务完成；3. 与多线程的区别：asyncio是单线程并发（通过事件循环切换任务），多线程是多线程并行，asyncio在I/O密集型任务中性能更优；4. 常用函数：asyncio.run()（启动事件循环）、asyncio.create_task()（创建任务）、asyncio.gather()（并发运行多个任务）；5. 异步生态：配套库有aiohttp（异步HTTP请求）、aiofiles（异步文件操作）、asyncpg（异步PostgreSQL）等；6. 注意事项：asyncio不适合CPU密集型任务（会阻塞事件循环），CPU密集型任务需结合multiprocessing；7. Python版本支持：async/await语法从Python 3.5开始支持，asyncio.run()从Python 3.7开始支持
break/continue语句（循环控制）Python中的循环控制语句，用于改变循环的执行流程。break语句用于“终止当前循环”（跳出循环体，不再执行后续迭代）；continue语句用于“跳过当前迭代”（忽略本次循环剩余代码，直接进入下一次迭代），两者均适用于for和while循环。```python # 一、break语句：终止当前循环 # 1. for循环中的break（遍历到指定元素后终止） fruits = ["apple", "banana", "orange", "grape"] for fruit in fruits: if fruit == "orange": break # 遇到"orange"终止循环 print(f"当前水果：{fruit}") # 输出： # 当前水果：apple # 当前水果：banana # 2. while循环中的break（满足条件后终止无限循环） count = 0 while True: # 无限循环 print(f"计数：{count}") count += 1 if count == 3: break # 计数到3终止循环 # 输出： # 计数：0 # 计数：1 # 计数：2 # 3. 嵌套循环中的break（仅终止当前层级循环） for i in range(2): for j in range(3): if j == 1: break # 仅终止内层循环，外层循环继续 print(f"i={i}, j={j}") # 输出： # i=0, j=0 # i=1, j=0 # 二、continue语句：跳过当前迭代 # 1. for循环中的continue（跳过偶数，只打印奇数） for num in range(1, 6): if num % 2 == 0: continue # 偶数时跳过当前迭代，进入下一次 print(f"奇数：{num}") # 输出： # 奇数：1 # 奇数：3 # 奇数：5 # 2. while循环中的continue（跳过负数，只处理非负数） num = -2 while num < 3: num += 1 if num < 0: continue # 负数时跳过当前迭代 print(f"非负数：{num}") # 输出： # 非负数：0 # 非负数：1 # 非负数：2 # 3. 结合条件的实际应用（筛选并处理数据） # 遍历列表，跳过空字符串，处理非空字符串 data = ["", "apple", "", "banana", "orange", ""] for item in data: if not item: continue # 跳过空字符串 # 处理非空字符串（转换为大写） print(f"处理后：{item.upper()}") # 输出： # 处理后：APPLE # 处理后：BANANA # 处理后：ORANGE # 三、break与continue的区别示例 print("=== break示例 ===") for i in range(5): if i == 2: break print(i) # 输出0、1 print("=== continue示例 ===") for i in range(5): if i == 2: continue print(i) # 输出0、1、3、4 ```1. 循环提前终止（如遍历数据时找到目标元素后，无需继续遍历，用break终止）；2. 无限循环控制（如服务器监听、用户输入等待等无限循环场景，用break手动终止）；3. 数据筛选处理（如跳过无效数据、不符合条件的数据，用continue只处理有效数据）；4. 嵌套循环控制（终止或跳过内层循环，不影响外层循环）；5. 性能优化（避免不必要的迭代，减少循环执行次数，提升程序效率）1. break特性：仅终止“当前层级”的循环，嵌套循环中不会影响外层循环；2. continue特性：仅跳过“当前次”迭代，循环不会终止，会继续执行下一次迭代；3. 循环else与break：for/while循环的else块，仅在循环“正常结束”（条件不满足）时执行；若被break终止，else块不会执行；4. while循环注意：使用continue时，需确保循环条件变量在continue之前更新，否则可能导致死循环（如忘记num += 1就continue，num始终不变，循环无限执行）；5. 嵌套循环控制：若需终止外层循环，可使用“标志位”（如设置flag=False，外层循环判断flag）或函数return（将循环放在函数中，break时return）；6. 性能影响：合理使用break/continue可减少循环迭代次数，提升性能；滥用则会增加代码复杂度，降低可读性；7. 常见误区：在嵌套循环中认为break能终止所有循环（实际仅终止当前层）；在while循环中continue前未更新条件变量，导致死循环。
calendar（日历模块）Python标准库模块，提供日历相关功能，支持生成指定年份/月份的日历、判断闰年、获取月份天数、获取星期几等，可用于日历展示、日期相关的逻辑判断等场景```python # 1. 导入calendar模块 import calendar # 2. 生成指定月份的日历（文本格式） cal_month = calendar.month(2024, 5) # 2024年5月的日历 print("2024年5月日历：") print(cal_month) # 输出示例： # May 2024 # Mo Tu We Th Fr Sa Su # 1 2 # 3 4 5 6 7 8 9 # 10 11 12 13 14 15 16 # 17 18 19 20 21 22 23 # 24 25 26 27 28 29 30 # 31 # 3. 生成指定年份的日历（全年） cal_year = calendar.calendar(2024) # 2024年全年日历 print("2024年全年日历（前3个月）：") print(cal_year[:500]) # 打印前500个字符 # 4. 日期相关判断 # 判断是否为闰年 is_leap = calendar.isleap(2024) print("2024年是否为闰年：", is_leap) # True # 获取指定年份的闰年数量（范围内） leap_count = calendar.leapdays(2000, 2024) # 2000-2023年间的闰年数 print("2000-2023年闰年数量：", leap_count) # 获取指定月份的天数 month_days = calendar.monthrange(2024, 5) # (星期几, 天数)，星期几：0=周一，6=周日 print("2024年5月：星期{}，共{}天".format(month_days[0], month_days[1])) # 2024年5月：星期2，共31天 # 获取指定日期是星期几（0=周一，6=周日） weekday = calendar.weekday(2024, 5, 22) print("2024年5月22日是星期{}".format(weekday)) # 获取指定日期是星期几（1=周日，7=周六，兼容旧接口） weekday2 = calendar.isoweekday(2024, 5, 22) print("2024年5月22日是ISO星期{}".format(weekday2)) # ISO标准：1=周一，7=周日 # 5. 日历格式化配置 # 设置每周的第一天（0=周一，6=周日，默认0） calendar.setfirstweekday(calendar.SUNDAY) # 设周日为第一天 cal_month_sun = calendar.month(2024, 5) print("2024年5月日历（周日为第一天）：") print(cal_month_sun) # 生成HTML格式的日历 html_cal = calendar.HTMLCalendar(calendar.SUNDAY) html_content = html_cal.format_month(2024, 5) print("HTML格式2024年5月日历：") print(html_content) ```1. 日历展示（如生成文本/HTML格式日历供用户查看）；2. 日期逻辑判断（如判断闰年、获取月份天数、计算星期几）；3. 日期范围计算（如统计某段时间内的工作日数量）；4. 日程规划类应用（如计算距离某个节日的天数）；5. 报表生成（如按月份统计数据时，获取月份的日期范围）1. 核心功能分类：日历生成（month()、calendar()）、闰年判断（isleap()、leapdays()）、日期属性获取（monthrange()、weekday()）、日历格式化（HTMLCalendar、TextCalendar）；2. 星期几编码规则：weekday()方法返回0=周一、6=周日；isoweekday()返回1=周一、7=周日（符合ISO 8601标准）；3. 日历格式化类：TextCalendar（生成文本日历，可自定义格式）、HTMLCalendar（生成HTML日历，适用于Web展示）；4. 与datetime模块的配合：calendar模块侧重日历整体功能，datetime模块侧重单个日期时间的处理，两者可配合使用（如用datetime获取当前日期，用calendar判断其星期几）；5. 注意事项：month()和calendar()生成的日历默认以周一为第一天，可通过setfirstweekday()修改；leapdays(y1, y2)统计的是y1到y2-1之间的闰年数量；6. 扩展：可通过继承TextCalendar或HTMLCalendar类，自定义日历的展示样式（如高亮节假日）
collections（集合模块）Python标准库模块，提供多种扩展的数据结构，弥补内置数据结构（list、dict、set、tuple）的不足，包括OrderedDict、defaultdict、deque、Counter、namedtuple等，适用于多种复杂场景```python # 1. defaultdict：带有默认值的字典 from collections import defaultdict # 默认为列表类型 dd = defaultdict(list) dd["a"].append(1) dd["a"].append(2) dd["b"].append(3) print(dd) # defaultdict(<class 'list'>, {'a': [1, 2], 'b': [3]}) # 默认为整数类型（计数场景常用） count_dd = defaultdict(int) words = ["a", "b", "a", "c", "a"] for word in words: count_dd[word] += 1 print(count_dd) # defaultdict(<class 'int'>, {'a': 3, 'b': 1, 'c': 1}) # 2. deque：双端队列（高效增删两端元素） from collections import deque dq = deque([1, 2, 3]) dq.append(4) # 右端添加 dq.appendleft(0) # 左端添加 print(dq) # deque([0, 1, 2, 3, 4]) dq.pop() # 右端删除 dq.popleft() # 左端删除 print(dq) # deque([1, 2, 3]) # 3. Counter：计数器（统计元素出现次数） from collections import Counter cnt = Counter(words) print(cnt) # Counter({'a': 3, 'b': 1, 'c': 1}) print(cnt.most_common(2)) # [('a', 3), ('b', 1)]（获取出现次数最多的2个元素） # 4. namedtuple：命名元组（可通过名称访问元素） from collections import namedtuple Person = namedtuple("Person", ["name", "age"]) p = Person("张三", 28) print(p.name) # 张三 print(p.age) # 28 print(p) # Person(name='张三', age=28) # 5. OrderedDict：有序字典（Python 3.7前保证插入顺序，3.7后普通dict也支持） from collections import OrderedDict od = OrderedDict([("a", 1), ("b", 2), ("c", 3)]) od.move_to_end("a") # 将指定键移到末尾 print(od) # OrderedDict([('b', 2), ('c', 3), ('a', 1)]) ```1. 分组统计（defaultdict用于分组，Counter用于计数）；2. 高效队列操作（deque用于双端队列、栈、滑动窗口等场景）；3. 命名数据存储（namedtuple用于存储有固定字段的数据，比普通元组更易读）；4. 有序键值对（OrderedDict用于需要严格保证键顺序的场景，Python 3.7前常用）；5. 复杂数据结构需求（如LRU缓存、任务队列、频率统计等）1. 核心组件功能：defaultdict解决键不存在时的KeyError问题，通过默认工厂函数自动生成默认值；deque底层基于双向链表，两端增删效率O(1)，优于列表（O(n)）；Counter是dict的子类，专门用于计数，提供most_common等实用方法；namedtuple是元组的子类，通过字段名访问元素，提升代码可读性；OrderedDict是dict的子类，保证键的插入顺序，提供move_to_end等有序操作方法；2. 性能特点：deque的两端操作性能远优于列表；Counter的计数功能比手动用dict实现更简洁高效；3. 适用场景细分：deque适合实现栈（append/pop）、队列（append/popleft）、滑动窗口；defaultdict适合分组聚合数据；Counter适合词频统计、数据频率分析；namedtuple适合替代简单类（无方法的纯数据类）；4. 注意事项：Python 3.7后，普通dict已保证插入顺序，OrderedDict的优势仅剩move_to_end、popitem等有序相关方法；namedtuple创建的对象是不可变的，若需要可变字段，可使用dataclasses模块；5. 扩展：collections还包含ChainMap（合并多个字典）、UserDict/UserList/UserString（自定义数据结构的基类）等组件
configparser（配置文件模块）Python标准库模块，专注于处理INI格式配置文件，支持“节（section）-键（key）-值（value）”的层级结构，可轻松实现配置的读取、写入、修改和删除，能自动转换常见数据类型，是管理程序配置参数的核心工具，适配多环境配置管理场景。```python # 1. 导入模块 import configparser import os # 2. 创建并写入INI配置文件 # 初始化配置解析器 config = configparser.ConfigParser() # 新增配置节（section）及键值对 # 数据库配置节 config["database"] = { "host": "127.0.0.1", "port": "3306", "username": "admin", "password": "SecurePass123!", "db_name": "project_db", "charset": "utf8mb4", "connect_timeout": "10" } # 应用程序配置节 config["application"] = { "debug_mode": "True", "log_level": "INFO", "max_requests": "1000", "static_dir": "./static", "template_dir": "./templates" } # 第三方服务配置节 config["third_party"] = { "api_key": "sk_8f7d6c5b4a3b2c1d", "api_url": "https://api.example.com/v1", "timeout": "30" } # 写入配置文件（指定编码避免中文乱码） with open("app_config.ini", "w", encoding="utf-8") as f: config.write(f) print("配置文件 app_config.ini 创建完成") # 3. 读取配置文件 # 重新初始化解析器并加载配置 config_reader = configparser.ConfigParser() # 支持同时读取多个配置文件，后面的文件会覆盖前面的同名配置 config_reader.read(["app_config.ini", "local_config.ini"], encoding="utf-8") # 3.1 获取配置节相关信息 # 获取所有配置节（返回列表） all_sections = config_reader.sections() print("所有配置节：", all_sections) # ['database', 'application', 'third_party'] # 判断配置节是否存在 has_db_section = config_reader.has_section("database") print("是否存在 database 配置节：", has_db_section) # True # 3.2 读取配置值（支持自动类型转换） # 读取字符串（默认类型） db_host = config_reader.get("database", "host") print(f"数据库地址：{db_host}（类型：{type(db_host)}）") # 127.0.0.1（类型：<class 'str'>） # 读取整数 db_port = config_reader.getint("database", "port") max_requests = config_reader.getint("application", "max_requests") print(f"数据库端口：{db_port}（类型：{type(db_port)}）") # 3306（类型：<class 'int'>） # 读取布尔值（支持 True/False、1/0、yes/no、on/off 等写法） debug_mode = config_reader.getboolean("application", "debug_mode") print(f"调试模式：{debug_mode}（类型：{type(debug_mode)}）") # True（类型：<class 'bool'>） # 读取时指定默认值（当键不存在时使用） db_pool_size = config_reader.getint("database", "pool_size", fallback=20) print(f"数据库连接池大小：{db_pool_size}") # 20（配置中未定义，使用默认值） # 3.3 获取指定节的所有键值对 app_configs = dict(config_reader["application"]) print("应用程序所有配置：", app_configs) # 4. 修改和更新配置 # 4.1 修改现有配置值 config_reader.set("application", "debug_mode", "False") config_reader.set("database", "connect_timeout", "15") # 4.2 新增配置键 config_reader.set("third_party", "retry_count", "3") # 4.3 新增配置节 config_reader.add_section("cache") config_reader["cache"] = { "type": "redis", "host": "127.0.0.1", "port": "6379", "expire_seconds": "3600" } # 4.4 删除配置键 if config_reader.has_option("database", "password"): config_reader.remove_option("database", "password") # 4.5 删除配置节 if config_reader.has_section("cache"): config_reader.remove_section("cache") # 保存修改后的配置（覆盖原文件或写入新文件） with open("app_config_updated.ini", "w", encoding="utf-8") as f: config_reader.write(f) print("修改后的配置已保存到 app_config_updated.ini") # 5. 高级特性：配置插值（引用其他配置项） # 启用扩展插值功能 config_interpolate = configparser.ConfigParser(interpolation=configparser.ExtendedInterpolation()) config_interpolate.read("app_config.ini", encoding="utf-8") # 在配置中引用其他键值（格式：${节名:键名}） config_interpolate["application"]["full_static_path"] = "${application:static_dir}/assets" full_static_path = config_interpolate.get("application", "full_static_path") print("拼接后的静态资源路径：", full_static_path) # ./static/assets ```1. 程序多环境配置（如开发、测试、生产环境的数据库地址、服务端口等差异化配置）；2. 第三方服务参数管理（如API密钥、接口地址、超时时间等，避免硬编码）；3. 可配置化程序开发（让用户通过修改INI文件自定义程序行为，无需修改代码）；4. 批量配置更新（如统一修改多个程序实例的数据库连接参数）；5. 配置备份与版本管理（INI文件为文本格式，便于版本控制和备份）；6. 中小型项目的配置中心替代方案（无需搭建复杂配置中心，轻量实现配置管理）1. 配置文件结构：INI文件核心由“节（section）”和“键值对（key=value）”组成，节用方括号包裹（[section]），键值对用等号或冒号分隔；注释以#或;开头，仅支持单行注释；2. 类型转换机制：getint()、getboolean()、getfloat()可自动将字符串配置值转换为对应类型，其中getboolean()支持多种布尔值写法（大小写不敏感）；3. 配置优先级：read()方法支持传入多个配置文件路径，后面的文件会覆盖前面文件的同名节和键，可实现“基础配置+局部配置”的叠加效果；4. 插值功能：通过ExtendedInterpolation()可实现配置项之间的引用（插值），简化路径拼接、参数复用等场景；5. 编码注意事项：处理含中文的配置时，必须指定encoding="utf-8"，否则会出现乱码；Windows系统默认可能为GBK编码，读取时需对应调整；6. 安全建议：敏感配置（如密码、API密钥）不建议明文存储在INI文件中，可结合加密模块（如hashlib、cryptography）加密后存储，读取时解密；7. 局限性：不支持JSON、YAML等格式的复杂数据结构（如嵌套字典、列表），复杂配置场景可考虑使用PyYAML、toml等第三方库。
contextlib（上下文管理工具）Python标准库模块，提供简化上下文管理器实现的工具，无需手动定义__enter__和__exit__方法，即可快速创建上下文管理器，常用于资源管理（如文件、数据库连接）```python # 1. 使用contextlib.contextmanager装饰器创建上下文管理器 from contextlib import contextmanager @contextmanager def file_manager(file_path, mode): # __enter__方法的逻辑 f = open(file_path, mode, encoding="utf-8") yield f # 返回资源给with语句 # __exit__方法的逻辑 f.close() print("文件已关闭") # 使用上下文管理器 with file_manager("test.txt", "w") as f: f.write("Hello, contextlib!") # 写入文件 # 退出with块，自动执行f.close() # 2. 处理异常 @contextmanager def error_handler(): try: yield print("执行成功") except Exception as e: print(f"执行失败：{e}") with error_handler(): 1 / 0 # 触发异常 # 输出：执行失败：division by zero # 3. 嵌套上下文管理器 with open("a.txt", "w") as f1, open("b.txt", "w") as f2: f1.write("Hello a") f2.write("Hello b") # 4. 关闭多个资源 from contextlib import ExitStack with ExitStack() as stack: files = [stack.enter_context(open(f"file{i}.txt", "w")) for i in range(3)] for i, f in enumerate(files): f.write(f"Hello file{i}") # 自动关闭所有打开的文件 ```1. 资源管理（文件、数据库连接、网络连接的自动关闭）；2. 异常处理（统一捕获代码块中的异常）；3. 临时环境切换（如临时修改系统配置，退出后恢复）；4. 多个资源的统一管理（批量打开资源，自动关闭）1. 核心功能：@contextmanager装饰器将生成器转换为上下文管理器，yield前为__enter__逻辑，yield后为__exit__逻辑；2. 与手动实现的区别：代码更简洁，无需定义类和__enter__、__exit__方法；3. ExitStack：用于管理多个上下文管理器，支持动态添加，自动按相反顺序关闭；4. 常用工具：contextlib.closing（将具有close()方法的对象转换为上下文管理器）、contextlib.suppress（忽略指定异常）；5. 上下文管理器协议：实现__enter__（获取资源）和__exit__（释放资源）方法的对象，with语句会自动调用这两个方法；6. 应用场景：替代try-finally语句，简化资源管理代码，减少内存泄漏风险
csv（CSV文件处理模块）Python标准库模块，提供CSV（逗号分隔值）文件的读写功能，支持标准CSV格式及自定义分隔符、引号规则等，可将CSV文件数据与Python的列表、字典等数据结构相互转换，适用于表格数据的导入导出```python # 1. 导入csv模块 import csv # 2. 写入CSV文件（列表方式） # 定义要写入的数据（列表的列表） data = [ ["姓名", "年龄", "性别", "城市"], ["张三", 28, "男", "深圳"], ["李四", 22, "女", "北京"], ["王五", 30, "男", "上海"] ] # 写入CSV文件（默认逗号分隔） with open("users.csv", "w", encoding="utf-8", newline="") as f: # 创建csv写入器 writer = csv.writer(f) # 写入所有数据 writer.writerows(data) # 单独写入一行 writer.writerow(["赵六", 25, "女", "广州"]) print("CSV文件写入完成") # 3. 读取CSV文件（列表方式） with open("users.csv", "r", encoding="utf-8") as f: # 创建csv读取器 reader = csv.reader(f) # 读取所有行（列表的列表） all_rows = list(reader) print("CSV文件所有数据（列表方式）：") for row in all_rows: print(row) # 示例：['姓名', '年龄', '性别', '城市'] # 4. 写入CSV文件（字典方式，带表头） # 定义要写入的数据（字典的列表，键为表头） dict_data = [ {"姓名": "孙七", "年龄": 26, "性别": "男", "城市": "杭州"}, {"姓名": "周八", "年龄": 24, "性别": "女", "城市": "成都"}, {"姓名": "吴九", "年龄": 29, "性别": "男", "城市": "重庆"} ] with open("users_dict.csv", "w", encoding="utf-8", newline="") as f: # 定义表头（字典的键） fieldnames = ["姓名", "年龄", "性别", "城市"] # 创建csv字典写入器 writer = csv.DictWriter(f, fieldnames=fieldnames) # 写入表头 writer.writeheader() # 写入数据 writer.writerows(dict_data) print("字典方式CSV文件写入完成") # 5. 读取CSV文件（字典方式） with open("users_dict.csv", "r", encoding="utf-8") as f: # 创建csv字典读取器 reader = csv.DictReader(f) print("CSV文件所有数据（字典方式）：") for row in reader: # row是字典，键为表头 print(f"姓名：{row['姓名']}，年龄：{row['年龄']}，城市：{row['城市']}") # 6. 自定义CSV格式（如制表符分隔、自定义引号） # 写入制表符分隔的CSV文件 tab_data = [ ["产品", "价格", "库存"], ["手机", 2999.99, 100], ["电脑", 5999.99, 50] ] with open("products_tab.csv", "w", encoding="utf-8", newline="") as f: writer = csv.writer( f, delimiter="\t", # 制表符分隔 quotechar="'", # 用单引号包裹字段 quoting=csv.QUOTE_NONNUMERIC # 非数字字段加引号 ) writer.writerows(tab_data) # 读取制表符分隔的CSV文件 with open("products_tab.csv", "r", encoding="utf-8") as f: reader = csv.reader(f, delimiter="\t") print("制表符分隔的CSV数据：") for row in reader: print(row) # 7. 处理大CSV文件（分块读取，避免内存占用过高） def read_large_csv(file_path, chunk_size=1000): with open(file_path, "r", encoding="utf-8") as f: reader = csv.DictReader(f) chunk = [] for i, row in enumerate(reader, 1): chunk.append(row) if i % chunk_size == 0: yield chunk chunk = [] # 返回剩余数据 if chunk: yield chunk # 分块读取大CSV文件 for idx, chunk in enumerate(read_large_csv("users.csv", chunk_size=2), 1): print(f"第{idx}块数据（共{len(chunk)}行）：") for row in chunk: print(row) ```1. 表格数据导入导出（如将Excel导出的CSV文件导入Python处理，或把Python中的数据导出为CSV供其他工具使用）；2. 数据批量处理（如处理大量用户数据、产品数据的CSV文件）；3. 数据交换（如与其他系统交换表格数据，CSV是通用格式）；4. 日志记录（如按CSV格式记录程序运行日志，便于后续分析）；5. 报表生成（如生成统计报表的CSV文件，供Excel打开编辑）；6. 大文件处理（如分块读取GB级别的CSV文件，避免内存溢出）1. 核心组件：csv.reader（列表方式读取CSV）、csv.writer（列表方式写入CSV）、csv.DictReader（字典方式读取，键为表头）、csv.DictWriter（字典方式写入，需指定表头）；2. 关键参数：delimiter（字段分隔符，默认逗号）、quotechar（字段引用符，默认双引号）、newline（换行符，写入时设为""可避免多余空行）、quoting（引号规则，如QUOTE_ALL所有字段加引号、QUOTE_NONNUMERIC非数字字段加引号）；3. 编码注意事项：处理包含中文的CSV文件时，需指定encoding="utf-8"（或utf-8-sig，处理BOM头），否则可能出现乱码；4. 与Excel的兼容性：Excel默认保存的CSV文件编码可能为GBK（Windows），读取时需指定encoding="gbk"；5. 大文件处理技巧：使用生成器分块读取（如read_large_csv函数），避免将整个文件加载到内存；写入大文件时，可批量调用writerows()（比多次调用writerow()高效）；6. 注意事项：CSV文件中若字段包含分隔符、引号或换行符，会自动被quotechar包裹，读取时会正确解析；DictReader默认使用第一行作为表头，若CSV无表头，需指定fieldnames参数；7. 扩展：若需要更复杂的CSV处理（如合并多个CSV、数据筛选、格式转换），可使用pandas库（read_csv()、to_csv()方法功能更强大）
dataclasses（数据类）Python 3.7+引入的标准库模块，通过@dataclass装饰器自动为类生成__init__、__repr__、__eq__等常用方法，简化纯数据类的定义，替代手动编写繁琐的初始化和魔法方法代码```python # 1. 基本数据类定义 from dataclasses import dataclass @dataclass class Person: name: str # 字段定义（类型注解） age: int gender: str = "未知" # 带默认值的字段 # 自动生成__init__方法 p1 = Person("张三", 28) p2 = Person("李四", 22, "男") # 自动生成__repr__方法 print(p1) # Person(name='张三', age=28, gender='未知') print(p2) # Person(name='李四', age=22, gender='男') # 自动生成__eq__方法 p3 = Person("张三", 28) print(p1 == p3) # True # 2. 可变与不可变数据类 @dataclass(frozen=True) # frozen=True创建不可变数据类 class Point: x: int y: int pt = Point(1, 2) # pt.x = 3 # 报错：can't set attribute（不可变） # 3. 自定义方法 @dataclass class Rectangle: width: float height: float # 自定义计算属性 @property def area(self): return self.width * self.height # 自定义方法 def scale(self, factor): self.width *= factor self.height *= factor rect = Rectangle(3, 4) print(rect.area) # 12.0 rect.scale(2) print(rect) # Rectangle(width=6.0, height=8.0) # 4. 字段配置（field） from dataclasses import field @dataclass class Product: name: str price: float stock: int = 0 # 忽略此字段在__repr__和__eq__中的作用 _internal_id: int = field(repr=False, compare=False, default=0) prod = Product("手机", 2999.99, 100, 12345) print(prod) # Product(name='手机', price=2999.99, stock=100)（未显示_internal_id） prod2 = Product("手机", 2999.99, 100, 67890) print(prod == prod2) # True（忽略_internal_id比较） ```1. 纯数据存储类（如用户信息、商品数据、配置参数等）；2. 替代namedtuple（需要可变字段的场景）；3. 简化类定义（避免手动编写__init__、__repr__等重复代码）；4. 数据验证与处理（结合字段配置实现复杂数据类）；5. 与其他模块配合（如序列化/反序列化、ORM映射等场景）1. 核心功能：@dataclass装饰器自动生成__init__（初始化字段）、__repr__（字符串表示）、__eq__（相等性判断）、__ne__（不等性判断）等方法；可通过参数控制生成行为（如frozen=True生成不可变类）；2. 字段定义规则：字段需添加类型注解（即使是Any类型）；带默认值的字段必须放在无默认值字段之后；3. field函数：用于精细化配置字段，支持repr（是否在__repr__中显示）、compare（是否参与__eq__比较）、default（默认值）、default_factory（默认值工厂函数，用于可变默认值）等参数；4. 与普通类的区别：数据类专注于数据存储，自动生成常用魔法方法，代码更简洁；普通类需手动实现这些方法，适合包含复杂业务逻辑的场景；5. 与namedtuple的区别：namedtuple创建的是不可变元组子类，数据类默认可变（可通过frozen=True改为不可变）；数据类支持自定义方法和属性，namedtuple不支持；6. 注意事项：类型注解仅用于提示，不强制类型检查，若需要类型校验，可结合pydantic模块；默认值若为可变对象（如列表、字典），需使用default_factory（如default_factory=list），避免多个实例共享同一个可变对象
datetime（日期时间模块）Python标准库模块，提供面向对象的日期时间处理功能，在time模块基础上扩展，支持日期计算、时区处理、高精度时间操作等，核心类包括datetime、date、time、timedelta，覆盖绝大多数日期时间场景```python # 1. 导入核心类 from datetime import datetime, date, time, timedelta # 2. 获取当前日期时间 now = datetime.now() # 当前本地时间 now_utc = datetime.utcnow() # 当前UTC时间 print("当前本地时间：", now) # 示例：2024-05-22 10:20:30.123456 print("当前UTC时间：", now_utc) # 3. 日期时间对象初始化 dt = datetime(2024, 5, 20, 14, 30, 0) # 年,月,日,时,分,秒（必选） d = date(2024, 5, 20) # 仅日期 t = time(14, 30, 0) # 仅时间 print("自定义datetime：", dt) print("仅日期：", d) print("仅时间：", t) # 4. 日期时间属性访问 print("年份：", dt.year) print("月份：", dt.month) print("日期：", dt.day) print("小时：", dt.hour) print("分钟：", dt.minute) print("秒：", dt.second) print("微秒：", dt.microsecond) # 5. 日期时间计算（timedelta） # 计算10天后的日期 future_dt = now + timedelta(days=10) print("10天后的时间：", future_dt) # 计算3小时30分钟前的时间 past_dt = now - timedelta(hours=3, minutes=30) print("3小时30分钟前的时间：", past_dt) # 计算两个时间的差值 dt1 = datetime(2024, 5, 20) dt2 = datetime(2024, 5, 25) delta = dt2 - dt1 print("时间差：", delta.days, "天", delta.seconds, "秒") # 5天 0秒 # 6. 格式转换（与字符串） # datetime → 字符串（strftime） dt_str = dt.strftime("%Y-%m-%d %H:%M:%S") print("datetime转字符串：", dt_str) # 字符串 → datetime（strptime） str_to_dt = datetime.strptime("2024-05-20 14:30:00", "%Y-%m-%d %H:%M:%S") print("字符串转datetime：", str_to_dt) # 7. 日期时间替换 dt_modified = dt.replace(year=2025, month=6) # 替换年份和月份 print("修改后的datetime：", dt_modified) # 2025-06-20 14:30:00 ```1. 复杂日期计算（如计算未来/过去时间、时间差统计）；2. 高精度日期时间处理（支持微秒级精度）；3. 日期时间格式化与解析（自定义格式字符串）；4. 仅日期/仅时间的单独处理；5. 业务场景中的日期逻辑（如订单有效期、活动时间范围判断）；6. 与数据库日期时间类型交互（如ORM框架中的日期字段映射）1. 核心类功能：datetime（日期+时间）、date（仅日期）、time（仅时间）、timedelta（时间间隔，用于计算）；2. timedelta支持的参数：days、seconds、microseconds、milliseconds、minutes、hours、weeks；3. 与time模块的关系：datetime模块基于time模块实现，功能更强大、接口更友好，推荐优先使用；4. 时区处理：datetime模块原生支持时区需Python 3.9+（zoneinfo模块），之前版本需借助pytz第三方库；5. 日期时间比较：datetime对象支持直接用>、<、==等运算符比较；6. 注意事项：datetime初始化时，月份范围1-12、日期范围1-当月最大天数，否则抛出ValueError；timedelta的days属性可能为负数（表示过去的时间差）；strptime()的格式必须与输入字符串严格匹配
decorator（装饰器）Python中的语法糖，用于在不修改原函数代码的前提下，为函数添加额外功能（如日志记录、性能测试、权限校验等），本质是一个接收函数作为参数并返回新函数的高阶函数```python # 1. 简单装饰器（无参数） def log_decorator(func): def wrapper(*args, **kwargs): print(f"开始执行函数：{func.__name__}") result = func(*args, **kwargs) # 调用原函数 print(f"函数{func.__name__}执行完毕") return result return wrapper # 使用装饰器 @log_decorator def add(a, b): return a + b print(add(1, 2)) # 输出：开始执行函数：add → 函数add执行完毕 → 3 # 2. 带参数的装饰器 def log_decorator_with_param(level): def decorator(func): def wrapper(*args, **kwargs): print(f"[{level}] 开始执行函数：{func.__name__}") result = func(*args, **kwargs) print(f"[{level}] 函数{func.__name__}执行完毕") return result return wrapper return decorator @log_decorator_with_param("INFO") def multiply(a, b): return a * b print(multiply(3, 4)) # 输出：[INFO] 开始执行函数：multiply → [INFO] 函数multiply执行完毕 → 12 # 3. 类装饰器 class TimerDecorator: def __init__(self, func): self.func = func def __call__(self, *args, **kwargs): import time start_time = time.time() result = self.func(*args, **kwargs) end_time = time.time() print(f"函数{self.func.__name__}执行耗时：{end_time - start_time:.2f}秒") return result @TimerDecorator def test_func(): import time time.sleep(1) test_func() # 输出：函数test_func执行耗时：1.00秒 ```1. 日志记录（记录函数调用信息、参数、返回值）；2. 性能测试（统计函数执行时间）；3. 权限校验（验证用户是否有权限调用函数）；4. 缓存（缓存函数执行结果，避免重复计算）；5. 输入输出校验（校验函数参数和返回值合法性）1. 本质：高阶函数的语法糖，@decorator 等价于 func = decorator(func)；2. 装饰器链：一个函数可被多个装饰器修饰，执行顺序从下到上；3. 保留原函数信息：装饰器会覆盖原函数的__name__、__doc__等属性，可使用functools.wraps修复；4. 带参数装饰器：本质是返回装饰器的函数，需额外嵌套一层；5. 类装饰器：通过__call__方法实现，适用于需要维护状态的装饰器场景；6. 常用内置装饰器：@staticmethod（静态方法）、@classmethod（类方法）、@property（属性方法）
del语句（删除对象）Python中的删除语句，用于删除对象的引用（变量、列表元素、字典键值对、切片等），也可删除整个对象（如列表、字典）。del通过释放对象引用，帮助Python垃圾回收机制回收内存，是内存管理和数据清理的基础工具。```python # 1. 删除变量（释放变量对对象的引用） a = 10 print(a) # 10 del a # 删除变量a # print(a) # 报错：name 'a' is not defined # 2. 删除列表元素/切片 lst = [1, 2, 3, 4, 5, 6] # 删除指定索引的元素 del lst[2] # 删除索引2的元素（3） print(lst) # [1, 2, 4, 5, 6] # 删除切片（连续多个元素） del lst[1:3] # 删除索引1到2的元素（2、4） print(lst) # [1, 5, 6] # 删除从指定索引到末尾的元素 del lst[1:] # 删除索引1及以后的元素（5、6） print(lst) # [1] # 3. 删除字典键值对 dict1 = {"name": "张三", "age": 28, "city": "深圳"} # 删除指定键的键值对 del dict1["age"] # 删除键"age"对应的键值对 print(dict1) # {"name": "张三", "city": "深圳"} # 删除多个键值对（循环删除） keys_to_delete = ["name", "city"] for key in keys_to_delete: if key in dict1: # 先判断键存在，避免报错 del dict1[key] print(dict1) # {}（空字典） # 4. 删除元组/字符串元素？（不可变类型无法删除） tpl = (1, 2, 3) # del tpl[0] # 报错：'tuple' object doesn't support item deletion str1 = "python" # del str1[1] # 报错：'str' object doesn't support item deletion # 5. 删除对象的属性（若对象支持） class Person: def __init__(self, name, age): self.name = name self.age = age p = Person("李四", 30) print(p.name) # 李四 del p.age # 删除Person实例的age属性 # print(p.age) # 报错：'Person' object has no attribute 'age' # 6. 删除模块/函数（不推荐，尽量避免） import math print(math.pi) # 3.141592653589793 del math.pi # 删除math模块的pi属性 # print(math.pi) # 报错：module 'math' has no attribute 'pi' # 7. 批量删除多个对象 x = 100 y = 200 z = 300 del x, y, z # 同时删除多个变量 # print(x, y, z) # 报错：name 'x' is not defined ```1. 内存清理（删除不再使用的变量、大对象，释放内存空间）；2. 数据清理（删除列表/字典中的无效数据、敏感数据）；3. 变量重定义前清理（避免旧变量对新逻辑产生干扰）；4. 对象属性管理（删除对象中不需要的属性）；5. 批量数据删除（删除列表切片、字典多个键值对等批量无效数据）1. 核心原理：del删除的是“对象的引用”，不是对象本身；当对象的引用计数为0时，Python垃圾回收机制会自动回收对象占用的内存；2. 不可变类型限制：字符串、元组等不可变类型的元素无法用del删除（因为不可变类型创建后无法修改）；3. 字典删除注意：del dict[key]删除不存在的键会报错，需先用key in dict判断键是否存在；4. 列表删除影响：删除列表元素后，后续元素会自动前移（索引重新排列），遍历列表时删除元素可能导致遍历不完整（建议遍历列表副本）；5. 与pop()的区别：del仅删除元素，不返回值；pop()删除元素并返回该元素（列表pop()可指定索引，字典pop()指定键）；6. 谨慎使用场景：不建议删除模块、函数等系统/自定义对象，可能导致程序逻辑混乱；删除对象属性后，后续访问该属性会报错；7. 垃圾回收：del后对象引用计数减少，若计数为0则被回收；对于循环引用的对象（如a引用b，b引用a），Python的垃圾回收机制也能处理，但效率较低，尽量避免循环引用。
dict（字典）Python内置的无序键值对集合（Python 3.7+后保证插入顺序），通过哈希表实现，键（key）唯一且必须是不可变类型，值（value）可任意类型，支持O(1)时间复杂度的增删改查```python # 1. 字典初始化 dict1 = {"name": "张三", "age": 28} # 直接初始化 dict2 = dict(name="李四", age=22) # 通过dict()构造函数 dict3 = {x: x*2 for x in range(3)} # 字典推导式 print(dict1) # {'name': '张三', 'age': 28} print(dict2) # {'name': '李四', 'age': 22} print(dict3) # {0: 0, 1: 2, 2: 4} # 2. 核心操作 person = {"name": "张三", "age": 28} person["gender"] = "男" # 添加键值对 person["age"] = 29 # 修改值 del person["gender"] # 删除键值对 print(person.get("address", "未知")) # 安全获取值，不存在返回默认值 # 3. 遍历 for key in person: print(f"{key}: {person[key]}") # 遍历键 for key, value in person.items(): print(f"{key}: {value}") # 遍历键值对 # 4. 常用方法 print(person.keys()) # 获取所有键 print(person.values()) # 获取所有值 print(person.items()) # 获取所有键值对 ```1. 键值映射场景（如用户ID与用户信息映射）；2. 快速查找场景（通过键快速定位值）；3. 配置信息存储（如程序配置参数）；4. 数据去重（利用键的唯一性）1. 底层实现：哈希表，通过计算键的哈希值确定存储位置；2. 键的要求：必须是不可变类型（如str、int、tuple），列表等可变类型不能作为键；3. 时间复杂度：增删改查均为O(1)，哈希冲突时会退化；4. 与列表的区别：字典按键访问，列表按索引访问；5. 常用方法：get()、items()、keys()、values()、pop()、update()等；6. Python 3.7+特性：字典保证插入顺序，底层通过双向链表记录插入顺序
enumerate（枚举函数）Python内置函数，用于将可迭代对象（如列表、元组、字符串）转换为枚举对象，枚举对象的每个元素是包含索引和值的元组，常用于循环中同时获取元素的索引和值```python # 1. 基本用法 lst = ["a", "b", "c"] for idx, val in enumerate(lst): print(f"索引：{idx}，值：{val}") # 输出： # 索引：0，值：a # 索引：1，值：b # 索引：2，值：c # 2. 指定起始索引 lst = ["a", "b", "c"] for idx, val in enumerate(lst, start=1): # 起始索引为1 print(f"序号：{idx}，值：{val}") # 输出： # 序号：1，值：a # 序号：2，值：b # 序号：3，值：c # 3. 枚举字符串 s = "Python" for idx, char in enumerate(s): print(f"索引{idx}：{char}") # 输出： # 索引0：P # 索引1：y # ... # 索引5：n # 4. 枚举元组和集合 tup = (10, 20, 30) for idx, val in enumerate(tup): print(f"索引{idx}：{val}") # 注意：集合是无序的，枚举结果的索引不代表原始顺序 s = {1, 2, 3} for idx, val in enumerate(s): print(f"索引{idx}：{val}") # 5. 与zip结合使用 names = ["张三", "李四", "王五"] scores = [90, 85, 95] for idx, (name, score) in enumerate(zip(names, scores)): print(f"第{idx+1}名：{name}，分数：{score}") # 输出： # 第1名：张三，分数：90 # 第2名：李四，分数：85 # 第3名：王五，分数：95 ```1. 循环中需要元素索引的场景（如列表遍历并记录位置）；2. 数据批量处理（如批量修改列表元素，需要知道元素位置）；3. 序号生成（如为数据添加序号）；4. 枚举可迭代对象的元素（如字符串、元组、集合等）1. 返回值：enumerate()返回枚举对象（迭代器），可通过list()转换为列表；2. 时间复杂度：O(n)，与遍历可迭代对象的时间复杂度一致；3. 与手动维护索引的区别：比手动维护index变量（如index=0，循环中index+=1）更简洁、高效、不易出错；4. 起始索引：start参数仅影响返回的索引值，不改变可迭代对象的原始索引；5. 无序对象注意：枚举集合等无序对象时，索引仅代表枚举顺序，不代表对象的原始顺序；6. 性能：enumerate()是内置函数，由C语言实现，性能优于手动维护索引的方式；7. 常见误区：认为enumerate()只能用于列表，实际上可用于所有可迭代对象
f-string（格式化字符串）Python 3.6+引入的字符串格式化语法，通过在字符串前加f或F，在{}中嵌入变量、表达式或函数调用，实现简洁高效的字符串拼接，性能优于%格式化和str.format()```python # 1. 基本用法：嵌入变量 name = "张三" age = 28 print(f"姓名：{name}，年龄：{age}") # 姓名：张三，年龄：28 # 2. 嵌入表达式 a = 10 b = 20 print(f"{a} + {b} = {a + b}") # 10 + 20 = 30 print(f"{a} * {b} = {a * b:.2f}") # 10 * 20 = 200.00（保留2位小数） # 3. 嵌入函数调用 def get_full_name(first_name, last_name): return f"{first_name}{last_name}" first = "张" last = "三" print(f"全名：{get_full_name(first, last)}") # 全名：张三 # 4. 格式说明符 num = 123.456 print(f"整数格式：{num:d}") # 整数格式：123（强制转换为整数） print(f"科学计数法：{num:e}") # 科学计数法：1.234560e+02 print(f"百分比格式：{num:.2%}") # 百分比格式：12345.60% print(f"对齐（右对齐，占10位）：{num:10.2f}") # 对齐（右对齐，占10位）： 123.46 # 5. 转义与多行f-string # 转义{}：使用双花括号 print(f"{{姓名：{name}}}") # {姓名：张三} # 多行f-string info = f""" 姓名：{name} 年龄：{age} 分数：{95.5} """ print(info) # 输出： # 姓名：张三 # 年龄：28 # 分数：95.5 """1. 字符串拼接场景（如日志输出、用户信息展示）；2. 格式化输出（如报表生成、数据展示）；3. 动态字符串生成（如SQL语句拼接、配置文件内容生成）；4. 函数返回格式化字符串；5. 任何需要简洁高效字符串格式化的场景1. 性能优势：f-string在编译时解析，性能优于%格式化和str.format()，尤其是在多变量拼接场景；2. 语法灵活：支持在{}中嵌入任意合法Python表达式，包括算术运算、函数调用、条件判断（三元表达式）；3. 格式说明符：兼容str.format()的格式说明符，用于控制数值精度、对齐方式、数据类型转换等；4. 与其他格式化方式对比：%格式化语法繁琐，不支持多类型灵活匹配；str.format()比%简洁，但仍不如f-string直观；5. 注意事项：f-string中的变量必须已定义，否则会抛出NameError；嵌入的表达式会立即执行，若表达式有副作用（如修改变量值）需谨慎；6. 进阶用法：支持嵌套f-string（如f"{f'{a}+{b}'}={a+b}"），但过度嵌套会降低可读性，不建议使用
functools（函数工具）Python标准库模块，提供一系列用于操作函数或可调用对象的工具函数，如函数装饰器、函数参数处理、函数缓存等，用于简化函数开发和优化函数性能```python # 1. functools.wraps：修复装饰器覆盖原函数信息的问题 from functools import wraps def my_decorator(func): @wraps(func) # 保留原函数信息 def wrapper(*args, **kwargs): print(f"调用函数：{func.__name__}") return func(*args, **kwargs) return wrapper @my_decorator def add(a, b): """两数相加""" return a + b print(add.__name__) # add（未使用wraps则为wrapper） print(add.__doc__) # 两数相加（未使用wraps则为None） # 2. functools.lru_cache：函数缓存（记忆化） from functools import lru_cache @lru_cache(maxsize=None) # 无限制缓存 def fib(n): if n<= 1: return n return fib(n-1) + fib(n-2) print(fib(10)) # 55（第二次调用fib(10)会直接从缓存获取结果） print(fib.cache_info()) # CacheInfo(hits=8, misses=11, maxsize=None, currsize=11) # 3. functools.partial：偏函数（固定部分参数） from functools import partial def power(base, exp): return base ** exp # 固定exp=2，创建平方函数 square = partial(power, exp=2) print(square(3)) # 9（等价于power(3,2)） # 固定base=2，创建2的n次方函数 power_of_2 = partial(power, 2) print(power_of_2(3)) # 8（等价于power(2,3)） # 4. functools.reduce：累积计算 from functools import reduce print(reduce(lambda x, y: x + y, [1,2,3,4])) # 10（1+2=3, 3+3=6, 6+4=10） print(reduce(lambda x, y: x * y, [1,2,3,4])) # 24（1*2=2, 2*3=6, 6*4=24） ```1. 装饰器开发（修复原函数信息）；2. 性能优化（缓存函数执行结果，避免重复计算）；3. 函数参数固定（创建偏函数，简化函数调用）；4. 累积计算（如求和、求积、拼接字符串）；5. 函数比较与排序（如cmp_to_key将比较函数转换为key函数）1. 核心函数：wraps（修复装饰器）、lru_cache（函数缓存）、partial（偏函数）、reduce（累积计算）、cmp_to_key（比较函数转key函数）；2. lru_cache注意事项：缓存的函数参数必须是不可变类型（如str、int、tuple），否则会报错；3. 偏函数与默认参数的区别：偏函数是创建新函数，默认参数是在原函数中指定，偏函数更灵活；4. reduce函数：Python 3中已从内置函数移到functools模块，适用于对序列进行累积操作；5. 应用场景：函数式编程、性能优化、简化函数调用等；6. 其他常用函数：functools.total_ordering（为类自动实现比较方法）、functools.singledispatch（单分派泛型函数）
generator（生成器）Python中用于创建迭代器的简洁方式，通过yield关键字定义，生成器函数执行时不会一次性返回所有结果，而是暂停并保存状态，每次调用next()或迭代时返回一个值，节省内存```python # 1. 生成器函数（yield关键字） def number_generator(n): for i in range(n): yield i # 暂停执行，返回i，下次调用从这里继续 print(f"继续执行，i={i}") # 使用生成器 gen = number_generator(3) print(next(gen)) # 0（第一次调用，执行到yield返回） print(next(gen)) # 继续执行，i=0 → 1（第二次调用，从yield后继续） print(next(gen)) # 继续执行，i=1 → 2（第三次调用） # next(gen) # 抛出StopIteration异常（无更多值） # 2. 生成器表达式（类似列表推导式，用()包裹） gen_expr = (x*2 for x in range(3)) print(type(gen_expr)) # <class 'generator'> for num in gen_expr: print(num, end=" ") # 0 2 4 # 3. 生成器应用：处理大量数据 def large_data_generator(file_path): with open(file_path, "r", encoding="utf-8") as f: for line in f: yield line.strip() # 逐行读取，避免一次性加载整个文件 # 遍历生成器获取数据 for line in large_data_generator("large_file.txt"): process_line(line) # 处理每一行数据 ```1. 处理大量数据（如大文件读取、海量数据生成）；2. 节省内存场景（避免一次性加载所有数据到内存）；3. 延迟计算场景（需要时才生成数据）；4. 迭代器创建（简化迭代器的实现）1. 工作原理：生成器函数执行时返回生成器对象，调用next()时执行到yield暂停，再次调用从暂停处继续；2. 与列表的区别：列表一次性生成所有数据，生成器按需生成数据，内存占用远小于列表；3. 终止条件：生成器函数执行完毕或遇到return时，抛出StopIteration异常；4. 常用操作：通过next()函数或for循环迭代获取值，可使用send()方法向生成器发送数据；5. 注意：生成器只能迭代一次，迭代完毕后无法再次获取值；6. 扩展：yield from语法可用于嵌套生成器，简化代码
hashlib（哈希算法模块）Python标准库模块，提供多种加密哈希算法的实现（如MD5、SHA-1、SHA-256等），用于生成数据的哈希值（消息摘要），支持对字符串、字节数据进行哈希计算，可用于数据完整性校验、密码加密存储等场景```python # 1. 导入hashlib模块 import hashlib # 2. 基本哈希计算（字符串数据） # 定义要哈希的数据（需转换为字节串） data = "Hello, hashlib!".encode("utf-8") # （1）MD5哈希（128位，不推荐用于安全场景） md5 = hashlib.md5() md5.update(data) # 传入数据 md5_result = md5.hexdigest() # 获取十六进制哈希值 print("MD5哈希值：", md5_result) # 示例：e1a7a1f3c8d4f5e6a7b8c9d0e1f2a3b4c # （2）SHA-256哈希（256位，推荐安全场景使用） sha256 = hashlib.sha256() sha256.update(data) sha256_result = sha256.hexdigest() print("SHA-256哈希值：", sha256_result) # 示例：a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2c # （3）SHA-512哈希（512位，更高安全性） sha512 = hashlib.sha512() sha512.update(data) sha512_result = sha512.hexdigest() print("SHA-512哈希值：", sha512_result) # 3. 分块处理大文件（避免一次性加载到内存） def hash_large_file(file_path, algorithm="sha256"): # 获取指定哈希算法对象 hash_obj = hashlib.new(algorithm) # 分块读取文件 with open(file_path, "rb") as f: while chunk := f.read(4096): # 每次读取4KB hash_obj.update(chunk) return hash_obj.hexdigest() # 生成测试文件 with open("large_file.txt", "wb") as f: f.write(b"test large file content" * 1000) # 计算大文件的SHA-256哈希值 file_hash = hash_large_file("large_file.txt") print("大文件SHA-256哈希值：", file_hash) # 4. 带盐值（salt）的哈希（用于密码存储） def hash_password(password, salt=None): # 生成随机盐值（若未提供） if salt is None: salt = hashlib.sha256(os.urandom(16)).hexdigest().encode("utf-8") else: salt = salt.encode("utf-8") # 密码转换为字节串 password = password.encode("utf-8") # 计算盐值+密码的哈希值（多次迭代增强安全性） hash_obj = hashlib.pbkdf2_hmac( hash_name="sha256", password=password, salt=salt, dkLen=32, # 派生密钥长度 iterations=100000 # 迭代次数，越高越安全但耗时更长 ) # 返回盐值和哈希值（盐值需存储，用于后续验证） return salt.decode("utf-8"), hash_obj.hex() # 加密密码 password = "user123456" salt, hashed_pwd = hash_password(password) print("密码盐值：", salt) print("加密后的密码哈希值：", hashed_pwd) # 验证密码 def verify_password(password, salt, hashed_pwd): _, computed_hash = hash_password(password, salt) return computed_hash == hashed_pwd is_valid = verify_password(password, salt, hashed_pwd) print("密码验证结果：", is_valid) # True is_valid_wrong = verify_password("wrong_password", salt, hashed_pwd) print("错误密码验证结果：", is_valid_wrong) # False # 5. 其他哈希算法 # SHA-1（160位，安全性较低，不推荐新系统使用） sha1 = hashlib.sha1(data).hexdigest() print("SHA-1哈希值：", sha1) # BLAKE2b（高性能哈希算法） blake2b = hashlib.blake2b(data).hexdigest() print("BLAKE2b哈希值：", blake2b) ```1. 数据完整性校验（如文件下载后验证哈希值，确保文件未被篡改）；2. 密码加密存储（将用户密码哈希后存储，避免明文存储风险）；3. 消息认证（验证消息的发送者身份和消息完整性）；4. 数据去重（通过哈希值判断数据是否重复，如文件去重）；5. 数字签名（结合非对称加密，用于文档、软件的签名验证）；6. 任何需要数据摘要和完整性保障的场景1. 支持的哈希算法：MD5（128位）、SHA-1（160位）、SHA-2系列（SHA-224、SHA-256、SHA-384、SHA-512）、BLAKE2等；2. 哈希算法安全性：MD5和SHA-1已被证明存在安全漏洞（可碰撞），不推荐用于安全场景；推荐使用SHA-256、SHA-512、BLAKE2等；3. 核心函数/方法：new()（创建指定算法的哈希对象）、update()（传入要哈希的数据，支持分块）、hexdigest()（返回十六进制哈希字符串）、digest()（返回二进制哈希值）；4. 密码哈希最佳实践：使用带盐值（salt）的哈希，盐值随机且唯一（每个用户不同）；使用PBKDF2_HMAC、bcrypt、Argon2等算法（自带盐值和迭代功能），避免直接使用MD5/SHA系列；5. 大文件处理：通过分块调用update()方法，避免将大文件一次性加载到内存，提升性能并节省内存；6. 注意事项：哈希函数是单向的（无法从哈希值反推原始数据）；相同的原始数据会生成相同的哈希值（确定性）；微小的原始数据变化会导致哈希值大幅变化（雪崩效应）；7. 扩展：若需要更高安全性的哈希或特殊功能，可使用cryptography第三方库（提供更全面的加密功能）
hmac（密钥哈希模块）Python标准库模块，提供基于密钥的哈希消息认证码（HMAC）实现，结合哈希算法和密钥，用于验证消息的完整性和真实性，确保消息未被篡改且来自合法发送者，比普通哈希算法多了密钥验证环节```python # 1. 导入hmac和hashlib模块 import hmac import hashlib import os # 2. 基本HMAC计算 # 定义密钥（需为字节串，推荐使用随机密钥） secret_key = os.urandom(16) # 16字节随机密钥 print("随机密钥（十六进制）：", secret_key.hex()) # 定义要认证的消息 message = "这是一条需要认证的消息".encode("utf-8") # 创建HMAC对象（指定哈希算法和密钥） hmac_obj = hmac.new( key=secret_key, msg=message, digestmod=hashlib.sha256 # 使用SHA-256哈希算法 ) # 获取HMAC值（十六进制） hmac_result = hmac_obj.hexdigest() print("HMAC-SHA256结果：", hmac_result) # 3. 分块处理消息（适用于大消息） hmac_chunked = hmac.new(secret_key, digestmod=hashlib.sha256) # 分块传入消息 hmac_chunked.update(b"这是第一部分消息") hmac_chunked.update(b"这是第二部分消息") hmac_chunked.update(b"这是第三部分消息") hmac_chunked_result = hmac_chunked.hexdigest() print("分块处理的HMAC结果：", hmac_chunked_result) # 4. 消息认证流程（发送方-接收方） def send_message_with_hmac(message, secret_key): # 发送方：计算消息的HMAC值，将消息和HMAC一起发送 hmac_obj = hmac.new(secret_key, msg=message, digestmod=hashlib.sha256) return message, hmac_obj.digest() # 返回原始消息和二进制HMAC值 def receive_and_verify(message, received_hmac, secret_key): # 接收方：重新计算消息的HMAC值，与接收的HMAC对比 hmac_obj = hmac.new(secret_key, msg=message, digestmod=hashlib.sha256) # 使用compare_digest安全比较（避免时序攻击） return hmac.compare_digest(hmac_obj.digest(), received_hmac) # 模拟发送和接收 message_to_send = "用户转账：100元".encode("utf-8") sent_msg, sent_hmac = send_message_with_hmac(message_to_send, secret_key) # 验证消息（正常情况） is_authentic = receive_and_verify(sent_msg, sent_hmac, secret_key) print("消息认证结果（正常）：", is_authentic) # True # 模拟消息被篡改 tampered_msg = "用户转账：200元".encode("utf-8") is_authentic_tampered = receive_and_verify(tampered_msg, sent_hmac, secret_key) print("消息认证结果（被篡改）：", is_authentic_tampered) # False # 模拟密钥错误 wrong_key = os.urandom(16) is_authentic_wrong_key = receive_and_verify(sent_msg, sent_hmac, wrong_key) print("消息认证结果（密钥错误）：", is_authentic_wrong_key) # False # 5. 使用不同的哈希算法 # HMAC-MD5（不推荐安全场景） hmac_md5 = hmac.new(secret_key, msg=message, digestmod=hashlib.md5) print("HMAC-MD5结果：", hmac_md5.hexdigest()) # HMAC-SHA-512 hmac_sha512 = hmac.new(secret_key, msg=message, digestmod=hashlib.sha512) print("HMAC-SHA-512结果：", hmac_sha512.hexdigest()) # 6. 从现有哈希对象创建HMAC hash_obj = hashlib.sha256() hash_obj.update(b"部分消息") # 基于现有哈希对象创建HMAC（继续处理剩余消息） hmac_from_hash = hmac.new(secret_key, digestmod=hashlib.sha256) hmac_from_hash.update(hash_obj.digest()) # 传入现有哈希结果 hmac_from_hash.update(b"剩余消息") print("基于现有哈希的HMAC结果：", hmac_from_hash.hexdigest()) ```1. 消息认证（如API接口调用时，验证请求是否来自合法客户端）；2. 数据传输安全（如客户端与服务器之间传输数据，确保数据未被篡改）；3. 身份验证（如用户登录时，验证用户发送的认证信息）；4. 数字签名辅助（结合非对称加密，增强签名的安全性）；5. 敏感数据传输（如金融交易数据、个人隐私数据的传输验证）；6. 任何需要同时保证数据完整性和发送者真实性的场景1. 核心原理：HMAC = 哈希( (密钥 ^ 外填充) + 哈希( (密钥 ^ 内填充) + 消息 ) )，通过双重哈希和密钥填充，确保即使哈希算法存在碰撞漏洞，HMAC仍能保证安全性；2. 与hashlib的区别：hashlib仅提供无密钥的哈希（验证完整性）；hmac提供带密钥的哈希（同时验证完整性和真实性）；3. 核心函数/方法：new()（创建HMAC对象，指定密钥、消息、哈希算法）、update()（分块传入消息）、digest()（返回二进制HMAC值）、hexdigest()（返回十六进制HMAC值）、compare_digest()（安全比较两个HMAC值，避免时序攻击）；4. 密钥选择：推荐使用16字节及以上的随机密钥（如os.urandom(16)生成），密钥需严格保密，不同通信方使用相同密钥；5. 哈希算法选择：推荐使用SHA-256、SHA-512等安全哈希算法，避免使用MD5、SHA-1；6. 安全注意事项：必须使用compare_digest()方法比较HMAC值，不可直接用==（避免时序攻击，攻击者可通过时间差异推断密钥）；7. 应用场景扩展：API接口签名（客户端用密钥计算请求参数的HMAC，服务器用相同密钥验证）、分布式系统间的数据同步验证、物联网设备间的通信安全
in/not in 成员运算符Python内置的成员运算符，用于判断一个元素是否属于某个可迭代对象（如字符串、列表、元组、集合、字典）。in判断元素“存在于”对象中，not in判断元素“不存在于”对象中，返回结果均为布尔值（True/False），是数据查询、筛选的基础工具。```python # 1. 字符串中的成员判断（判断子串是否存在） text = "Python基础教程" print("Python" in text) # True（"Python"是text的子串） print("java" in text) # False（"java"不是text的子串） print("教程" not in text) # False（"教程"存在于text中） # 2. 列表/元组中的成员判断（判断元素是否存在） lst = [1, 2, 3, 4, 5] print(3 in lst) # True（3是列表元素） print(6 in lst) # False（6不是列表元素） tpl = ("a", "b", "c") print("b" in tpl) # True print("d" not in tpl) # True # 3. 集合中的成员判断（效率最高，推荐大量数据使用） s = {10, 20, 30, 40} print(20 in s) # True print(50 not in s) # True # 4. 字典中的成员判断（默认判断键是否存在，不判断值） dict1 = {"name": "张三", "age": 28, "city": "深圳"} print("name" in dict1) # True（"name"是字典的键） print("张三" in dict1) # False（"张三"是字典的值，不是键） # 判断值是否存在需用values() print("张三" in dict1.values()) # True # 5. 实际应用场景：数据筛选与验证 # 筛选列表中的偶数 lst_num = [1, 2, 3, 4, 5, 6, 7, 8] even_lst = [x for x in lst_num if x % 2 == 0] print(even_lst) # [2, 4, 6, 8] # 验证用户输入是否在允许的范围内 allowed_genders = ["男", "女", "未知"] user_gender = input("请输入性别（男/女/未知）：") if user_gender in allowed_genders: print("输入有效") else: print("输入无效，仅允许输入男/女/未知") # 6. 嵌套结构中的成员判断（需逐层判断） nested_lst = [[1, 2], [3, 4], [5, 6]] print(2 in nested_lst) # False（2是子列表元素，不是外层列表元素） print([1, 2] in nested_lst) # True（[1,2]是外层列表元素） # 判断子列表中的元素 has_2 = any(2 in sub_lst for sub_lst in nested_lst) print(has_2) # True ```1. 数据存在性验证（如验证用户输入是否在允许的选项中、判断元素是否在数据集合中）；2. 数据筛选（如筛选列表中符合条件的元素、过滤不存在的键值对）；3. 条件判断（如根据元素是否存在执行不同的逻辑）；4. 数据去重辅助（如判断元素是否已在集合中，避免重复添加）；5. 字典键/值验证（如判断字典中是否存在指定键，避免访问不存在的键报错）1. 效率差异：集合（set）的in操作效率最高（时间复杂度O(1)），列表/元组（O(n)）效率较低，大量数据的成员判断优先使用集合；2. 字典成员判断：默认判断“键”，判断“值”需用value in dict.values()（效率低），判断“键值对”需用(key, value) in dict.items()；3. 嵌套结构注意：in运算符仅判断“当前层级”的元素，嵌套结构需逐层判断（如嵌套列表需遍历子列表）；4. 字符串成员判断：判断的是“子串”是否存在（如"ab" in "abc"返回True），不是单个字符（单个字符也属于子串）；5. 空对象判断：空字符串、空列表、空元组、空集合、空字典的in判断均返回False（如1 in [] → False）；6. 不可变对象要求：集合、字典的键要求是不可变类型，因此in判断的元素若为集合/字典的键，必须是不可变类型（如str、int、tuple）；7. 替代方案：any()/all()函数可结合生成器表达式，实现多条件的成员判断（如any(x in lst for x in [2,4,6])判断列表是否包含任意一个目标元素）。
itertools（迭代器工具）Python标准库模块，提供一系列高效的迭代器生成函数，用于创建各种类型的迭代器，支持循环、组合、排列等常见迭代操作，性能优于手动实现，节省内存```python # 1. 无限迭代器 from itertools import count, cycle, repeat # count：从指定值开始无限递增 for i in count(5, 2): # 5,7,9,... if i > 10: break print(i, end=" ") # 5 7 9 # cycle：循环迭代可迭代对象 for idx, val in enumerate(cycle(["a", "b"])): if idx > 3: break print(val, end=" ") # a b a b # repeat：重复生成指定值 for val in repeat("hello", 3): # 重复3次 print(val, end=" ") # hello hello hello # 2. 有限迭代器 from itertools import accumulate, chain, groupby, product # accumulate：累加/累积计算 print(list(accumulate([1,2,3,4]))) # [1, 3, 6, 10]（1,1+2,1+2+3,...） # chain：串联多个可迭代对象 print(list(chain([1,2], [3,4], [5]))) # [1,2,3,4,5] # groupby：按指定键分组 data = [("a",1), ("a",2), ("b",3), ("b",4)] for key, group in groupby(data, key=lambda x: x[0]): print(key, list(group)) # a [('a',1), ('a',2)] → b [('b',3), ('b',4)] # product：笛卡尔积 print(list(product([1,2], ["a","b"]))) # [(1,'a'), (1,'b'), (2,'a'), (2,'b')] ```1. 无限序列生成（如计数器、循环任务）；2. 数据组合与排列（如笛卡尔积、排列组合）；3. 高效迭代处理（如串联多个数据集、分组统计）；4. 内存高效的循环操作（避免创建大量中间列表）1. 核心优势：生成的是迭代器，按需生成数据，内存占用低，性能高效；2. 无限迭代器注意事项：必须手动添加终止条件，否则会无限循环；3. 常用函数分类：无限迭代器（count、cycle、repeat）、迭代器组合（chain、product、permutations、combinations）、迭代器过滤（filterfalse、takewhile、dropwhile）、累积计算（accumulate）；4. 与列表推导式的区别：itertools函数返回迭代器，列表推导式返回列表，前者更节省内存；5. 性能优化：itertools函数由C语言实现，执行速度远快于纯Python手动实现；6. 常见应用：数据处理、算法实现、批量任务处理等场景
json（JSON处理模块）Python标准库模块，提供JSON数据与Python数据类型之间的转换功能，包括将Python对象（如dict、list）转换为JSON字符串（序列化），以及将JSON字符串转换为Python对象（反序列化），适用于数据交换场景```python # 1. 导入json模块 import json # 2. Python对象序列化（转换为JSON字符串） python_data = { "name": "张三", "age": 28, "gender": "男", "is_student": False, "hobbies": ["编程", "阅读", "运动"], "address": { "province": "广东", "city": "深圳" } } # dumps()：将Python对象转换为JSON字符串 json_str = json.dumps(python_data, ensure_ascii=False, indent=2) print("JSON字符串：") print(json_str) # 输出： # { # "name": "张三", # "age": 28, # "gender": "男", # "is_student": false, # "hobbies": [ # "编程", # "阅读", # "运动" # ], # "address": { # "province": "广东", # "city": "深圳" # } # } # dump()：将Python对象直接写入文件（序列化到文件） with open("data.json", "w", encoding="utf-8") as f: json.dump(python_data, f, ensure_ascii=False, indent=2) # 3. JSON字符串反序列化（转换为Python对象） json_str = ''' { "name": "李四", "age": 22, "gender": "女", "is_student": true, "hobbies": ["音乐", "绘画"], "address": { "province": "北京", "city": "北京" } } ''' # loads()：将JSON字符串转换为Python对象 python_obj = json.loads(json_str) print("Python对象：", python_obj) print("姓名：", python_obj["name"]) print("爱好：", python_obj["hobbies"]) # load()：从文件读取JSON字符串并转换为Python对象（从文件反序列化） with open("data.json", "r", encoding="utf-8") as f: loaded_data = json.load(f) print("从文件加载的Python对象：", loaded_data) # 4. 特殊类型处理（如datetime） from datetime import datetime # 自定义JSON编码器，处理datetime类型 class DateTimeEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, datetime): return obj.strftime("%Y-%m-%d %H:%M:%S") return super().default(obj) # 自定义JSON解码器，处理datetime字符串 def datetime_decoder(obj): for key, value in obj.items(): if isinstance(value, str): try: return datetime.strptime(value, "%Y-%m-%d %H:%M:%S") except ValueError: pass return obj data_with_datetime = { "event": "会议", "time": datetime(2024, 5, 20, 14, 30, 0) } # 序列化（处理datetime） json_str = json.dumps(data_with_datetime, cls=DateTimeEncoder, ensure_ascii=False) print("包含datetime的JSON字符串：", json_str) # 反序列化（还原datetime） python_obj = json.loads(json_str, object_hook=datetime_decoder) print("还原的datetime对象：", python_obj["time"], type(python_obj["time"])) ```1. 数据交换（如前后端数据交互、不同系统间的数据传输）；2. 配置文件存储（用JSON格式存储程序配置）；3. 数据持久化（将Python对象保存为JSON文件）；4. API开发（请求参数和响应数据的JSON转换）；5. 日志记录（将复杂数据结构以JSON格式记录到日志）1. 核心函数：dumps()（Python对象→JSON字符串）、dump()（Python对象→JSON文件）、loads()（JSON字符串→Python对象）、load()（JSON文件→Python对象）；2. 序列化规则：Python的dict→JSON的object，list/tuple→JSON的array，str→JSON的string，int/float→JSON的number，True→true，False→false，None→null；3. 反序列化规则：JSON的object→Python的dict，JSON的array→Python的list，JSON的string→Python的str，JSON的number→Python的int/float，JSON的true→True，JSON的false→False，JSON的null→None；4. 特殊参数：ensure_ascii（默认True，是否将非ASCII字符编码为\uXXXX，设为False可保留中文）、indent（缩进空格数，用于格式化输出JSON）、sort_keys（是否按键排序）；5. 特殊类型处理：JSON不支持Python的datetime、decimal、complex等类型，需自定义JSONEncoder和JSONDecoder实现转换；6. 与其他格式的区别：JSON是轻量级文本格式，可读性强，广泛用于网络数据交换；XML格式更复杂，适用于复杂数据结构；Pickle是Python专用二进制格式，支持所有Python对象，但不可跨语言；7. 注意事项：JSON字符串必须使用双引号，单引号会导致反序列化失败；Python对象中的键必须是字符串类型（JSON的键只能是字符串）；处理大JSON文件时，若文件过大，建议分块处理，避免占用过多内存
lambda（匿名函数）Python中的匿名函数，通过lambda关键字定义，只能包含一个表达式，表达式的结果即为返回值，适用于创建简单的临时函数，避免定义正式函数的繁琐```python # 1. 基本用法：lambda 参数: 表达式 add = lambda a, b: a + b print(add(1, 2)) # 3（等价于def add(a,b): return a+b） # 2. 作为参数传递（常用场景） # 列表排序 lst = [(1, 3), (2, 1), (3, 2)] lst.sort(key=lambda x: x[1]) # 按元组第二个元素排序 print(lst) # [(2, 1), (3, 2), (1, 3)] # 过滤列表 lst = [1, 2, 3, 4, 5] even_lst = list(filter(lambda x: x % 2 == 0, lst)) # 过滤偶数 print(even_lst) # [2, 4] # 映射转换 lst = [1, 2, 3] square_lst = list(map(lambda x: x**2, lst)) # 求平方 print(square_lst) # [1, 4, 9] # 3. 与reduce结合 from functools import reduce total = reduce(lambda x, y: x + y, [1,2,3,4]) print(total) # 10 # 4. 作为返回值 def get_operator(op): if op == "+": return lambda a, b: a + b elif op == "*": return lambda a, b: a * b add = get_operator("+") multiply = get_operator("*") print(add(2, 3)) # 5 print(multiply(2, 3)) # 6 ```1. 临时函数需求（无需定义正式函数）；2. 函数参数场景（如sort的key、filter的过滤函数、map的映射函数）；3. 简单逻辑表达（一行代码可完成的函数逻辑）；4. 函数式编程（与reduce、filter、map等函数结合）1. 语法限制：只能有一个表达式，不能包含复杂逻辑（如循环、条件判断需用三元表达式）；2. 与正式函数的区别：匿名函数无函数名，适用于简单逻辑；正式函数适用于复杂逻辑，可复用；3. 三元表达式结合：lambda x: x if x%2==0 else -x（偶数返回本身，奇数返回负数）；4. 不建议场景：逻辑复杂、需要复用、需要文档字符串的函数，应使用正式函数；5. 变量作用域：lambda中的变量遵循LEGB规则，可能存在闭包相关的变量延迟绑定问题；6. 常见误区：认为lambda函数比正式函数高效，实际上性能差异极小，主要差异在代码可读性
list（列表）Python内置的有序可变序列，用于存储任意类型元素，支持动态添加、删除、修改元素，底层基于动态数组实现，访问效率高，插入删除效率与位置相关```python # 1. 列表初始化 lst1 = [1, 2, 3, "Python"] # 直接初始化 lst2 = list(range(5)) # 通过list()构造函数 lst3 = [x*2 for x in range(3)] # 列表推导式 print(lst1) # [1, 2, 3, 'Python'] print(lst2) # [0, 1, 2, 3, 4] print(lst3) # [0, 2, 4] # 2. 核心操作 lst = [1, 2, 3] lst.append(4) # 末尾添加元素 lst.insert(1, 1.5) # 指定位置插入元素 lst.remove(2) # 删除指定值的元素 print(lst) # [1, 1.5, 3, 4] # 3. 切片操作 print(lst[1:3]) # [1.5, 3]（左闭右开） print(lst[::-1]) # [4, 3, 1.5, 1]（反转列表） # 4. 遍历 for item in lst: print(item, end=" ") # 1 1.5 3 4 ```1. 存储有序数据集合（如用户列表、商品列表）；2. 动态数据维护场景（频繁添加/删除元素）；3. 临时数据存储（如循环过程中的中间结果）；4. 需按索引访问数据的场景1. 底层实现：动态数组，预分配一定容量，满了自动扩容（通常扩容为原容量的1.5倍）；2. 时间复杂度：按索引访问O(1)，末尾添加/删除O(1)，指定位置插入/删除O(n)；3. 与元组的区别：列表可变（mutable），元组不可变（immutable）；4. 常用方法：append()、extend()、insert()、remove()、pop()、sort()、reverse()等；5. 注意：列表可存储不同类型元素，但会增加内存开销和降低效率，建议存储同类型元素
logging（日志模块）Python标准库模块，提供完善的日志记录功能，支持日志级别控制、多目标输出（控制台、文件、网络等）、日志格式化、日志轮转等，可替代print语句实现更灵活、可配置的日志管理，是程序调试、运行监控、问题排查的核心工具。```python # 1. 导入logging模块 import logging from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler import os # 2. 基础日志配置（快速使用） # 配置日志级别、格式、输出目标 logging.basicConfig( level=logging.INFO, # 日志级别：DEBUG < INFO < WARNING < ERROR < CRITICAL format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", # 日志格式 handlers=[ logging.StreamHandler(), # 输出到控制台 logging.FileHandler("app_basic.log", encoding="utf-8") # 输出到文件 ] ) # 获取日志器对象 logger = logging.getLogger(__name__) # 输出不同级别的日志 logger.debug("这是DEBUG级日志（基础配置中未开启，不会输出）") logger.info("这是INFO级日志（程序正常运行信息）") logger.warning("这是WARNING级日志（潜在风险提示）") logger.error("这是ERROR级日志（程序错误，但不影响整体运行）") logger.critical("这是CRITICAL级日志（严重错误，程序可能终止）") # 3. 高级日志配置（自定义输出、轮转等） def setup_advanced_logging(): # 创建日志器 logger = logging.getLogger("advanced_logger") logger.setLevel(logging.DEBUG) # 日志器级别（低于处理器级别无效） logger.propagate = False # 禁止向上传播（避免重复输出） # 定义日志格式 formatter = logging.Formatter( "%(asctime)s - %(name)s - %(filename)s:%(lineno)d - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S" ) # 1. 控制台处理器（输出INFO及以上级别） console_handler = logging.StreamHandler() console_handler.setLevel(logging.INFO) console_handler.setFormatter(formatter) logger.addHandler(console_handler) # 2. 文件处理器（按文件大小轮转，输出DEBUG及以上级别） # 每个文件最大10MB，最多保留5个备份文件 file_rotating_handler = RotatingFileHandler( "app_rotating.log", maxBytes=10 * 1024 * 1024, # 10MB backupCount=5, encoding="utf-8" ) file_rotating_handler.setLevel(logging.DEBUG) file_rotating_handler.setFormatter(formatter) logger.addHandler(file_rotating_handler) # 3. 定时轮转文件处理器（按天轮转，输出ERROR及以上级别） timed_rotating_handler = TimedRotatingFileHandler( "app_timed.log", when="D", # 按天轮转 interval=1, # 每天轮转一次 backupCount=7, # 保留7天的日志 encoding="utf-8" atTime=datetime.time(0, 0, 0) # 每天凌晨轮转 ) timed_rotating_handler.setLevel(logging.ERROR) timed_rotating_handler.setFormatter(formatter) logger.addHandler(timed_rotating_handler) return logger # 初始化高级日志 advanced_logger = setup_advanced_logging() # 使用高级日志器输出日志 advanced_logger.debug("这是DEBUG级日志（仅输出到rotating.log）") advanced_logger.info("这是INFO级日志（输出到控制台和rotating.log）") advanced_logger.error("这是ERROR级日志（输出到所有三个处理器）") # 4. 日志中包含异常信息 try: 1 / 0 except Exception as e: # exc_info=True 会自动记录异常堆栈信息 logger.error("执行除法运算出错", exc_info=True) # 5. 日志过滤（自定义过滤规则） class LevelFilter(logging.Filter): def __init__(self, min_level, max_level): self.min_level = min_level self.max_level = max_level def filter(self, record): return self.min_level <= record.levelno <= self.max_level # 给控制台处理器添加过滤（仅输出WARNING和ERROR级别） filter = LevelFilter(logging.WARNING, logging.ERROR) console_handler.addFilter(filter) advanced_logger.warning("过滤后：这是WARNING级日志（会输出）") advanced_logger.info("过滤后：这是INFO级日志（不会输出）") ```1. 程序调试（记录程序运行过程中的变量值、执行流程，替代print语句）；2. 运行监控（记录程序的关键操作、性能指标，监控程序运行状态）；3. 问题排查（记录错误信息、异常堆栈，便于后续定位问题）；4. 安全审计（记录用户操作、敏感操作，用于安全追溯）；5. 大规模程序日志管理（如分布式系统、长期运行的服务程序，需要日志轮转、分级输出）；6. 多环境日志配置（开发环境输出详细DEBUG日志，生产环境仅输出ERROR及以上日志）1. 核心组件：Logger（日志器，程序入口，负责产生日志）；Handler（处理器，负责将日志输出到指定目标，如控制台、文件）；Formatter（格式化器，定义日志的输出格式）；Filter（过滤器，控制哪些日志可以被输出）；2. 日志级别：从低到高为DEBUG（调试信息）、INFO（正常信息）、WARNING（警告）、ERROR（错误）、CRITICAL（严重错误）；通过设置级别，可控制输出的日志详细程度；3. 日志轮转：RotatingFileHandler（按文件大小轮转，避免单个日志文件过大）；TimedRotatingFileHandler（按时间轮转，如按天、按时）；4. 格式化参数：常用参数包括%(asctime)s（日志时间）、%(name)s（日志器名称）、%(levelname)s（日志级别）、%(message)s（日志消息）、%(filename)s（文件名）、%(lineno)d（行号）；5. 最佳实践：每个模块使用logging.getLogger(__name__)获取日志器（基于模块名的层级日志器）；避免使用basicConfig()在多模块场景下的冲突；生产环境开启日志轮转，避免日志文件耗尽磁盘空间；敏感信息（如密码）需脱敏后再记录；6. 与print的区别：print仅输出到控制台，无法控制级别、格式和输出目标；logging支持多目标输出、级别控制、持久化、异常堆栈记录等，功能更强大；7. 扩展：支持输出日志到网络（如SocketHandler）、邮件（SMTPHandler）、数据库等；支持自定义Handler实现特殊输出需求；可结合ELK栈（Elasticsearch、Logstash、Kibana）实现大规模日志分析。
os（操作系统接口模块）Python标准库模块，提供与操作系统交互的功能，包括文件和目录操作、进程管理、环境变量获取、路径处理等，屏蔽了不同操作系统（Windows、Linux、macOS）的差异，实现跨平台兼容```python # 1. 导入os模块 import os # 2. 路径相关操作 # 获取当前工作目录 current_dir = os.getcwd() print("当前工作目录：", current_dir) # 拼接路径（跨平台兼容） file_path = os.path.join(current_dir, "test.txt") print("拼接的文件路径：", file_path) # 拆分路径 dir_name, file_name = os.path.split(file_path) print("目录名：", dir_name) print("文件名：", file_name) # 获取文件扩展名 file_base, file_ext = os.path.splitext(file_name) print("文件主名：", file_base) print("文件扩展名：", file_ext) # 判断路径是否存在 print("路径是否存在：", os.path.exists(file_path)) # 3. 文件和目录操作 # 创建目录（单层） os.makedirs("test_dir", exist_ok=True) # exist_ok=True：目录存在时不报错 # 创建文件（空白文件） with open(os.path.join("test_dir", "test.txt"), "w") as f: f.write("测试文件") # 列出目录下的内容 print("目录内容：", os.listdir("test_dir")) # 删除文件 os.remove(os.path.join("test_dir", "test.txt")) # 删除目录（空目录） os.rmdir("test_dir") # 4. 环境变量操作 # 获取环境变量 path_env = os.getenv("PATH") print("PATH环境变量：", path_env) # 设置环境变量（仅当前进程有效） os.environ["MY_ENV"] = "test_value" print("自定义环境变量MY_ENV：", os.getenv("MY_ENV")) # 5. 进程管理 # 执行系统命令（返回命令输出） if os.name == "posix": # Linux/macOS result = os.popen("ls -l").read() elif os.name == "nt": # Windows result = os.popen("dir").read() print("系统命令输出：", result) # 6. 其他常用功能 # 获取当前进程ID pid = os.getpid() print("当前进程ID：", pid) # 获取父进程ID ppid = os.getppid() print("父进程ID：", ppid) # 判断是否为文件/目录 test_path = current_dir print("是否为文件：", os.path.isfile(test_path)) print("是否为目录：", os.path.isdir(test_path)) ```1. 文件和目录管理（创建、删除、重命名、遍历目录）；2. 路径处理（跨平台路径拼接、拆分、判断）；3. 环境变量操作（获取、设置系统环境变量）；4. 进程控制（执行系统命令、获取进程信息）；5. 跨平台适配（编写兼容不同操作系统的代码）；6. 批量文件处理（遍历目录下的文件进行批量操作）1. 核心子模块：os.path（路径处理核心，提供大量路径相关函数）、os.environ（环境变量字典，可直接操作）；2. 跨平台兼容性：os模块的函数会自动适配不同操作系统，如os.path.join()在Windows上使用“\”，在Linux/macOS上使用“/”；os.name可判断操作系统类型（nt→Windows，posix→Linux/macOS）；3. 路径处理推荐：Python 3.4+推荐使用pathlib模块（面向对象的路径处理），功能更强大，语法更简洁；os.path模块是传统的函数式路径处理方式；4. 进程相关注意：os.system()执行系统命令会阻塞当前进程，返回命令退出码；os.popen()执行命令并返回文件对象，可读取命令输出；更强大的进程管理推荐使用subprocess模块；5. 文件操作权限：在Linux/macOS上，os模块的文件操作受文件权限限制，需确保当前用户有对应的权限；Windows上受用户账户控制（UAC）限制；6. 常用函数分类：路径处理（os.path.join、os.path.exists、os.path.isfile等）、目录操作（os.makedirs、os.rmdir、os.listdir等）、文件操作（os.remove、os.rename等）、环境变量（os.getenv、os.environ）、进程信息（os.getpid、os.getppid）；7. 注意事项：使用os.makedirs()创建多层目录时，需指定exist_ok=True避免目录已存在时报错；删除目录前需确保目录为空，否则os.rmdir()会报错；执行系统命令时需注意安全，避免注入攻击（尤其是命令中包含用户输入时）
pass语句（空语句）Python中的空语句，仅作为语法占位符，执行时不做任何操作。当语法要求必须有代码块（如if、for、函数、类定义），但暂时不需要实现具体逻辑时，可用pass语句填充，避免语法错误。```python # 1. 条件判断中的pass（暂时不实现某个分支逻辑） score = 75 if score >= 90: print("优秀") elif score >= 60: pass # 及格分支暂时不实现，用pass占位 else: print("不及格") # 2. 循环中的pass（暂时不实现循环体逻辑） # 遍历列表但暂时不处理元素 lst = [1, 2, 3, 4] for item in lst: pass # 后续补充处理逻辑 # 无限循环占位（后续补充终止条件和逻辑） while True: pass # 3. 函数定义中的pass（暂时不实现函数功能） def calculate_sum(a, b): pass # 后续补充求和逻辑 # 现在调用函数不会报错，但无返回值（返回None） print(calculate_sum(10, 20)) # None # 4. 类定义中的pass（暂时不实现类的属性和方法） class Person: pass # 后续补充__init__、方法等 # 实例化类不会报错 p = Person() print(p) # <__main__.Person object at 0x0000021F7A8D7D90> # 5. 异常处理中的pass（捕获异常后不做处理） try: 1 / 0 # 会抛出ZeroDivisionError异常 except ZeroDivisionError: pass # 捕获异常后不处理，程序继续执行 print("程序继续运行...") # 会正常输出 # 6. 占位符的实际应用（项目开发中的TODO标记） def process_data(data): # TODO：后续实现数据清洗、转换逻辑 pass class OrderSystem: def create_order(self): # TODO：实现创建订单逻辑 pass def cancel_order(self): # TODO：实现取消订单逻辑 pass ```1. 项目开发占位（先搭建代码框架，后续补充具体逻辑，如函数、类、分支结构的占位）；2. 语法错误避免（当语法要求必须有代码块时，用pass填充空代码块）；3. 异常静默处理（捕获异常后不做任何操作，让程序继续运行，需谨慎使用）；4. 测试代码框架（快速搭建代码结构，验证语法正确性，无需实现具体功能）；5. 临时注释替代（当需要临时禁用某个代码块时，用pass替代注释，避免注释过多导致的混乱）1. 核心作用：语法占位，无实际执行逻辑；2. 与注释的区别：注释是给开发者看的，解释器忽略；pass是合法的Python语句，解释器会执行（但不做任何操作）；3. 谨慎使用场景：异常处理中用pass会“静默”异常，可能掩盖程序问题，仅在明确不需要处理异常时使用（如忽略特定的非致命异常）；4. 代码规范：使用pass时，建议添加TODO注释，明确后续需要补充的逻辑，避免遗忘；5. 替代方案：空代码块也可用...（省略号）占位（Python 3+支持），功能与pass类似，但pass更规范、可读性更强；6. 执行效率：pass语句执行效率极高，几乎不占用资源；7. 常见误区：认为pass是“空操作”就可以随意使用，忽略了代码的可维护性；正确用法是仅作为临时占位，后续必须补充具体逻辑（除明确的静默异常场景外）。
pathlib（路径处理模块）Python 3.4+引入的标准库模块，提供面向对象的路径处理方式，替代传统的os.path模块，将路径视为对象，支持链式调用，语法更简洁直观，且原生支持跨平台路径处理```python # 1. 导入Path类 from pathlib import Path # 2. 路径对象初始化 # 当前工作目录 current_dir = Path.cwd() print("当前工作目录：", current_dir) # 绝对路径初始化 abs_path = Path("/home/user/test.txt") # Linux/macOS # abs_path = Path("C:\\Users\\user\\test.txt") # Windows print("绝对路径：", abs_path) # 相对路径初始化 rel_path = Path("data", "test.txt") # 相对路径拼接（无需os.path.join） print("相对路径：", rel_path) # 3. 路径拼接与访问 # 链式拼接（更直观） file_path = current_dir / "data" / "test.txt" # 使用/运算符拼接 print("拼接后的路径：", file_path) # 访问路径组成部分 print("文件名：", file_path.name) print("文件主名：", file_path.stem) print("文件扩展名：", file_path.suffix) print("父目录：", file_path.parent) print("绝对路径：", file_path.absolute()) # 4. 文件和目录操作 # 创建目录（多层，exist_ok=True避免报错） dir_path = current_dir / "new_dir" / "sub_dir" dir_path.mkdir(parents=True, exist_ok=True) # 创建文件 file_path = dir_path / "test.txt" file_path.touch() # 创建空白文件 file_path.write_text("Hello pathlib!", encoding="utf-8") # 写入文本 # 读取文件 content = file_path.read_text(encoding="utf-8") print("文件内容：", content) # 列出目录下的内容 print("目录内容：", list(dir_path.iterdir())) # iterdir()返回迭代器 # 遍历目录下的所有txt文件（递归） txt_files = list(current_dir.glob("**/*.txt")) # glob()支持通配符，**表示递归 print("所有txt文件：", txt_files) # 删除文件 file_path.unlink() # 类似os.remove() # 删除目录（空目录） dir_path.rmdir() dir_path.parent.rmdir() # 删除父目录（需为空） # 5. 路径判断 print("路径是否存在：", file_path.exists()) print("是否为文件：", file_path.is_file()) print("是否为目录：", file_path.is_dir()) print("是否为绝对路径：", file_path.is_absolute()) # 6. 路径转换 # 转换为字符串 str_path = str(file_path) print("转换为字符串：", str_path, type(str_path)) # 转换为os.path兼容的路径 os_path = file_path.as_posix() # 转换为POSIX格式（/分隔） print("POSIX格式路径：", os_path) ```1. 跨平台路径处理（替代os.path，适配Windows、Linux、macOS）；2. 文件和目录的创建、删除、读写操作；3. 目录遍历与文件查找（支持通配符和递归遍历）；4. 路径组成部分的访问（文件名、扩展名、父目录等）；5. 任何需要简洁直观路径操作的场景（替代繁琐的os.path函数组合）1. 核心优势：面向对象设计，路径是对象，支持链式调用，语法更简洁；原生支持跨平台，无需担心路径分隔符差异；集成了os.path的所有功能，且功能更强大；2. 核心类：Path（抽象基类），WindowsPath（Windows系统实现）、PosixPath（Linux/macOS系统实现），无需手动选择，Path会自动适配当前系统；3. 与os.path的对比：os.path是函数式接口，需组合多个函数完成复杂操作；pathlib是面向对象接口，一个路径对象调用多个方法即可完成操作，代码更易读易维护；4. 关键方法：路径拼接（/运算符）、目录创建（mkdir()）、文件创建（touch()）、文件读写（read_text()、write_text()、read_bytes()、write_bytes()）、目录遍历（iterdir()、glob()）、路径判断（exists()、is_file()等）；5. 高级功能：glob()方法支持通配符查找文件（如*.txt、**/*.csv），**表示递归遍历子目录；支持路径的比较（==运算符，判断路径是否相同）；6. 兼容性：pathlib是Python 3.4+新增，若需兼容Python 2.x，需使用os.path；在Python 3.x项目中，推荐优先使用pathlib；7. 注意事项：mkdir()创建多层目录时需指定parents=True；rmdir()只能删除空目录，删除非空目录需先删除目录内的文件；read_text()/write_text()适用于文本文件，二进制文件使用read_bytes()/write_bytes()；glob()返回的是生成器，可通过list()转换为列表，适合处理大量文件时节省内存
property（属性装饰器）Python内置装饰器，用于将类的方法转换为属性，可实现属性的getter、setter、deleter方法，隐藏属性的访问细节，实现数据封装和权限控制```python # 1. 基本用法（getter方法） class Person: def __init__(self, name): self._name = name # 私有属性（约定俗成，单下划线） @property def name(self): """获取姓名""" return self._name p = Person("张三") print(p.name) # 张三（直接访问属性，而非调用方法） # p.name = "李四" # 报错：can't set attribute（无setter方法） # 2. 完整用法（getter、setter、deleter） class Person: def __init__(self, age): self._age = age @property def age(self): """获取年龄""" return self._age @age.setter def age(self, value): """设置年龄（校验合法性）""" if not isinstance(value, int) or value < 0 or value > 150: raise ValueError("年龄必须是0-150的整数") self._age = value @age.deleter def age(self): """删除年龄属性""" del self._age p = Person(28) print(p.age) # 28 p.age = 30 # 调用setter方法设置值 print(p.age) # 30 # p.age = 200 # 抛出ValueError：年龄必须是0-150的整数 del p.age # 调用deleter方法删除属性 # print(p.age) # 报错：'Person' object has no attribute '_age' # 3. 只读属性（仅定义getter） class Rectangle: def __init__(self, width, height): self._width = width self._height = height @property def area(self): """计算面积（只读属性）""" return self._width * self._height r = Rectangle(3, 4) print(r.area) # 12 # r.area = 20 # 报错：can't set attribute ```1. 数据封装（隐藏属性的访问细节，仅暴露属性接口）；2. 属性权限控制（如只读、只写、读写，及值的合法性校验）；3. 计算属性（如面积、周长等动态计算的属性）；4. 兼容性维护（原通过方法访问的逻辑，改为属性访问，不影响外部调用）1. 本质：将方法转换为描述符（descriptor），实现属性的访问控制；2. 命名约定：私有属性通常用单下划线（_attr）或双下划线（__attr，名称修饰）表示，避免直接访问；3. 与普通属性的区别：property属性可实现复杂的访问逻辑，普通属性直接访问变量；4. 装饰器顺序：@property必须在@attr.setter、@attr.deleter之前；5. 另一种实现方式：通过property()函数，如name = property(get_name, set_name, del_name, "文档字符串")；6. 应用场景：面向对象编程中的数据封装，类的属性管理，确保数据的合法性和安全性
pydantic（数据验证库）Python常用的第三方数据验证库，通过定义模型类并添加类型注解，自动实现数据类型校验、值范围校验、默认值设置等功能，支持JSON序列化/反序列化，广泛用于API开发、配置解析等场景```python # 1. 安装：pip install pydantic from pydantic import BaseModel, Field, ValidationError # 2. 基本数据模型定义 class User(BaseModel): name: str age: int = Field(..., ge=0, le=150, description="年龄必须在0-150之间") # 必选字段，范围限制 email: str = Field(..., regex=r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$") # 邮箱格式校验 gender: str = Field(default="未知", pattern=r"^男|女|未知$") # 可选字段，值限制 # 3. 数据验证（正确数据） user1 = User( name="张三", age=28, email="zhangsan@example.com", gender="男" ) print(user1.model_dump()) # 转换为字典：{'name': '张三', 'age': 28, 'email': 'zhangsan@example.com', 'gender': '男'} print(user1.model_dump_json()) # 转换为JSON字符串 # 4. 数据验证（错误数据） try: user2 = User( name="李四", age=200, # 年龄超出范围 email="lisi.example.com", # 邮箱格式错误 gender="保密" # 性别值不合法 ) except ValidationError as e: print(e) # 输出包含详细错误信息： # 1 validation error for User # age # Input should be less than or equal to 150 [type=less_than_or_equal, input_value=200, input_type=int] # email # String should match pattern '^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$' [type=string_pattern_mismatch, input_value='lisi.example.com', input_type=str] # gender # String should match pattern '^男|女|未知$' [type=string_pattern_mismatch, input_value='保密', input_type=str] # 5. 嵌套模型 class Address(BaseModel): province: str city: str class UserWithAddress(User): address: Address # 嵌套Address模型 user3 = UserWithAddress( name="王五", age=30, email="wangwu@example.com", address=Address(province="广东", city="深圳") ) print(user3.address.city) # 深圳 # 6. 配置解析 class Settings(BaseModel): database_url: str timeout: int = 30 debug: bool = False class Config: env_file = ".env" # 从.env文件加载配置 # .env文件内容： # database_url=mysql://localhost:3306/test # timeout=60 # debug=True settings = Settings() print(settings.database_url) # mysql://localhost:3306/test print(settings.timeout) # 60 print(settings.debug) # True ```1. API开发（请求参数验证、响应数据格式化）；2. 配置文件解析（从.env、JSON等文件加载配置并验证）；3. 数据接口交互（JSON数据的序列化/反序列化与验证）；4. 表单数据验证（Web开发中的用户输入验证）；5. 数据清洗与预处理（确保输入数据符合业务规则）1. 核心优势：基于类型注解的声明式验证，代码简洁直观；自动生成详细的错误信息，便于调试；支持嵌套模型、复杂数据类型（如日期、枚举）；内置JSON序列化/反序列化功能；2. 核心组件：BaseModel（所有数据模型的基类）、Field（字段配置，用于设置默认值、校验规则等）、ValidationError（验证失败时抛出的异常）；3. 常用校验规则：类型校验（自动根据注解校验）、数值范围（ge/lte/gt/lt）、字符串格式（regex/pattern）、值集合（enum）、必填/可选字段控制等；4. 扩展功能：支持从环境变量、配置文件加载数据；支持自定义校验函数；支持数据转换（如字符串转日期、整数转布尔值）；5. 与dataclasses的区别：dataclasses主要用于简化数据类定义，不提供数据验证；pydantic专注于数据验证，同时也简化了数据类定义，功能更强大；6. 应用生态：广泛用于FastAPI、Starlette等现代Python Web框架，作为请求/响应模型的默认选择；7. 注意事项：pydantic是第三方库，需手动安装；类型注解不仅是提示，还用于实际验证，需确保注解准确；复杂场景下可自定义校验逻辑，满足特殊业务需求
PyYAML（YAML解析模块）Python第三方库，用于解析和生成YAML格式文件，支持复杂数据结构（嵌套字典、列表、锚点引用等），语法简洁直观，可读性强，相比INI格式更适合存储层级复杂的配置，广泛用于配置文件、数据序列化等场景。```python # 1. 安装：pip install pyyaml import yaml # 2. 生成并写入YAML文件 # 定义复杂数据结构（支持嵌套、列表、多种数据类型） config_data = { "database": { "host": "127.0.0.1", "port": 3306, "credentials": { "username": "admin", "password": "SecurePass123!" }, "db_name": "project_db", "charset": "utf8mb4", "connect_options": ["timeout=10", "pool_size=20"] }, "application": { "debug_mode": True, "log_level": "INFO", "max_requests": 1000, "paths": { "static": "./static", "templates": "./templates" }, "features": ["api", "admin", "user"] }, "third_party": { "api_key": "sk_8f7d6c5b4a3b2c1d", "api_url": "https://api.example.com/v1", "timeout": 30, "retry": {"count": 3, "delay": 2} } } # 写入YAML文件（默认流式风格，可指定为块风格） with open("app_config.yaml", "w", encoding="utf-8") as f: yaml.dump( config_data, f, default_flow_style=False, # 块风格（更易读） sort_keys=False, # 保留键的原始顺序 allow_unicode=True # 支持中文 ) print("YAML配置文件 app_config.yaml 创建完成") # 3. 读取YAML文件 with open("app_config.yaml", "r", encoding="utf-8") as f: # 解析YAML内容为Python字典 loaded_config = yaml.safe_load(f) # 推荐使用safe_load，避免安全风险 # 访问读取的配置 print("数据库地址：", loaded_config["database"]["host"]) print("调试模式：", loaded_config["application"]["debug_mode"]) print("第三方API重试次数：", loaded_config["third_party"]["retry"]["count"]) print("应用支持特性：", loaded_config["application"]["features"]) # 4. YAML特殊特性：锚点与引用（复用配置） yaml_with_anchor = """ base_config: &base timeout: 30 retry_count: 3 api1: <<: *base # 引用base_config的配置 url: "https://api1.example.com" api2: <<: *base # 复用base配置 url: "https://api2.example.com" timeout: 60 # 覆盖base的timeout配置 """ # 解析含锚点的YAML anchor_config = yaml.safe_load(yaml_with_anchor) print("API1配置（复用base）：", anchor_config["api1"]) print("API2配置（复用+覆盖）：", anchor_config["api2"]) # 5. 生成YAML字符串（而非文件） simple_data = {"name": "张三", "age": 28, "hobbies": ["编程", "阅读"]} yaml_str = yaml.dump(simple_data, default_flow_style=False, allow_unicode=True) print("生成的YAML字符串：") print(yaml_str) # 6. 安全注意事项：避免使用load()，优先safe_load() # yaml.load(f) # 不安全，可能执行恶意代码 # yaml.safe_load(f) # 安全，仅解析标准YAML数据结构 ```1. 复杂配置文件管理（如包含嵌套层级、列表、字典的多维度配置）；2. 容器化部署配置（如Docker、K8s的YAML配置文件生成与解析）；3. 数据序列化与交换（YAML格式可读性强，适合人类编辑和跨系统数据交换）；4. 测试用例数据存储（如复杂测试场景的输入输出数据，用YAML组织更清晰）；5. 替代INI格式的高级配置场景（需要锚点复用、复杂数据类型的配置）；6. 机器学习项目配置（如模型参数、训练超参数的层级化配置）1. 核心优势：支持嵌套字典、列表等复杂数据结构；语法简洁无冗余（相比JSON无需引号和逗号）；支持锚点（&）和引用（*）实现配置复用；保留键的原始顺序（dump时指定sort_keys=False）；2. 安全建议：永远使用safe_load()和safe_dump()方法，避免使用load()和dump()（后者可能执行恶意代码，存在安全风险）；3. YAML语法要点：键值对用冒号分隔（key: value）；列表项以短横线开头（- item）；缩进表示层级（建议2个空格，不支持制表符）；锚点&定义复用配置，*引用锚点配置，<<: *anchor实现配置合并；4. 与JSON/INI的对比：JSON格式严谨但冗余，适合机器交互；INI格式简单但不支持复杂嵌套；YAML兼顾可读性和复杂结构支持，适合人类编辑的配置场景；5. 编码处理：处理中文时需指定encoding="utf-8"，dump时设置allow_unicode=True；6. 扩展功能：支持自定义数据类型的序列化/反序列化（通过添加构造器和表示器）；支持YAML 1.2标准；7. 注意事项：PyYAML是第三方库，需手动安装；不同语言的YAML解析器对语法细节可能有差异，编写时需遵循通用规范。
random（随机数模块）Python标准库模块，提供各种随机数生成功能，支持生成整数、浮点数随机数，随机打乱序列、随机选择元素等，核心基于伪随机数生成器，可通过种子（seed）控制随机序列的重复性```python # 1. 导入random模块 import random # 2. 生成基础随机数 # 生成[0.0, 1.0)之间的浮点数 rand_float = random.random() print("0-1浮点数随机数：", rand_float) # 生成[a, b]之间的整数 rand_int = random.randint(1, 10) # 1到10（包含两端） print("1-10整数随机数：", rand_int) # 生成[a, b)之间的整数（步长为step） rand_range = random.randrange(0, 10, 2) # 0-10间的偶数（步长2） print("0-10偶数随机数：", rand_range) # 生成[a, b]之间的浮点数 rand_uniform = random.uniform(2.5, 5.5) print("2.5-5.5浮点数随机数：", rand_uniform) # 3. 随机操作序列 lst = [1, 2, 3, 4, 5] # 随机选择一个元素 choice_val = random.choice(lst) print("随机选择一个元素：", choice_val) # 随机选择k个不重复元素（无放回抽样） sample_vals = random.sample(lst, 2) print("随机选择2个不重复元素：", sample_vals) # 随机选择k个元素（可重复，有放回抽样） choices_vals = random.choices(lst, k=3) print("随机选择3个可重复元素：", choices_vals) # 随机打乱序列（原地修改） random.shuffle(lst) print("打乱后的列表：", lst) # 4. 控制随机序列（种子） # 设置种子（相同种子生成相同的随机序列） random.seed(10) print("种子10生成的随机数1：", random.random()) print("种子10生成的随机数2：", random.randint(1, 10)) # 重新设置相同种子，生成相同序列 random.seed(10) print("重新设置种子10生成的随机数1：", random.random()) print("重新设置种子10生成的随机数2：", random.randint(1, 10)) # 5. 概率分布随机数 # 生成正态分布（均值0，标准差1）的随机数 normal_rand = random.normalvariate(0, 1) print("正态分布随机数：", normal_rand) # 生成均匀分布的随机数（同uniform，更贴合分布概念） uniform_rand = random.uniform(1, 3) print("均匀分布随机数：", uniform_rand) ```1. 数据随机抽样（如从数据集选择部分样本进行测试）；2. 随机排序（如打乱列表顺序进行随机展示）；3. 模拟场景（如游戏中的随机事件、蒙特卡洛模拟）；4. 密码/验证码生成（如生成随机字符串验证码）；5. 测试用例设计（如生成随机测试数据验证程序稳定性）；6. 随机推荐（如从商品列表中随机推荐几个商品）1. 伪随机数特性：random模块生成的是伪随机数（基于数学算法生成，非真正随机），相同种子（seed）会生成相同的随机序列，便于测试复现；2. 核心函数分类：基础随机数（random()、randint()、uniform()）、序列操作（choice()、sample()、shuffle()）、分布随机数（normalvariate()、expovariate()等）；3. 种子设置：seed()函数可接收整数、浮点数、字符串等作为参数，若不设置，默认使用系统时间作为种子；4. 安全注意事项：random模块生成的随机数不适合加密场景（如密码生成），加密级随机数需使用secrets模块；5. 序列操作区别：sample()是无放回抽样（元素不重复），choices()是有放回抽样（元素可重复）；shuffle()原地修改序列，返回None；6. 分布随机数：支持多种概率分布（正态分布、指数分布、泊松分布等），适用于统计模拟场景；7. 注意事项：shuffle()仅能打乱可变序列（如列表），不可变序列（如元组）需先转换为列表再打乱
requests（HTTP请求库）Python最常用的第三方HTTP请求库，提供简洁直观的API，支持HTTP/HTTPS的GET、POST、PUT、DELETE等多种请求方法，支持会话保持、文件上传下载、cookie管理、代理设置等功能，简化网络请求开发```python # 1. 安装：pip install requests import requests # 2. 基本GET请求 response = requests.get("https://httpbin.org/get") print("响应状态码：", response.status_code) # 200（成功） print("响应头：", response.headers) print("响应文本：", response.text) # 字符串形式的响应内容 print("响应JSON：", response.json()) # 自动解析JSON响应（需响应为JSON格式） # 3. GET请求带参数 params = { "name": "张三", "age": 28 } response = requests.get("https://httpbin.org/get", params=params) print("请求URL：", response.url) # https://httpbin.org/get?name=%E5%BC%A0%E4%B8%89&age=28（自动URL编码） # 4. POST请求（表单数据） data = { "username": "test", "password": "123456" } response = requests.post("https://httpbin.org/post", data=data) print(response.json()) # 5. POST请求（JSON数据） json_data = { "title": "Python请求", "content": "使用requests库发送JSON请求" } response = requests.post("https://httpbin.org/post", json=json_data) # 自动设置Content-Type: application/json print(response.json()) # 6. 会话保持（维持cookie） session = requests.Session() # 第一次请求（登录，获取cookie） session.post("https://httpbin.org/post", data={"username": "test"}) # 第二次请求（自动携带cookie） response = session.get("https://httpbin.org/cookies") print("当前cookie：", response.json()) # 7. 文件上传 files = { "file": open("test.txt", "rb") # 打开文件为二进制模式 } response = requests.post("https://httpbin.org/post", files=files) print(response.json()) files["file"].close() # 关闭文件 # 8. 异常处理 try: response = requests.get("https://httpbin.org/status/404", timeout=5) # 设置超时时间5秒 response.raise_for_status() # 若状态码为4xx/5xx，抛出HTTPError except requests.exceptions.HTTPError as e: print("HTTP错误：", e) except requests.exceptions.Timeout as e: print("超时错误：", e) except requests.exceptions.RequestException as e: print("请求错误：", e) ```1. 网络API调用（如调用第三方接口、自己开发的后端API）；2. 网页数据爬取（获取网页内容进行分析）；3. 文件上传下载（如向服务器上传文件、从服务器下载文件）；4. 模拟登录与会话保持（如模拟用户登录后访问需要权限的页面）；5. 自动化测试（测试HTTP接口的可用性与正确性）；6. 代理请求（通过代理服务器访问网络）1. 核心功能：支持所有HTTP方法（GET、POST、PUT、DELETE、HEAD、OPTIONS等）；自动处理URL编码、cookie管理、会话保持；支持请求超时设置、SSL证书验证；内置JSON解析功能；2. 响应对象属性：status_code（响应状态码）、headers（响应头）、text（字符串响应内容）、content（二进制响应内容）、json()（解析JSON响应）、cookies（响应的cookie）；3. 会话机制：Session类用于维持会话状态，多个请求可共享cookie、headers等信息，避免重复设置，提升效率；4. 高级特性：支持文件上传（通过files参数）、代理设置（proxies参数）、自定义请求头（headers参数）、SSL证书验证控制（verify参数）；5. 异常处理：requests定义了多种异常类型（如HTTPError、Timeout、ConnectionError等），可通过try-except捕获并处理；6. 与urllib的区别：urllib是Python标准库模块，API繁琐；requests是第三方库，API简洁直观，功能更强大，是网络请求的首选；7. 注意事项：requests是第三方库，需手动安装；发送请求时建议设置timeout参数，避免程序无限等待；处理二进制文件（如图片、视频）时使用content属性，处理文本内容时使用text属性；爬取网页时需遵守网站的robots协议，避免非法爬取
secrets（安全随机数模块）Python 3.6+引入的标准库模块，提供加密级安全的随机数生成功能，用于生成安全相关的随机数据（如密码、验证码、令牌等），底层基于操作系统的安全随机数生成器，避免了random模块伪随机数的安全隐患```python # 1. 导入secrets模块 import secrets # 2. 生成安全随机整数 # 生成[0, n)之间的安全随机整数 rand_int = secrets.randbelow(100) # 0到99之间的整数 print("0-99安全随机整数：", rand_int) # 生成[a, b]之间的安全随机整数 rand_int_range = secrets.randbits(8) # 生成8位随机整数（0-255） print("8位安全随机整数：", rand_int_range) # 3. 生成安全随机浮点数（间接实现） # 生成[0.0, 1.0)之间的安全随机浮点数 rand_float = secrets.randbelow(10**18) / 10**18 print("0-1安全随机浮点数：", rand_float) # 4. 安全操作序列 lst = ["a", "b", "c", "d", "e"] # 安全随机选择一个元素 choice_val = secrets.choice(lst) print("安全随机选择一个元素：", choice_val) # 安全随机选择k个不重复元素（无放回抽样） sample_vals = secrets.sample(lst, 2) print("安全随机选择2个不重复元素：", sample_vals) # 5. 生成安全随机字符串（常用场景） import string # 生成指定长度的随机密码（包含大小写字母、数字、特殊字符） def generate_secure_password(length=12): # 定义密码字符集 chars = string.ascii_letters + string.digits + string.punctuation # 确保密码包含至少一种每种类型的字符 password = [ secrets.choice(string.ascii_uppercase), secrets.choice(string.ascii_lowercase), secrets.choice(string.digits), secrets.choice(string.punctuation) ] # 填充剩余长度 password += [secrets.choice(chars) for _ in range(length - 4)] # 打乱顺序 secrets.SystemRandom().shuffle(password) return ''.join(password) secure_password = generate_secure_password(16) print("生成的安全密码：", secure_password) # 6. 生成安全令牌（用于身份验证） token_hex = secrets.token_hex(16) # 16字节，生成32位十六进制令牌 print("16字节十六进制令牌：", token_hex) token_urlsafe = secrets.token_urlsafe(16) # URL安全的Base64编码令牌 print("URL安全令牌：", token_urlsafe) # 7. 验证随机数的安全性（简单判断） print("随机数是否足够安全（熵值）：", secrets.compare_digest(token_hex, token_hex)) # True ```1. 安全密码生成（如用户注册时生成初始密码、密码重置）；2. 身份验证令牌（如登录令牌、API接口令牌）；3. 验证码生成（如短信验证码、邮箱验证码）；4. 加密密钥生成（如生成对称加密、非对称加密的密钥）；5. 安全抽样（如敏感数据的随机抽样，需保证不可预测性）；6. 任何需要高安全性随机数据的场景（替代random模块的安全隐患）1. 核心优势：基于操作系统的安全随机数生成器（如Windows的CryptGenRandom、Linux的/dev/urandom），生成的随机数不可预测、不可重现，适合加密场景；2. 与random模块的区别：random模块生成伪随机数，适合非安全场景；secrets模块生成真随机数（加密级），适合安全场景；3. 核心函数：randbelow()（生成指定范围整数）、randbits()（生成指定位数整数）、choice()（随机选择元素）、sample()（随机抽样）、token_hex()（生成十六进制令牌）、token_urlsafe()（生成URL安全令牌）；4. 安全字符串生成：结合string模块的字符集（ascii_letters、digits、punctuation），可生成符合安全要求的密码/令牌；5. compare_digest()函数：安全地比较两个字符串（避免时序攻击），返回布尔值，适合验证令牌、密码等敏感数据；6. 注意事项：secrets模块不支持设置种子（确保随机性不可控）；token_hex(n)生成的字符串长度为2n（每个字节对应两个十六进制字符）；token_urlsafe(n)生成的字符串长度约为1.33n（Base64编码）；7. 适用版本：Python 3.6及以上，若需兼容低版本，可使用os.urandom()函数替代（功能有限）
set（集合）Python内置的无序不重复元素集合，基于哈希表实现，支持集合运算（交集、并集、差集等），主要用于去重和关系测试，元素必须是不可变类型```python # 1. 集合初始化 set1 = {1, 2, 3, 3} # 直接初始化，自动去重 set2 = set([1, 2, 3, 3]) # 通过set()构造函数 set3 = set(range(5)) # 从可迭代对象创建 print(set1) # {1, 2, 3} print(set2) # {1, 2, 3} print(set3) # {0, 1, 2, 3, 4} # 2. 核心操作 s = {1, 2, 3} s.add(4) # 添加元素 s.remove(2) # 删除元素，不存在则报错 s.discard(5) # 删除元素，不存在不报错 print(s) # {1, 3, 4} # 3. 集合运算 a = {1, 2, 3} b = {3, 4, 5} print(a & b) # {3}（交集） print(a | b) # {1, 2, 3, 4, 5}（并集） print(a - b) # {1, 2}（差集） print(a ^ b) # {1, 2, 4, 5}（对称差集） # 4. 关系测试 print(3 in a) # True（判断元素是否存在） print(a.issubset(b)) # False（判断a是否是b的子集） ```1. 数据去重场景（如列表去重）；2. 集合关系测试（如判断两个数据集的交集、并集）；3. 元素存在性判断（快速判断元素是否在集合中）；4. 过滤重复数据（如批量数据处理中的重复筛选）1. 底层实现：哈希表，与字典类似，存储的是键（无值）；2. 元素要求：必须是不可变类型，可变类型（如列表）不能作为集合元素；3. 时间复杂度：增删改查及存在性判断均为O(1)；4. 与列表的区别：集合无序不重复，列表有序可重复；5. 常用方法：add()、remove()、discard()、intersection()（交集）、union()（并集）等；6. 不可变集合：frozenset，元素不可修改，可作为字典的键或其他集合的元素
subprocess（子进程管理模块）Python标准库模块，用于创建和管理子进程，执行系统命令或外部程序，支持获取命令输出、控制进程输入输出、等待进程结束、设置超时等功能，替代了旧的os.system()、os.popen()等函数，功能更强大、更安全```python # 1. 导入subprocess模块 import subprocess # 2. 基本用法：执行系统命令（获取返回码） # run()函数是核心函数，返回CompletedProcess对象 result = subprocess.run( ["ls", "-l"], # 命令参数以列表形式传入（推荐，避免shell注入） capture_output=True, # 捕获stdout和stderr text=True, # 将输出转换为字符串（默认是字节串） shell=False, # 不使用shell（推荐，更安全） timeout=5 # 超时时间（秒） ) print("命令返回码：", result.returncode) # 0表示成功 print("标准输出：", result.stdout) print("标准错误：", result.stderr) # Windows系统示例 # result = subprocess.run( # ["dir"], # capture_output=True, # text=True, # shell=True # Windows的dir命令需要shell=True # ) # 3. 执行命令并获取输出（简化方式） # check_output()：执行命令，返回标准输出，若命令失败抛出异常 try: output = subprocess.check_output( ["echo", "Hello subprocess"], text=True, timeout=5 ) print("check_output输出：", output.strip()) except subprocess.CalledProcessError as e: print("命令执行失败：", e.returncode, e.output) # 4. 交互模式：向子进程输入数据 # 执行python命令，交互式输入代码 proc = subprocess.Popen( ["python"], stdin=subprocess.PIPE, # 标准输入 stdout=subprocess.PIPE, # 标准输出 stderr=subprocess.PIPE, # 标准错误 text=True, encoding="utf-8" ) # 向子进程输入代码 input_data = "print('Hello from child process')\nprint(1 + 2)\nexit()" stdout, stderr = proc.communicate(input=input_data, timeout=5) print("子进程输出：", stdout) print("子进程错误：", stderr) print("子进程返回码：", proc.returncode) # 5. 等待进程结束与超时处理 try: result = subprocess.run( ["sleep", "3"], # 睡眠3秒 timeout=2 # 超时2秒 ) except subprocess.TimeoutExpired as e: print("命令超时：", e) # 超时后终止进程 e.process.kill() # 6. 执行外部程序 # 执行Python脚本 result = subprocess.run( ["python", "test_script.py"], capture_output=True, text=True ) print("脚本执行输出：", result.stdout) ```1. 执行系统命令（如ls、dir、rm等）；2. 调用外部程序或脚本（如其他Python脚本、exe程序、Shell脚本）；3. 进程间交互（向子进程输入数据，获取子进程输出）；4. 自动化测试（执行测试用例程序，获取测试结果）；5. 批量任务处理（通过子进程并行执行多个任务）；6. 系统管理脚本（如备份、监控、部署等脚本）1. 核心函数/类：run()（推荐，简化的进程创建函数，适用于大多数场景）、Popen()（底层类，功能更灵活，适用于复杂场景）、check_output()（获取命令输出，命令失败抛出异常）；2. 输入输出控制：capture_output=True（捕获stdout和stderr）、stdin/stdout/stderr参数（指定输入输出流，可重定向到文件或管道）；3. shell参数：shell=True表示通过shell执行命令（可使用shell语法如管道、通配符），但存在安全风险（shell注入），非必要不使用；shell=False（默认）表示直接执行命令，命令参数以列表形式传入，更安全；4. 超时处理：run()和communicate()都支持timeout参数，超时后抛出TimeoutExpired异常，可在异常中终止进程；5. 返回码：returncode=0表示命令执行成功，非0表示失败；check_output()和run(check=True)会在返回码非0时抛出CalledProcessError异常；6. 与os.system()的区别：os.system()仅返回退出码，不捕获输出；subprocess模块功能更强大，支持捕获输出、交互、超时等，是os.system()的替代方案；7. 注意事项：命令参数以列表形式传入（shell=False时），避免因空格、特殊字符导致命令执行错误；处理用户输入的命令参数时，必须避免使用shell=True，防止shell注入攻击；长时间运行的子进程需注意资源释放，避免僵尸进程；在Windows系统中，部分命令（如dir、cd）需要shell=True才能执行
sys（系统模块）Python标准库模块，提供与Python解释器和操作系统交互的核心功能，包括命令行参数获取、标准输入输出控制、模块路径管理、进程退出控制、系统信息获取等，是Python程序访问系统级功能的基础接口。```python # 1. 导入sys模块 import sys # 2. 获取命令行参数（sys.argv） # sys.argv[0] 是脚本名称，后续是传入的参数 print("脚本名称：", sys.argv[0]) print("所有命令行参数：", sys.argv) print("参数个数：", len(sys.argv)) # 示例：若执行 python sys_demo.py --name 张三 28，则输出： # 脚本名称： sys_demo.py # 所有命令行参数： ['sys_demo.py', '--name', '张三', '28'] # 参数个数： 4 # 3. 标准输入输出与错误流控制 # 标准输出（stdout）：打印信息（类似print） sys.stdout.write("通过sys.stdout输出信息\n") # 标准错误（stderr）：输出错误信息 sys.stderr.write("通过sys.stderr输出错误信息\n") # 标准输入（stdin）：读取用户输入 print("请输入内容：", end="") user_input = sys.stdin.readline() # 读取一行输入 print("你输入的内容：", user_input.strip()) # 重定向标准输出（临时将输出写入文件） with open("stdout_redirect.txt", "w", encoding="utf-8") as f: original_stdout = sys.stdout # 保存原始stdout sys.stdout = f # 重定向到文件 print("这段内容会写入文件，不会显示在控制台") sys.stdout = original_stdout # 恢复原始stdout print("恢复后，这段内容显示在控制台") # 4. 模块路径管理（sys.path） print("当前Python模块搜索路径：") for path in sys.path: print(f" - {path}") # 添加自定义模块路径（让Python能找到自定义模块） custom_path = "./my_modules" if custom_path not in sys.path: sys.path.append(custom_path) print(f"\n添加自定义路径后的sys.path：") print(f" ... {custom_path}") # 5. 进程退出控制（sys.exit()） def exit_demo(): print("程序即将退出...") sys.exit(0) # 0 表示正常退出，非0表示异常退出（可传递退出码） print("这行代码不会执行") # exit_demo() # 取消注释可测试退出功能 # 6. 获取系统与解释器信息 print("\nPython解释器版本：", sys.version) print("Python版本信息（元组）：", sys.version_info) # (major, minor, micro, releaselevel, serial) print("操作系统平台：", sys.platform) # win32（Windows）、linux（Linux）、darwin（macOS） print("处理器架构：", sys.maxsize) # 64位系统返回9223372036854775807，32位返回2147483647 print("当前进程ID：", sys.getpid()) print("父进程ID：", sys.getppid()) # 7. 内存使用信息 print("\n内存使用信息：") print("当前进程内存使用（字节）：", sys.getsizeof("test string")) # 获取对象占用内存 # 更详细的内存信息（需导入psutil第三方库） try: import psutil process = psutil.Process(sys.getpid()) mem_info = process.memory_info() print("物理内存使用（MB）：", mem_info.rss / 1024 / 1024) except ImportError: print("需安装psutil库（pip install psutil）获取详细内存信息") # 8. 其他常用功能 # 获取递归深度限制 print("\n默认递归深度限制：", sys.getrecursionlimit()) # 设置递归深度限制（谨慎使用，过深可能导致崩溃） sys.setrecursionlimit(10000) print("修改后的递归深度限制：", sys.getrecursionlimit()) # 检查是否为交互模式 print("是否为交互模式：", sys.flags.interactive) ```1. 命令行参数处理（简单场景下替代argparse，直接解析sys.argv）；2. 标准输入输出重定向（如将程序输出写入文件、从文件读取输入）；3. 自定义模块路径配置（让Python能导入非默认路径下的模块）；4. 程序退出控制（在特定条件下主动终止程序，并返回指定退出码）；5. 系统环境适配（根据sys.platform判断操作系统，编写跨平台代码）；6. 程序调试与监控（获取解释器版本、进程ID、内存使用等信息）；7. 递归深度控制（调整Python默认的递归深度限制，适配深度递归场景）1. 核心属性/函数：sys.argv（命令行参数列表）；sys.stdin/sys.stdout/sys.stderr（标准输入/输出/错误流）；sys.path（模块搜索路径列表）；sys.exit(code)（进程退出，code为退出码）；sys.version（Python解释器版本字符串）；sys.platform（操作系统平台标识）；sys.getpid()（获取当前进程ID）；2. 命令行参数解析：sys.argv是原始参数列表，需手动处理参数解析（如判断参数是否存在、转换参数类型）；复杂场景推荐使用argparse模块；3. 标准流重定向：通过修改sys.stdout/sys.stdin/sys.stderr的值，可将输入输出重定向到文件、网络流等；重定向后需及时恢复原始流，避免影响后续操作；4. 模块路径管理：sys.path的顺序决定了Python导入模块时的搜索优先级；添加自定义路径时，建议使用绝对路径，避免相对路径导致的问题；5. 跨平台适配：通过sys.platform判断操作系统（win32→Windows，linux→Linux，darwin→macOS），可实现不同平台的差异化逻辑（如文件路径分隔符、系统命令执行）；6. 退出码规范：sys.exit(0)表示程序正常退出；非0退出码（如1、2）表示异常退出，不同退出码可代表不同的错误类型，供调用方识别；7. 注意事项：修改sys.path时需谨慎，避免添加恶意路径导致安全风险；调整递归深度限制（sys.setrecursionlimit()）可能导致栈溢出，需结合实际场景合理设置；sys模块的很多功能与操作系统紧密相关，部分功能在不同平台上的表现可能存在差异；8. 扩展：sys模块还提供了sys.modules（已导入的模块字典）、sys.getsizeof(obj)（获取对象内存大小）等功能，可用于模块管理和性能优化。
threading（线程模块）Python标准库核心并发模块，提供线程的创建、管理、同步与通信能力。线程是进程内的轻量级执行单元，共享进程内存空间，切换开销小。适用于I/O密集型任务并发（如网络请求、文件读写），受GIL（全局解释器锁）限制，CPU密集型场景并发效率有限，需配合多进程使用。```python # 1. 导入模块 import threading import time # 2. 两种创建线程的方式 # 方式1：继承Thread类重写run()方法 class TaskThread(threading.Thread): def __init__(self, name, delay): super().__init__(name=name) # 设定线程名称 self.delay = delay # 线程执行的核心逻辑（必须重写） def run(self): print(f"线程[{self.name}]启动，延迟{self.delay}秒执行") time.sleep(self.delay) # 模拟I/O耗时操作 print(f"线程[{self.name}]执行完成") # 方式2：传入目标函数及参数 def task_func(name, delay): print(f"线程[{name}]启动，延迟{self.delay}秒执行") time.sleep(delay) print(f"线程[{name}]执行完成") # 3. 启动并管理线程 if __name__ == "__main__": # 主线程入口（避免多进程场景下重复启动） # 方式1创建线程 thread1 = TaskThread("Thread-1", 2) # 方式2创建线程 thread2 = threading.Thread(target=task_func, args=("Thread-2", 1), name="Thread-2") # 启动线程（调用start()，底层会自动调用run()） thread1.start() thread2.start() # 等待线程执行完成（主线程阻塞，避免主线程提前退出） thread1.join() thread2.join() print("所有子线程执行完毕，主线程结束") # 4. 线程同步：解决共享资源竞争（Lock锁） shared_num = 0 lock = threading.Lock() # 创建互斥锁 def increment(name, times): global shared_num for _ in range(times): lock.acquire() # 获取锁，未获取到则阻塞 try: # 临界区：操作共享资源（确保同一时间只有一个线程执行） shared_num += 1 print(f"线程[{name}] - 当前数值：{shared_num}") finally: lock.release() # 释放锁（无论是否出错都必须释放） # 启动两个线程操作共享变量 thread3 = threading.Thread(target=increment, args=("Thread-3", 10)) thread4 = threading.Thread(target=increment, args=("Thread-4", 10)) thread3.start() thread4.start() thread3.join() thread4.join() print(f"最终共享数值：{shared_num}（预期20）") # 5. 守护线程：主线程结束时自动终止 def daemon_task(): while True: print("守护线程运行中...") time.sleep(1) daemon_thread = threading.Thread(target=daemon_task, daemon=True) daemon_thread.start() time.sleep(3) # 主线程运行3秒后退出，守护线程随之终止 print("主线程退出，守护线程自动终止") ```1. I/O密集型任务并发（如批量网络请求、多文件读写、数据库批量查询）；2. 图形界面（GUI）程序（主线程处理界面交互，子线程处理耗时操作，避免界面卡顿）；3. 后台任务监控（如程序运行时的日志收集、数据同步等后台常驻任务）；4. 多任务协作（如多个线程分工处理不同环节，共同完成复杂任务）；5. 有限资源并发访问（如控制并发访问数据库的连接数，避免资源耗尽）1. 核心组件：Thread（线程类，创建线程的核心）、Lock（互斥锁，解决资源竞争）、RLock（可重入锁，支持同一线程多次获取）、Event（事件通知，实现线程间通信）、Semaphore（信号量，控制并发线程数）；2. GIL限制：Python全局解释器锁导致同一时刻只有一个线程执行Python字节码，CPU密集型任务用threading无法提升效率，需用multiprocessing（多进程）；3. 线程生命周期：创建（Thread实例）→ 启动（start()）→ 运行（run()）→ 阻塞（sleep/wait）→ 结束/终止；4. 守护线程特性：通过daemon=True设置，主线程结束时会自动终止，无需等待；非守护线程（默认）主线程会等待其执行完毕；5. 线程安全：操作共享资源必须用锁保护临界区，否则会出现数据错乱（如计数器累加错误）；6. 避免死锁：多个线程获取锁的顺序需一致，避免相互等待对方释放锁；7. 与多进程区别：线程共享进程内存，开销小、通信快；进程独立内存，开销大、无GIL限制，适合CPU密集型任务。
time（时间处理模块）Python标准库模块，提供时间相关核心功能，支持获取当前时间、时间格式转换（时间戳、结构化时间、字符串时间）、时间延迟、程序执行耗时统计等，适配本地时间与UTC时间，是时间处理的基础模块```python # 1. 导入time模块 import time # 2. 三种时间表示形式及转换 # （1）时间戳：从1970-01-01 00:00:00 UTC到当前的秒数（浮点数） timestamp = time.time() print("当前时间戳：", timestamp) # 示例：1716234567.890123 # （2）结构化时间：time.struct_time对象，含年、月、日等字段 local_struct = time.localtime(timestamp) # 本地时间（时区相关） utc_struct = time.gmtime(timestamp) # UTC时间（世界协调时间） print("本地结构化时间：", local_struct) # time.struct_time(tm_year=2024, ...) print("UTC结构化时间：", utc_struct) # （3）字符串时间：人类可读的时间格式 str_local = time.ctime(timestamp) # 默认格式本地时间 print("默认格式时间字符串：", str_local) # 示例：Wed May 22 10:09:27 2024 # 3. 自定义时间格式转换 # 结构化时间 → 自定义字符串时间 custom_str = time.strftime("%Y-%m-%d %H:%M:%S", local_struct) print("自定义格式（年-月-日 时:分:秒）：", custom_str) # 示例：2024-05-22 10:09:27 # 字符串时间 → 结构化时间（需匹配格式） str_to_struct = time.strptime("2024-05-20 14:30:00", "%Y-%m-%d %H:%M:%S") print("字符串转结构化时间：", str_to_struct) # 结构化时间 → 时间戳 struct_to_timestamp = time.mktime(local_struct) print("结构化时间转时间戳：", struct_to_timestamp) # 4. 时间延迟与程序耗时统计 # 时间延迟（暂停程序执行） print("开始延迟2秒...") time.sleep(2) # 暂停2秒 print("延迟结束！") # 统计程序执行耗时（普通精度） start = time.time() sum_result = 0 for i in range(1_000_000): sum_result += i end = time.time() print(f"循环执行耗时：{end - start:.6f}秒") # 5. 高精度计时（适合短时间间隔测量） # perf_counter：包含睡眠耗时的高精度计时器（推荐） start_perf = time.perf_counter() time.sleep(0.5) for i in range(500_000): sum_result += i end_perf = time.perf_counter() print(f"高精度计时（含睡眠）：{end_perf - start_perf:.6f}秒") # process_time：仅统计进程占用CPU的时间（不含睡眠） start_proc = time.process_time() for i in range(500_000): sum_result += i end_proc = time.process_time() print(f"CPU时间（不含睡眠）：{end_proc - start_proc:.6f}秒") ```1. 程序执行耗时统计（如优化代码性能、监控任务执行效率）；2. 时间格式转换（如日志记录时间格式化、接口时间参数处理）；3. 定时任务（如程序中添加固定延迟、周期性执行任务）；4. 时间戳相关操作（如数据排序、时间差计算）；5. 本地时间与UTC时间转换（如跨时区数据交互）1. 三种时间格式核心关系：时间戳（计算机可直接计算）<--> 结构化时间（程序可解析字段）<--> 字符串时间（人类可读）；2. 格式符说明：%Y（4位年份）、%m（2位月份）、%d（2位日期）、%H（24小时制）、%M（分钟）、%S（秒），完整格式符可查看time.strftime文档；3. 时区注意：localtime()返回本地时区时间，gmtime()返回UTC时区时间，time模块本身不直接支持时区转换，复杂时区需求需用datetime+pytz模块；4. 高精度计时：perf_counter()精度高于time()，适合短时间间隔测量；process_time()仅统计CPU时间，适合评估CPU密集型程序性能；5. 与datetime模块区别：time模块偏向底层时间操作，功能基础；datetime模块提供面向对象的时间处理，支持更复杂的日期计算、时区操作；6. 注意事项：time.struct_time对象是不可变的；strptime()的格式字符串必须与输入字符串完全匹配，否则抛出ValueError；time.sleep()会暂停当前线程的执行，不影响其他线程
toml（TOML解析模块）Python标准库模块（Python 3.11+），用于解析和生成TOML格式文件，TOML旨在成为“明显优于INI”的配置格式，支持强类型、层级结构、数组、日期时间等，语法简洁直观，兼顾可读性和机器解析效率，是Python项目配置的推荐格式之一。```python # 1. 导入toml模块（Python 3.11+内置，低版本需安装：pip install toml） import toml from datetime import datetime # 2. 生成并写入TOML文件 config_data = { "database": { "host": "127.0.0.1", "port": 3306, "username": "admin", "password": "SecurePass123!", "db_name": "project_db", "charset": "utf8mb4", "connect_timeout": 10, "pool_size": 20 }, "application": { "debug_mode": True, "log_level": "INFO", "max_requests": 1000, "launch_time": datetime(2024, 5, 20, 14, 30, 0), # 支持datetime类型 "paths": { "static": "./static", "templates": "./templates" }, "features": ["api", "admin", "user"] # 数组类型 }, "third_party": { "api_key": "sk_8f7d6c5b4a3b2c1d", "api_url": "https://api.example.com/v1", "timeout": 30, "retry": { "count": 3, "delay": 2.5 # 浮点数类型 } }, # 数组表格（类似列表的层级配置） "servers": [ {"name": "server1", "ip": "192.168.1.100", "port": 8080}, {"name": "server2", "ip": "192.168.1.101", "port": 8080} ] } # 写入TOML文件 with open("app_config.toml", "w", encoding="utf-8") as f: toml.dump(config_data, f) print("TOML配置文件 app_config.toml 创建完成") # 3. 读取TOML文件 with open("app_config.toml", "r", encoding="utf-8") as f: loaded_config = toml.load(f) # 访问配置项（自动保留原始类型） print("数据库端口：", loaded_config["database"]["port"], type(loaded_config["database"]["port"])) # 3306 <class 'int'> print("调试模式：", loaded_config["application"]["debug_mode"], type(loaded_config["application"]["debug_mode"])) # True <class 'bool'> print("启动时间：", loaded_config["application"]["launch_time"], type(loaded_config["application"]["launch_time"])) # 2024-05-20 14:30:00 <class 'datetime.datetime'> print("第二台服务器IP：", loaded_config["servers"][1]["ip"]) # 192.168.1.101 # 4. 解析TOML字符串 toml_str = """ [app] name = "Python TOML Test" version = "1.0.0" authors = ["张三", "李四"] [app.settings] theme = "dark" font_size = 14 """ parsed_toml = toml.loads(toml_str) print("应用名称：", parsed_toml["app"]["name"]) print("应用作者：", parsed_toml["app"]["authors"]) print("应用主题：", parsed_toml["app"]["settings"]["theme"]) # 5. 生成TOML字符串 simple_data = {"name": "王五", "age": 30, "is_staff": True} toml_str_generated = toml.dumps(simple_data) print("生成的TOML字符串：") print(toml_str_generated) ```1. Python项目配置（如pyproject.toml，PEP 621推荐的项目元数据格式）；2. 强类型配置场景（需要严格区分整数、布尔值、日期时间等类型的配置）；3. 替代INI/YAML的配置需求（兼顾INI的简洁和YAML的复杂结构支持）；4. 工具类项目配置（如代码格式化工具、测试工具的配置文件）；5. 跨语言配置交换（TOML是跨语言标准，支持多种编程语言解析）；6. 中小型项目的配置管理（语法简单，无需复杂学习成本，易维护）1. 核心特性：强类型支持（自动识别整数、浮点数、布尔值、字符串、日期时间、数组等类型）；层级结构清晰（通过点分隔或嵌套表格表示层级）；数组表格（[[table]]）支持列表式层级配置；语法严谨无歧义；2. TOML语法要点：表格用[table.name]表示层级；键值对支持等号分隔（key = value）；字符串支持单引号、双引号、多行字符串；数组用方括号包裹（[item1, item2]）；日期时间支持RFC 3339格式（如2024-05-20T14:30:00Z）；3. 与其他格式对比：相比INI，支持复杂嵌套和强类型；相比YAML，语法更严谨（无缩进歧义），无需学习锚点等复杂特性；相比JSON，更适合人类编辑（无冗余引号和逗号）；4. 版本支持：Python 3.11+将toml模块纳入标准库，低版本需安装第三方toml库（pip install toml）；5. 典型应用：pyproject.toml（Python项目的构建配置文件，用于Poetry、Pipenv等工具）；各种Python开发工具的配置文件（如black、isort等）；6. 注意事项：TOML对大小写敏感；表格名称和键名不支持特殊字符，需使用合法标识符；日期时间类型仅支持特定格式，解析时需遵循规范；7. 扩展功能：支持自定义解码器（处理特殊类型）；支持解析时保留注释（第三方toml库如tomllib-ext可实现）。
try-except（异常处理）Python中的异常处理机制，用于捕获和处理程序运行时的异常（如除零错误、类型错误、文件不存在等），避免程序意外终止，同时可提供错误信息便于调试```python # 1. 基本异常处理 try: # 可能发生异常的代码块 a = 1 / 0 print(a) except ZeroDivisionError as e: # 捕获指定异常并处理 print(f"除零错误：{e}") # 输出：除零错误：division by zero # 2. 捕获多个异常 try: lst = [1, 2, 3] print(lst[5]) # 索引错误 # 1 / 0 # 除零错误 except (IndexError, ZeroDivisionError) as e: print(f"发生错误：{e}") # 输出：发生错误：list index out of range # 3. 捕获所有异常 try: int("abc") # 类型错误 except Exception as e: print(f"程序异常：{e}") # 输出：程序异常：invalid literal for int() with base 10: 'abc' # 4. else和finally子句 try: a = 10 / 2 except Exception as e: print(f"错误：{e}") else: # 无异常时执行 print(f"计算结果：{a}") # 输出：计算结果：5.0 finally: # 无论是否有异常都执行（常用于资源清理） print("程序执行完毕") # 输出：程序执行完毕 # 5. 自定义异常 class MyError(Exception): """自定义异常类""" def __init__(self, message): self.message = message def test_func(value): if value < 0: raise MyError("值不能为负数") # 抛出自定义异常 try: test_func(-5) except MyError as e: print(f"自定义异常：{e.message}") # 输出：自定义异常：值不能为负数 ```1. 程序容错（避免因小错误导致程序整体崩溃）；2. 资源清理（如文件关闭、数据库连接关闭，通过finally实现）；3. 输入校验（处理用户输入不合法的情况）；4. 调试与日志（记录异常信息，便于问题定位）；5. 自定义业务异常（处理业务逻辑中的错误场景）1. 异常层级：Python异常有层级关系，BaseException是所有异常的基类，Exception是所有非退出异常的基类；2. 不建议捕获所有异常：过度捕获异常会隐藏潜在问题，应尽量捕获具体异常；3. raise语句：用于主动抛出异常，可抛出内置异常或自定义异常；4. else子句：仅在try块无异常时执行，常用于后续逻辑处理；5. finally子句：无论是否有异常都会执行，常用于资源清理（如关闭文件、释放锁）；6. 自定义异常：继承Exception类（而非BaseException），可添加自定义属性和方法；7. 常见内置异常：ZeroDivisionError、IndexError、KeyError、TypeError、ValueError、FileNotFoundError等
tuple（元组）Python内置的有序不可变序列，用于存储任意类型元素，底层基于数组实现，一旦创建无法修改元素，访问效率与列表相当，内存占用比列表更低```python # 1. 元组初始化 tup1 = (1, 2, 3, "Python") # 括号包裹，逗号分隔 tup2 = 1, 2, 3 # 省略括号（元组打包） tup3 = tuple(range(5)) # 通过tuple()构造函数 tup4 = (1,) # 单元素元组，必须加逗号 print(tup1) # (1, 2, 3, 'Python') print(tup2) # (1, 2, 3) print(tup3) # (0, 1, 2, 3, 4) print(tup4) # (1,) # 2. 核心操作 tup = (1, 2, 3) print(tup[1]) # 2（按索引访问） print(tup[1:3]) # (2, 3)（切片操作） print(2 in tup) # True（元素存在性判断） # 3. 元组解包 a, b, c = tup print(f"a={a}, b={b}, c={c}") # a=1, b=2, c=3 # 4. 不可变性验证 # tup[0] = 10 # 报错：'tuple' object does not support item assignment # 5. 与列表转换 lst = list(tup) lst.append(4) new_tup = tuple(lst) print(new_tup) # (1, 2, 3, 4) ```1. 存储不可变数据（如配置参数、固定常量集合）；2. 函数返回多个值（本质是返回元组）；3. 字典的键（元组不可变，可作为字典键，列表不行）；4. 数据安全性要求高的场景（避免数据被意外修改）；5. 临时数据存储（内存占用比列表低，访问效率高）1. 底层实现：与列表类似基于数组，但因不可变，无需预留扩容空间，内存占用更紧凑；2. 时间复杂度：按索引访问、切片、存在性判断均为O(1)或O(k)（k为切片长度），无修改操作；3. 与列表的核心区别：元组不可变（mutable=False），列表可变（mutable=True）；4. 常用方法：count()（统计元素出现次数）、index()（查找元素索引），方法数量远少于列表；5. 元组解包特性：支持灵活的变量赋值，可通过*接收剩余元素（如a, *b = (1,2,3,4) → a=1, b=[2,3,4]）；6. 注意：元组的不可变性是指元素引用不可变，若元素是可变对象（如列表），其内部内容可修改
with语句（上下文管理器）Python中的上下文管理语句，用于简化资源管理，自动完成资源的获取和释放（如文件打开后自动关闭、数据库连接打开后自动断开），底层依赖上下文管理器协议```python # 1. 基本用法：文件操作 # 传统方式（需手动关闭文件） f = open("test.txt", "w", encoding="utf-8") try: f.write("Hello World") finally: f.close() # with语句方式（自动关闭文件） with open("test.txt", "w", encoding="utf-8") as f: f.write("Hello World") # 退出with块，自动调用f.close()，即使发生异常 # 2. 多个资源的同时管理 with open("a.txt", "r", encoding="utf-8") as f1, open("b.txt", "w", encoding="utf-8") as f2: # 读取a.txt内容并写入b.txt content = f1.read() f2.write(content) # 3. 自定义上下文管理器（实现__enter__和__exit__方法） class DatabaseConnection: def __init__(self, conn_str): self.conn_str = conn_str def __enter__(self): # 模拟连接数据库 print(f"连接数据库：{self.conn_str}") return self # 返回资源对象给as def __exit__(self, exc_type, exc_val, exc_tb): # 模拟关闭数据库连接 print("关闭数据库连接") # 返回True表示异常已处理，不会向上传播 return True def query(self, sql): print(f"执行SQL：{sql}") # 使用自定义上下文管理器 with DatabaseConnection("mysql://localhost:3306/test") as db: db.query("SELECT * FROM users") # 1 / 0 # 即使发生异常，也会自动关闭连接，且异常被__exit__处理 # 4. 结合contextlib使用（简化自定义上下文管理器） from contextlib import contextmanager @contextmanager def my_context(): print("进入上下文") yield print("退出上下文") with my_context(): print("在上下文中执行") # 输出：进入上下文 → 在上下文中执行 → 退出上下文 ```1. 文件操作（自动关闭文件，避免文件句柄泄露）；2. 数据库连接（自动断开连接，节省资源）；3. 网络连接（自动关闭连接，避免连接泄露）；4. 锁操作（自动获取和释放锁，避免死锁）；5. 临时环境管理（如临时修改配置，退出后恢复）1. 上下文管理器协议：对象必须实现__enter__（获取资源，返回资源对象）和__exit__（释放资源，处理异常）方法；2. __exit__方法参数：exc_type（异常类型）、exc_val（异常值）、exc_tb（异常追踪信息），返回True表示异常已处理；3. 与try-finally的区别：with语句代码更简洁，自动处理资源释放，无需手动编写finally块；4. 常用支持with的对象：open()返回的文件对象、threading.Lock、sqlite3.Connection、requests.Session等；5. 扩展：通过contextlib模块可简化上下文管理器的实现（无需定义类和__enter__、__exit__方法）；6. 注意事项：with语句仅能管理实现了上下文管理器协议的对象，自定义对象需手动实现该协议
zip（打包函数）Python内置函数，用于将多个可迭代对象打包成一个元组迭代器，每个元组包含来自各个可迭代对象的对应位置元素，当最短的可迭代对象耗尽时停止打包```python # 1. 基本用法 names = ["张三", "李四", "王五"] ages = [28, 22, 30] scores = [90, 85, 95] # 打包多个可迭代对象 zip_obj = zip(names, ages, scores) print(type(zip_obj)) # <class 'zip'> # 转换为列表查看结果 print(list(zip_obj)) # [('张三', 28, 90), ('李四', 22, 85), ('王五', 30, 95)] # 2. 循环遍历打包结果 for name, age, score in zip(names, ages, scores): print(f"姓名：{name}，年龄：{age}，分数：{score}") # 输出： # 姓名：张三，年龄：28，分数：90 # 姓名：李四，年龄：22，分数：85 # 姓名：王五，年龄：30，分数：95 # 3. 处理长度不同的可迭代对象 names = ["张三", "李四", "王五"] ages = [28, 22] # 长度比names短 # 以最短的可迭代对象为准 for name, age in zip(names, ages): print(f"姓名：{name}，年龄：{age}") # 输出： # 姓名：张三，年龄：28 # 姓名：李四，年龄：22 # 4. 解压（*操作符） zipped = [('张三', 28), ('李四', 22)] names, ages = zip(*zipped) print(names) # ('张三', '李四') print(ages) # (28, 22) # 5. 与enumerate结合 for idx, (name, age) in enumerate(zip(names, ages)): print(f"序号{idx+1}：{name}，年龄{age}") # 6. 打包不同类型的可迭代对象 lst = [1, 2, 3] tup = ("a", "b", "c") s = "xyz" print(list(zip(lst, tup, s))) # [(1, 'a', 'x'), (2, 'b', 'y'), (3, 'c', 'z')] ```1. 多组数据对应匹配（如姓名、年龄、分数的对应关系）；2. 数据并行处理（同时遍历多个可迭代对象）；3. 数据打包传输（将多个相关数据打包成元组）；4. 解压数据（通过*操作符还原打包的数据）；5. 字典构建（将两个列表分别作为键和值构建字典）1. 返回值：zip()返回zip对象（迭代器），可通过list()、tuple()等转换为其他类型；2. 长度规则：打包结果的长度等于最短的可迭代对象的长度；3. 处理长度不同的需求：若需以最长的可迭代对象为准，可使用itertools.zip_longest()；4. 解压操作：通过*操作符可将zip对象或打包后的元组列表解压为多个可迭代对象；5. 性能：zip()是内置函数，由C语言实现，性能优于手动循环匹配多个可迭代对象；6. Python 2 vs Python 3：Python 2中zip()返回列表，Python 3中返回迭代器（更节省内存）；7. 常见应用：构建字典（dict(zip(keys, values))）、多参数循环遍历、数据批量匹配等
变量与数据类型基础Python中变量是数据的引用容器，无需声明类型，赋值时自动确定类型。核心基础数据类型包括整数（int）、浮点数（float）、字符串（str）、布尔值（bool），是构建所有Python程序的基础单元。```python # 1. 变量定义与赋值（动态类型，无需声明） num1 = 10 # 整数（int） num2 = 3.14 # 浮点数（float） name = "Python" # 字符串（str） is_valid = True # 布尔值（bool） empty = None # 空值（NoneType） # 2. 查看变量类型 print(type(num1)) # <class 'int'> print(type(num2)) # <class 'float'> print(type(name)) # <class 'str'> print(type(is_valid)) # <class 'bool'> # 3. 基础数据类型操作 # 整数/浮点数运算 print(num1 + 5) # 15 print(num2 * 2) # 6.28 print(10 // 3) # 3（整数除法） print(10 % 3) # 1（取余） # 字符串操作 print(name + "基础") # 拼接：Python基础 print(name * 2) # 重复：PythonPython print(name[0:3]) # 切片：Pyt # 布尔值运算（True=1，False=0） print(is_valid and False) # False print(is_valid or False) # True print(not is_valid) # False # 4. 类型转换 print(int(num2)) # 3（浮点数转整数） print(float(num1)) # 10.0（整数转浮点数） print(str(num1)) # "10"（整数转字符串） print(bool(0)) # False（0转布尔值为False） ```1. 程序中存储基础数据（如用户ID、金额、名称、开关状态等）；2. 简单数据运算与判断（如数值计算、条件判断的布尔结果）；3. 数据格式转换（如接收用户输入的字符串转数值，输出时数值转字符串）；4. 所有Python程序的基础构建（任何复杂程序都离不开基础数据类型）1. 动态类型特性：变量类型可随赋值改变（如a=10后可再赋值a="abc"），灵活但需注意类型一致性；2. 不可变类型：int、float、str、bool、None都是不可变类型，修改时会创建新对象，原对象不变；3. 布尔值判断：0、空字符串、空容器、None的布尔值均为False，非空/非0均为True；4. 变量命名规则：由字母、数字、下划线组成，不能以数字开头，区分大小写，避免使用关键字（如if、for、class）；5. 类型提示：Python 3.5+支持类型提示（如num: int = 10），仅用于提示，不强制类型检查；6. 注意事项：不同类型直接运算可能报错（如"10"+10，需先转换类型）。
函数基础（def）Python中封装代码逻辑的核心语法，将一段可复用的代码块定义为函数，通过调用函数执行代码，实现代码复用、模块化编程。支持参数传递、返回值、默认参数、关键字参数等特性。```python # 1. 无参数无返回值函数 def say_hello(): print("Hello, Python!") # 调用函数 say_hello() # 输出：Hello, Python! # 2. 带参数函数 def add(a, b): result = a + b print(f"{a} + {b} = {result}") add(3, 5) # 传入位置参数，输出：3 + 5 = 8 # 3. 带返回值函数（用return返回结果） def multiply(a, b): return a * b # 返回计算结果 product = multiply(4, 6) print(f"4 * 6 = {product}") # 输出：24 # 4. 默认参数（参数有默认值，调用时可省略） def greet(name, greeting="Hello"): print(f"{greeting}, {name}!") greet("张三") # 用默认问候语，输出：Hello, 张三! greet("李四", "Hi") # 自定义问候语，输出：Hi, 李四! # 5. 关键字参数（调用时指定参数名，顺序可任意） greet(greeting="Good morning", name="王五") # 输出：Good morning, 王五! # 6. 不定长参数（接收任意数量的参数） # *args：接收任意数量的位置参数，存储为元组 def sum_args(*args): total = 0 for num in args: total += num return total print(sum_args(1, 2, 3, 4)) # 输出：10 # **kwargs：接收任意数量的关键字参数，存储为字典 def print_kwargs(**kwargs): for key, value in kwargs.items(): print(f"{key}: {value}") print_kwargs(name="赵六", age=30, city="深圳") # 输出键值对 # 7. 函数嵌套 def outer_func(x): def inner_func(y): return y * 2 return inner_func(x) + 3 print(outer_func(5)) # 5*2+3=13 ```1. 代码复用（将重复执行的逻辑封装为函数，避免代码冗余）；2. 模块化编程（将复杂程序拆分为多个函数，每个函数负责单一功能，便于维护）；3. 业务逻辑封装（如数据处理、接口调用、文件操作等逻辑封装为函数）；4. 参数化控制（通过参数传递不同值，实现函数的灵活复用）；5. 团队协作开发（不同开发者负责不同函数，提升开发效率）1. 函数定义规则：用def关键字，函数名遵循变量命名规则，代码块缩进，参数放在括号内；2. 返回值特性：return语句用于返回结果，执行到return后函数立即结束；无return或return后无值，返回None；3. 参数类型：位置参数（必须按顺序传入）、关键字参数（指定参数名，顺序灵活）、默认参数（有默认值，可省略）、不定长参数（*args/**kwargs）；4. 默认参数注意：默认参数必须放在位置参数之后；默认参数最好是不可变类型（如int、str），避免使用可变类型（如列表），否则可能出现意外行为；5. 函数作用域：函数内部定义的变量是局部变量，仅在函数内有效；外部变量是全局变量，函数内可读取，修改需用global声明；6. 函数文档字符串：函数内首行可添加字符串（"""..."""），用于说明函数功能，可通过help(函数名)查看；7. 注意事项：函数调用时，位置参数必须在关键字参数之前；不定长参数*args必须在**kwargs之前。
集合基础操作Python中无序、不重复的元素集合类型，用于存储唯一元素，支持集合运算（交集、并集、差集等）。语法上用大括号表示，核心特点是去重和集合运算，适合数据去重、元素存在性判断、数据对比等场景。```python # 1. 集合定义与初始化 s1 = {1, 2, 3, 4} # 直接定义（大括号） s2 = set([2, 3, 5, 6]) # 用set()转换列表（去重） s3 = set("hello") # 字符串转集合（去重，无序） s4 = set() # 空集合（必须用set()，{}是空字典） # 2. 去重特性 lst = [1, 2, 2, 3, 3, 3] s5 = set(lst) print(s5) # {1, 2, 3}（自动去重） lst_unique = list(s5) # 转回列表，得到去重后的列表 # 3. 集合元素操作 # 添加元素 s1.add(5) # 添加单个元素 s1.update([6, 7]) # 批量添加元素 print(s1) # {1, 2, 3, 4, 5, 6, 7} # 删除元素 s1.remove(5) # 删除指定元素，不存在报错 s1.discard(8) # 删除指定元素，不存在不报错 s1.pop() # 随机删除一个元素（无序，无法指定） s1.clear() # 清空集合 print(s1) # set() # 4. 集合运算（交集、并集、差集、对称差集） a = {1, 2, 3, 4} b = {3, 4, 5, 6} # 交集（共同元素） print(a & b) # {3, 4} print(a.intersection(b)) # 并集（所有元素，去重） print(a | b) # {1, 2, 3, 4, 5, 6} print(a.union(b)) # 差集（a中有但b中没有的元素） print(a - b) # {1, 2} print(a.difference(b)) # 对称差集（a和b中互不相同的元素） print(a ^ b) # {1, 2, 5, 6} print(a.symmetric_difference(b)) # 5. 集合关系判断 c = {3, 4} print(c.issubset(a)) # c是a的子集？True print(a.issuperset(c)) # a是c的超集？True print(a.isdisjoint(b)) # a和b无交集？False ```1. 数据去重（如去除列表、字符串中的重复元素）；2. 元素存在性判断（集合的in操作效率远高于列表，适合大量数据的存在性检查）；3. 数据对比（如两个数据集的共同元素、差异元素、合并去重等）；4. 过滤重复数据（如处理用户输入、日志数据时过滤重复记录）；5. 数学集合运算（如交集、并集、差集的数学场景模拟）1. 核心特性：无序（无法通过索引访问元素）、不重复（自动去重，添加重复元素无效）；2. 元素要求：集合中的元素必须是不可变类型（如int、str、tuple），不能是列表、字典等可变类型；3. 与列表/字典的区别：列表有序可重复、可变；字典键值对映射；集合无序不重复、可变（可添加/删除元素）；4. 集合运算优势：集合运算（交集、并集等）比列表推导式实现更简洁高效（如a&b比[x for x in a if x in b]高效）；5. 空集合创建：必须用set()，不能用{}（{}是空字典）；6. 性能注意：集合的in操作时间复杂度是O(1)，列表是O(n)，大量数据的存在性判断优先用集合；7. 注意事项：集合是无序的，遍历顺序不固定；不能直接存储可变元素，若需存储复杂数据，可将其转换为元组后存储。
类型转换函数Python中用于实现不同数据类型之间转换的内置函数，核心包括int()、float()、str()、bool()、list()、tuple()、set()、dict()等。通过类型转换可解决不同类型数据的运算、存储和展示问题，是数据处理的基础操作。```python # 1. 基础数据类型转换 # 字符串转数值 str_num = "123" int_num = int(str_num) # 字符串转整数：123 float_num = float(str_num) # 字符串转浮点数：123.0 str_float = "3.14" int_float = int(float(str_float)) # 先转浮点数再转整数：3（直接int("3.14")报错） # 数值转字符串 num = 456 str_num2 = str(num) # 整数转字符串："456" str_float2 = str(3.14) # 浮点数转字符串："3.14" # 数值/字符串转布尔值 print(bool(0)) # 0转布尔值：False print(bool(1)) # 非0整数转布尔值：True print(bool(3.14)) # 非0浮点数转布尔值：True print(bool("")) # 空字符串转布尔值：False print(bool("abc")) # 非空字符串转布尔值：True print(bool(None)) # None转布尔值：False # 2. 序列/集合类型转换 # 列表转其他类型 lst = [1, 2, 3, 3] tpl = tuple(lst) # 列表转元组：(1, 2, 3, 3) s = set(lst) # 列表转集合（去重）：{1, 2, 3} str_lst = str(lst) # 列表转字符串："[1, 2, 3, 3]" # 元组转其他类型 tpl2 = (4, 5, 6) lst2 = list(tpl2) # 元组转列表：[4, 5, 6] s2 = set(tpl2) # 元组转集合：{4, 5, 6} # 字符串转序列（需符合格式） str_seq = "1,2,3,4" lst3 = list(map(int, str_seq.split(","))) # 字符串按,分割转列表：[1,2,3,4] str_char = "python" lst4 = list(str_char) # 字符串转字符列表：['p','y','t','h','o','n'] # 3. 字典类型转换（需特定格式的可迭代对象） # 列表转字典（列表元素需是键值对元组） lst_kv = [("name", "张三"), ("age", 28)] dict1 = dict(lst_kv) # 列表转字典：{"name":"张三", "age":28} # 元组转字典 tpl_kv = (("city", "深圳"), ("gender", "男")) dict2 = dict(tpl_kv) # 元组转字典：{"city":"深圳", "gender":"男"} # 4. 转换异常处理（避免非法转换报错） try: int("abc") # 字符串无法转整数，会报错 except ValueError as e: print(f"转换错误：{e}") # 输出：转换错误：invalid literal for int() with base 10: 'abc' # 安全转换：先判断是否可转换 def safe_str_to_int(s): if s.isdigit(): # 判断字符串是否全为数字 return int(s) else: return None print(safe_str_to_int("123")) # 123 print(safe_str_to_int("abc")) # None ```1. 数据运算适配（如字符串类型的数值需转成int/float才能参与运算）；2. 数据存储适配（如列表需转成集合去重，列表需转成元组保证数据不可变）；3. 数据展示适配（如数值需转成字符串才能拼接文本，序列需转成字符串展示）；4. 函数参数适配（如函数要求传入列表，需将元组转成列表）；5. 数据清洗（如将用户输入的字符串转成指定类型，过滤无效数据）1. 转换规则：只有兼容的数据类型才能转换（如"123"可转int，"abc"不可转int）；转换失败会抛出ValueError异常，需结合try-except处理；2. 布尔值转换规律：0、空字符串、空序列（[]、()、set()）、空字典（{}）、None转布尔值为False；非空/非0值转布尔值为True；3. 序列转换注意：字符串转列表时，默认按字符分割（如"abc"→['a','b','c']）；若需按特定分隔符分割，需先split()再转换；4. 字典转换要求：转字典的可迭代对象必须是“键值对”结构（如元组列表、双元素元组）；5. 隐式类型转换：Python在运算时会自动进行隐式转换（如int和float相加，int自动转float）；显式转换需手动调用转换函数；6. 性能影响：频繁的类型转换会增加性能开销，尽量在数据录入时就确定正确类型；7. 扩展转换：复杂类型转换（如JSON字符串转字典）需使用专门模块（如json模块），内置转换函数无法实现。
列表基础操作Python中最常用的可变序列类型，用于存储有序、可重复的元素，元素类型可任意（如整数、字符串、列表等）。核心基础操作包括增、删、改、查、切片、排序等，是处理批量数据的核心工具。```python # 1. 列表定义与初始化 lst1 = [1, 2, 3, 4] # 直接定义 lst2 = list(range(5)) # 用list()转换 lst3 = [1, "a", 3.14, True] # 元素类型可混合 lst4 = [] # 空列表 # 2. 访问列表元素（通过索引） print(lst1[0]) # 正向索引：1 print(lst1[-1]) # 负向索引：4 # 3. 修改元素（可变特性） lst1[2] = 10 print(lst1) # [1, 2, 10, 4] # 4. 增删元素 # 增加元素 lst1.append(5) # 末尾添加：[1, 2, 10, 4, 5] lst1.insert(1, 1.5) # 索引1处插入：[1, 1.5, 2, 10, 4, 5] lst1.extend([6, 7]) # 扩展列表：[1, 1.5, 2, 10, 4, 5, 6, 7] # 删除元素 lst1.remove(10) # 删除指定值：[1, 1.5, 2, 4, 5, 6, 7] del lst1[1] # 删除指定索引：[1, 2, 4, 5, 6, 7] pop_item = lst1.pop() # 删除末尾元素并返回：7，列表变为[1, 2, 4, 5, 6] # 5. 列表切片（同字符串，返回新列表） print(lst1[1:4]) # [2, 4, 5] print(lst1[::2]) # [1, 4, 6] print(lst1[::-1]) # 反转：[6, 5, 4, 2, 1] # 6. 常用列表方法 print(len(lst1)) # 长度：5 print(2 in lst1) # 判断元素是否存在：True print(lst1.count(2)) # 元素出现次数：1 lst1.sort() # 排序（原地修改）：[1, 2, 4, 5, 6] lst1.reverse() # 反转（原地修改）：[6, 5, 4, 2, 1] # 7. 列表推导式（简洁创建列表） # 生成1-10的偶数列表 even_lst = [x for x in range(1, 11) if x % 2 == 0] print(even_lst) # [2, 4, 6, 8, 10] ```1. 批量数据存储（如存储多个用户信息、多个文件路径、批量计算结果）；2. 数据动态修改（如添加新数据、删除无效数据、更新数据值）；3. 数据排序与筛选（如对列表数据排序、筛选符合条件的元素）；4. 迭代处理数据（如通过for循环遍历列表，批量处理每个元素）；5. 作为函数参数/返回值（传递批量数据，返回多个结果）1. 可变特性：列表元素可修改、添加、删除，修改时直接操作原列表（不同于字符串的不可变）；2. 索引与切片：规则同字符串，支持正向/负向索引、步长切片，切片返回新列表；3. 增删方法对比：append()末尾添加（高效），insert()指定位置添加（效率低，需移动元素），extend()扩展列表（比+拼接高效）；remove()按值删除（需遍历），del按索引删除（高效），pop()删除并返回元素；4. 列表推导式：比for循环+append()更简洁高效，适合创建有规律的列表；5. 排序注意：sort()方法原地排序（修改原列表），sorted()函数返回新排序列表（不修改原列表）；sort()默认升序，reverse=True可降序；6. 嵌套列表：列表可包含列表（如[[1,2],[3,4]]），用于表示二维数据（如表格、矩阵）；7. 注意事项：列表索引越界会报错（如访问lst[10]当长度为5时）；列表元素为可变对象（如列表）时，修改子对象会影响原列表。
列表推导式Python中简洁创建列表的语法糖，通过一行代码实现“循环遍历+条件筛选+元素处理”的逻辑，替代传统的for循环+append()写法。语法为[表达式 for 变量 in 可迭代对象 if 条件]，具有语法简洁、执行高效的优势。```python # 1. 基础用法：生成简单列表（循环遍历+元素处理） # 生成1-10的整数列表（替代lst = []; for i in range(11): lst.append(i)） lst1 = [i for i in range(1, 11)] print(lst1) # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # 生成1-10的平方列表（元素处理：求平方） lst2 = [i**2 for i in range(1, 11)] print(lst2) # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] # 2. 带条件筛选的列表推导式（循环+条件判断） # 生成1-10的偶数列表（筛选条件：i%2==0） even_lst = [i for i in range(1, 11) if i % 2 == 0] print(even_lst) # [2, 4, 6, 8, 10] # 生成1-20的奇数且能被3整除的列表（多条件筛选） odd_div3_lst = [i for i in range(1, 21) if i % 2 == 1 and i % 3 == 0] print(odd_div3_lst) # [3, 9, 15] # 3. 嵌套列表推导式（处理嵌套结构） # 展平嵌套列表（将二维列表转为一维列表） nested_lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] flatten_lst = [num for sub_lst in nested_lst for num in sub_lst] print(flatten_lst) # [1, 2, 3, 4, 5, 6, 7, 8, 9] # 嵌套推导式生成二维列表（如3x3的矩阵） matrix = [[i * 3 + j for j in range(1, 4)] for i in range(3)] print(matrix) # [[1, 2, 3], [4, 5, 6], [7, 8, 9]] # 4. 结合函数/表达式的列表推导式 # 字符串列表转换为大写 str_lst = ["apple", "banana", "orange"] upper_lst = [s.upper() for s in str_lst] print(upper_lst) # ["APPLE", "BANANA", "ORANGE"] # 计算列表中每个元素的长度 len_lst = [len(s) for s in str_lst] print(len_lst) # [5, 6, 6] # 5. 条件表达式的列表推导式（三目运算） # 给列表元素分类：大于5标记为"大"，否则标记为"小" num_lst = [3, 7, 2, 9, 5, 1] tag_lst = ["大" if num > 5 else "小" for num in num_lst] print(tag_lst) # ["小", "大", "小", "大", "小", "小"] # 6. 与传统for循环的对比（简洁性和效率） # 传统写法：生成1-10的偶数列表 traditional_lst = [] for i in range(1, 11): if i % 2 == 0: traditional_lst.append(i) # 列表推导式写法（一行搞定） comprehension_lst = [i for i in range(1, 11) if i % 2 == 0] print(traditional_lst == comprehension_lst) # True（结果一致） # 效率对比：列表推导式执行效率高于传统for+append（解释器优化） ```1. 快速创建有规律的列表（如数值序列、平方序列、矩阵等）；2. 数据筛选与转换（如筛选符合条件的元素、批量转换元素格式）；3. 嵌套结构处理（如展平嵌套列表、生成多维列表）；4. 替代繁琐的for+append写法（减少代码行数，提升可读性）；5. 临时数据处理（如函数中临时生成处理后的列表，无需单独定义循环）1. 语法结构：[表达式 循环体 条件筛选]，循环体是必须的，条件筛选可选；2. 执行顺序：先执行循环体（for 变量 in 可迭代对象），再判断条件（若有），最后执行表达式生成元素；3. 嵌套推导式顺序：外层循环在前，内层循环在后（如[num for sub_lst in nested_lst for num in sub_lst]，先遍历外层的sub_lst，再遍历内层的num）；4. 效率优势：列表推导式由Python解释器优化执行，比传统for+append()效率高（减少函数调用开销）；5. 可读性边界：列表推导式适合简单的循环+筛选逻辑；若逻辑过于复杂（如多层嵌套、多条件判断、复杂表达式），建议改用传统for循环，避免可读性下降；6. 与生成器表达式的区别：列表推导式用[]，生成器表达式用()；列表推导式直接生成完整列表（占内存），生成器表达式生成迭代器（惰性计算，省内存）；7. 扩展用法：字典推导式（{}）、集合推导式（{}）语法类似，分别用于创建字典和集合。
内置函数（print/input）Python内置的基础I/O函数，print()用于将数据输出到控制台（或指定输出流），input()用于从控制台读取用户输入（以字符串形式返回）。两者是Python程序与用户交互的基础工具，无需导入模块即可直接使用。```python # 一、print()函数：输出数据 # 1. 基础用法：输出单个/多个数据 print("Hello, Python!") # 输出单个字符串：Hello, Python! print(10, 3.14, "Python") # 输出多个数据，默认用空格分隔：10 3.14 Python # 2. 自定义分隔符（sep参数） print(10, 20, 30, sep="-") # 用-分隔：10-20-30 print("a", "b", "c", sep="") # 无分隔符拼接：abc print("name", "age", "city", sep="|") # 用|分隔：name|age|city # 3. 自定义结束符（end参数，默认是换行\n） print("第一行", end="") # 不换行，后续输出紧跟 print("第二行") # 输出：第一行第二行 print("行1", end="\t") # 用制表符结束 print("行2") # 输出：行1 行2 # 4. 输出到文件（file参数） with open("output.txt", "w", encoding="utf-8") as f: print("这行内容会写入文件", file=f) # 不输出到控制台，写入文件 # 5. 输出格式化（结合f-string） name = "张三" age = 28 print(f"姓名：{name}，年龄：{age}") # 格式化输出：姓名：张三，年龄：28 # 二、input()函数：读取用户输入 # 1. 基础用法：提示用户输入，返回字符串 user_name = input("请输入你的姓名：") print(f"你好，{user_name}!") # 输出用户输入的姓名 # 2. 读取后转换类型（input()默认返回字符串，需手动转换） # 读取整数 age = int(input("请输入你的年龄：")) print(f"明年你将{age + 1}岁") # 读取浮点数 height = float(input("请输入你的身高（m）：")) print(f"你的身高是{height}米") # 3. 处理用户输入为空的情况 user_input = input("请输入内容（不能为空）：").strip() # 去除首尾空格 while not user_input: # 为空则重新输入 user_input = input("输入不能为空，请重新输入：").strip() print(f"你输入的内容：{user_input}") # 4. 多输入读取（分割用户输入的多个值） # 示例：用户输入"10 20"，分割为两个整数 a, b = map(int, input("请输入两个整数（用空格分隔）：").split()) print(f"两数之和：{a + b}") ```1. 程序与用户交互（如获取用户输入的参数、展示程序运行结果）；2. 调试程序（输出变量值、执行流程，辅助定位问题）；3. 简单数据录入（如小型脚本的用户信息录入、参数配置）；4. 文本输出到文件（快速将内容写入文件，无需复杂的文件操作）；5. 命令行工具交互（命令行程序的输入提示和结果展示）1. print()特性：可输出任意类型数据（自动转换为字符串）；多个数据用逗号分隔，默认空格拼接；end参数控制结束符（默认\n换行）；file参数支持输出重定向（如写入文件）；2. input()特性：始终返回字符串类型，读取数值需用int()/float()转换；用户按回车结束输入；无输入时返回空字符串；3. 常见问题：input()读取数值时，用户输入非数值会报错，需结合try-except处理异常；4. 输入处理技巧：用strip()去除用户输入的首尾空格（避免误输入空格）；用split()分割多输入值（默认按空格分割，可指定分隔符）；5. 输出优化：多个变量输出用f-string配合print()，比逗号分隔更易控制格式；6. 扩展用法：print()可结合logging模块实现更灵活的输出（如同时输出到控制台和文件）；input()可结合argparse模块实现命令行参数与用户输入的双重支持。
条件判断（if-elif-else）Python中实现分支逻辑的核心语法，根据条件表达式的布尔结果执行不同代码块。支持单分支（if）、双分支（if-else）、多分支（if-elif-else），条件表达式可结合比较运算符、逻辑运算符构建。```python # 1. 单分支（if） score = 85 if score >= 60: print("成绩合格") # 条件成立时执行 # 2. 双分支（if-else） if score >= 90: print("优秀") else: print("非优秀") # 条件不成立时执行 # 3. 多分支（if-elif-else） if score >= 90: grade = "A" elif score >= 80: grade = "B" elif score >= 60: grade = "C" else: grade = "D" print(f"成绩等级：{grade}") # 输出：B # 4. 条件表达式（三元运算符，简化双分支） result = "合格" if score >= 60 else "不合格" print(result) # 合格 # 5. 复杂条件（结合逻辑运算符） age = 20 has_id = True if age >= 18 and has_id: print("可办理身份证") elif age < 18 and has_id: print("可办理少儿身份证") else: print("缺少证件材料") # 6. 嵌套条件 if score >= 60: print("合格") if score >= 80: print("且成绩良好") ```1. 程序分支逻辑控制（如根据用户输入执行不同操作、根据数据状态执行不同处理逻辑）；2. 数据筛选与判断（如筛选符合条件的数据、判断数据有效性）；3. 业务规则实现（如根据订单金额判断折扣等级、根据用户权限展示不同功能）；4. 异常场景处理（如判断文件是否存在后执行读写操作）1. 缩进规则：Python用缩进（推荐4个空格）区分代码块，条件判断的代码块必须缩进，否则报错；2. 条件表达式：结果必须是布尔值（True/False），可直接使用布尔变量，或通过比较（==、!=、>、<等）、逻辑运算（and、or、not）构建；3. 多分支执行顺序：从上到下依次判断，满足一个条件后执行对应代码块，后续条件不再判断；4. 三元运算符优势：简化简单的双分支逻辑，代码更简洁（但复杂逻辑不建议使用，影响可读性）；5. 嵌套条件注意：嵌套层级不宜过多（建议不超过3层），否则代码可读性差，可拆分为函数；6. 常见错误：将赋值运算符（=）误用作比较运算符（==），导致条件判断逻辑错误。
循环语句（for-in）Python中遍历可迭代对象（如列表、字符串、字典等）的核心循环语法，无需手动控制循环索引，直接迭代对象中的每个元素。配合range()函数可实现固定次数循环，配合break/continue可控制循环流程。```python # 1. 遍历可迭代对象（列表、字符串、元组） fruits = ["apple", "banana", "orange"] for fruit in fruits: print(f"水果：{fruit}") # 依次输出列表中每个元素 # 遍历字符串 for char in "Python": print(char, end=" ") # 输出：P y t h o n # 2. 配合range()实现固定次数循环 # range(stop)：0到stop-1 for i in range(5): print(f"循环次数：{i+1}") # 执行5次（0-4） # range(start, stop, step)：从start到stop-1，步长为step for i in range(2, 10, 2): print(i, end=" ") # 输出：2 4 6 8 # 3. 遍历字典 person = {"name": "张三", "age": 28, "city": "深圳"} # 遍历键 for key in person: print(f"键：{key}，值：{person[key]}") # 遍历键值对 for key, value in person.items(): print(f"{key}: {value}") # 4. 循环控制（break/continue） # break：终止循环 for i in range(10): if i == 5: break print(i, end=" ") # 输出：0 1 2 3 4 # continue：跳过当前循环，进入下一次 for i in range(10): if i % 2 == 0: continue print(i, end=" ") # 输出：1 3 5 7 9 # 5. 嵌套for循环 for i in range(3): for j in range(2): print(f"i={i}, j={j}") # 执行3*2=6次 ```1. 遍历数据集合（如批量处理列表中的数据、遍历文件内容、处理字典中的键值对）；2. 固定次数重复操作（如执行10次测试、生成10个随机数）；3. 数据筛选与处理（如遍历列表筛选符合条件的元素、批量修改数据）；4. 矩阵/表格类数据处理（如嵌套循环处理二维列表）；5. 批量任务执行（如批量发送邮件、批量处理文件）1. 可迭代对象：能被for-in遍历的对象，包括序列（列表、字符串、元组）、集合、字典、生成器、文件对象等；2. range()特性：range对象是惰性序列，不立即生成所有元素，节省内存，适合大量次数循环；3. 字典遍历：默认遍历键，遍历值用values()，遍历键值对用items()；4. 循环控制：break彻底终止当前循环，continue仅跳过当前次循环；5. 嵌套循环性能：嵌套层级越多，性能越低，尽量减少嵌套（如拆分为函数、使用列表推导式）；6. 列表推导式：可替代简单for循环+条件判断，代码更简洁（如[x*2 for x in range(5) if x%2==0]）；7. 注意事项：遍历列表时修改列表长度可能导致遍历不完整（如删除元素），建议遍历列表副本（for x in list_copy:）。
循环语句（while）Python中基于条件判断的循环语法，只要条件表达式为True，就重复执行循环体。适合循环次数不固定的场景（如依赖用户输入终止循环、等待某个条件满足），配合break/continue可控制循环流程，避免死循环。```python # 1. 基础while循环（条件满足时执行） count = 0 while count < 5: print(f"计数：{count}") count += 1 # 必须更新条件变量，否则死循环 # 输出：0 1 2 3 4 # 2. 配合break终止循环 user_input = "" while True: # 无限循环（条件恒为True） user_input = input("请输入内容（输入'quit'退出）：") if user_input == "quit": break # 输入'quit'时终止循环 print(f"你输入的是：{user_input}") # 3. 配合continue跳过当前循环 num = 0 while num < 10: num += 1 if num % 2 == 0: continue # 偶数时跳过后续代码，进入下一次循环 print(num, end=" ") # 输出：1 3 5 7 9 # 4. 嵌套while循环 i = 1 while i <= 3: j = 1 while j <= 2: print(f"i={i}, j={j}") j += 1 i += 1 # 5. 循环else语句（循环正常结束时执行，break终止则不执行） count = 0 while count < 3: print(count) count += 1 else: print("循环正常结束") # 会执行 count = 0 while count < 3: if count == 2: break print(count) count += 1 else: print("循环正常结束") # 不会执行 ```1. 循环次数不固定的场景（如等待用户输入、等待某个外部条件满足、处理未知长度的数据）；2. 无限循环场景（如服务器监听请求、程序后台常驻任务，需通过break手动终止）；3. 依赖动态条件的循环（如根据实时数据状态调整循环逻辑）；4. 与for循环互补（for循环适合已知可迭代对象，while适合未知次数/动态条件）1. 死循环风险：while循环必须确保条件最终会变为False，或通过break终止，否则会无限循环（如忘记更新count变量）；2. 条件变量更新：循环体内必须包含更新条件变量的代码（如count += 1），否则条件恒为True；3. 无限循环使用：while True是常用的无限循环写法，需配合break在合适时机终止，适用于服务器、监听任务等；4. 循环else特性：else块仅在循环正常结束（条件变为False）时执行，若被break终止则不执行；5. 与for循环的选择：已知循环次数或遍历可迭代对象，优先用for循环（简洁、不易出错）；循环次数未知或依赖动态条件，用while循环；6. 性能注意：while循环的性能与for循环接近，但嵌套while循环的可读性通常低于for循环；7. 常见错误：循环体内未更新条件变量导致死循环；条件表达式逻辑错误导致循环提前结束或无法结束。
元组基础操作Python中不可变的有序序列类型，用于存储有序、可重复的元素，元素类型可任意。语法上用圆括号表示，核心特点是不可变（创建后无法修改元素），比列表更轻量、安全，适合存储不希望被修改的数据。```python # 1. 元组定义与初始化 t1 = (1, 2, 3, 4) # 直接定义（圆括号可省略，推荐保留） t2 = 5, 6, 7 # 省略括号定义 t3 = tuple(range(3)) # 用tuple()转换 t4 = (1,) # 单元素元组，必须加逗号（否则是普通括号） t5 = () # 空元组 # 2. 访问元组元素（同列表，通过索引） print(t1[0]) # 1 print(t1[-2]) # 3 print(t1[1:3]) # (2, 3)（切片返回新元组） # 3. 不可变特性（无法修改元素） # t1[0] = 10 # 报错：'tuple' object does not support item assignment # 4. 常用元组操作 print(len(t1)) # 长度：4 print(2 in t1) # 判断元素存在：True print(t1.count(2)) # 元素出现次数：1 print(t1.index(3)) # 元素索引：2 # 5. 元组拼接与重复（返回新元组） t6 = t1 + t2 print(t6) # (1, 2, 3, 4, 5, 6, 7) t7 = t1 * 2 print(t7) # (1, 2, 3, 4, 1, 2, 3, 4) # 6. 元组解包（将元组元素赋值给多个变量） a, b, c = t2 # t2 = (5,6,7) print(a, b, c) # 5 6 7 # 解包时忽略部分元素（用_） x, _, z = (10, 20, 30) print(x, z) # 10 30 # 不定长解包（*接收多个元素） t8 = (1, 2, 3, 4, 5) first, *middle, last = t8 print(first, middle, last) # 1 [2, 3, 4] 5 # 7. 元组作为函数返回值（返回多个结果） def get_user_info(): return "孙七", 26, "广州" # 自动打包为元组 name, age, city = get_user_info() # 解包接收 print(name, age, city) # 孙七 26 广州 ```1. 存储不希望被修改的数据（如固定的配置项、常量、坐标点等）；2. 函数返回多个值（Python函数默认将多个返回值打包为元组，调用时解包接收）；3. 作为字典的键（元组不可变，可作为字典键；列表可变，不可作为字典键）；4. 数据安全传输（不可变特性确保数据在传递过程中不被篡改）；5. 与列表配合使用（如列表存储可变数据，元组存储固定标识）1. 不可变核心：元组的不可变是指元素的引用不可变，若元素是可变对象（如列表），则对象内部可修改（如t=(1,[2,3]); t[1].append(4) 是允许的）；2. 语法注意：单元素元组必须加逗号（如(1,)），否则圆括号会被当作普通运算符；3. 与列表的区别：列表可变、用方括号，适合动态修改数据；元组不可变、用圆括号，适合存储固定数据，更轻量、安全；4. 元组解包：是Python的重要特性，可快速将元组元素赋值给多个变量，支持不定长解包（*）；5. 性能优势：元组的创建和访问速度略快于列表，因为不可变特性减少了内存管理开销；6. 常用场景：函数多返回值、字典键、固定集合（如颜色值、坐标点）、配置常量；7. 注意事项：元组没有append()、remove()等修改方法，若需修改数据，需先转换为列表（如list(t)），修改后再转回元组。
字典基础操作Python中核心的键值对映射类型，用于存储无序（Python 3.7+后有序）的关联数据，键（key）唯一且必须是不可变类型（如字符串、整数），值（value）可任意类型。核心操作包括增删改查键值对，是存储结构化数据的核心工具。```python # 1. 字典定义与初始化 dict1 = {"name": "张三", "age": 28, "city": "深圳"} # 直接定义 dict2 = dict(name="李四", age=30, city="北京") # 用dict()函数 dict3 = {} # 空字典 dict4 = dict([("name", "王五"), ("age", 25)]) # 列表转字典 # 2. 访问字典值（通过键） print(dict1["name"]) # 张三 # 安全访问（键不存在时返回默认值，不报错） print(dict1.get("gender", "未知")) # 未知 # 3. 修改与添加键值对 dict1["age"] = 29 # 修改已有键的值 dict1["gender"] = "男" # 添加新键值对 print(dict1) # {"name": "张三", "age": 29, "city": "深圳", "gender": "男"} # 4. 删除键值对 del dict1["gender"] # 删除指定键 pop_value = dict1.pop("city") # 删除并返回值：深圳 dict1.popitem() # 删除最后一个键值对（Python 3.7+） print(dict1) # {"name": "张三", "age": 29} # 5. 字典遍历 # 遍历键 for key in dict1: print(f"键：{key}，值：{dict1[key]}") # 遍历值 for value in dict1.values(): print(value) # 遍历键值对（推荐） for key, value in dict1.items(): print(f"{key}: {value}") # 6. 常用字典方法 print(len(dict1)) # 长度：2 print("name" in dict1) # 判断键是否存在：True dict1.clear() # 清空字典 print(dict1) # {} # 7. 字典推导式（简洁创建字典） # 生成键为1-5，值为键的平方的字典 square_dict = {x: x*x for x in range(1, 6)} print(square_dict) # {1:1, 2:4, 3:9, 4:16, 5:25} # 8. 嵌套字典（存储复杂结构化数据） person = { "name": "赵六", "info": {"age": 35, "city": "上海"}, "hobbies": ["编程", "阅读"] } print(person["info"]["city"]) # 上海 print(person["hobbies"][0]) # 编程 ```1. 存储结构化数据（如用户信息、商品信息、配置参数等包含多个属性的数据）；2. 快速查找数据（通过键查找值，效率远高于列表的索引查找）；3. 数据关联映射（如将ID与对应的用户信息关联、将名称与对应的数值关联）；4. 配置参数管理（如程序的配置项，键为配置名，值为配置值）；5. 作为函数返回值（返回多个关联的结果，比列表更清晰）1. 键的特性：键必须唯一，重复定义会覆盖前值；键必须是不可变类型（str、int、tuple等），不能用列表、字典等可变类型；2. 有序性：Python 3.7+中字典是有序的（按插入顺序），3.6及以下无序；3. 访问方式对比：直接用[key]访问，键不存在会报错；用get()方法访问，键不存在返回默认值（默认None），更安全；4. 字典推导式：简洁高效创建字典，支持条件判断（如{x:x*x for x in range(1,6) if x%2==0}）；5. 嵌套字典：字典的值可以是字典，用于存储多层级结构化数据（如JSON数据的Python表示）；6. 与列表的区别：列表是有序序列，按索引访问；字典是键值对映射，按键访问；字典查找效率更高，适合存储关联数据；7. 注意事项：遍历字典时修改字典长度（如添加/删除键）可能导致遍历异常，建议遍历字典副本（如for key in dict.copy():）。
字典推导式Python中简洁创建字典的语法糖，基于可迭代对象生成键值对映射，语法为{键表达式: 值表达式 for 变量 in 可迭代对象 if 条件}。可替代传统的for循环+键值对赋值写法，高效实现字典的创建、筛选和转换。```python # 1. 基础用法：生成简单字典（循环+键值对表达式） # 生成键为1-5，值为键的平方的字典 square_dict = {i: i**2 for i in range(1, 6)} print(square_dict) # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25} # 生成键为字符串，值为长度的字典 str_lst = ["apple", "banana", "orange", "grape"] len_dict = {s: len(s) for s in str_lst} print(len_dict) # {"apple":5, "banana":6, "orange":6, "grape":5} # 2. 带条件筛选的字典推导式（筛选符合条件的键值对） # 筛选值为偶数的键值对（基于square_dict） even_value_dict = {k: v for k, v in square_dict.items() if v % 2 == 0} print(even_value_dict) # {2:4, 4:16} # 筛选键为奇数且值大于10的键值对 filter_dict = {k: v for k, v in square_dict.items() if k % 2 == 1 and v > 10} print(filter_dict) # {3:9（不满足v>10，排除）, 5:25（满足）} → {5:25} # 3. 基于两个可迭代对象生成字典（结合zip()） # 键列表和值列表对应生成字典 keys = ["name", "age", "city"] values = ["张三", 28, "深圳"] person_dict = {k: v for k, v in zip(keys, values)} print(person_dict) # {"name":"张三", "age":28, "city":"深圳"} # 4. 字典转换与修改（基于现有字典生成新字典） # 现有字典 original_dict = {"a": 10, "b": 20, "c": 30, "d": 40} # 生成新字典，值翻倍 doubled_dict = {k: v * 2 for k, v in original_dict.items()} print(doubled_dict) # {"a":20, "b":40, "c":60, "d":80} # 生成新字典，键转换为大写 upper_key_dict = {k.upper(): v for k, v in original_dict.items()} print(upper_key_dict) # {"A":10, "B":20, "C":30, "D":40} # 5. 嵌套字典的推导式（处理复杂结构） # 嵌套字典（原始数据） nested_dict = { "user1": {"name": "张三", "age": 28}, "user2": {"name": "李四", "age": 30}, "user3": {"name": "王五", "age": 25} } # 筛选年龄大于26的用户，生成新的嵌套字典 filtered_user_dict = { user_id: user_info for user_id, user_info in nested_dict.items() if user_info["age"] > 26 } print(filtered_user_dict) # 输出：{"user1": {"name":"张三", "age":28}, "user2": {"name":"李四", "age":30}} # 6. 与传统for循环的对比 # 传统写法：生成键为1-5的平方字典 traditional_dict = {} for i in range(1, 6): traditional_dict[i] = i**2 # 字典推导式写法（一行搞定） comprehension_dict = {i: i**2 for i in range(1, 6)} print(traditional_dict == comprehension_dict) # True（结果一致） ```1. 快速创建有规律的字典（如数值映射、字符串长度映射、配置参数字典等）；2. 字典数据筛选（如筛选符合条件的键值对，生成新字典）；3. 字典转换与修改（如批量修改键/值、生成字典副本并修改）；4. 多列表映射成字典（结合zip()将两个列表分别作为键和值，生成字典）；5. 复杂嵌套字典处理（筛选或转换嵌套字典中的数据）；6. 替代繁琐的for循环+赋值写法（减少代码行数，提升效率）1. 语法结构：{键表达式: 值表达式 循环体 条件筛选}，键表达式和值表达式是核心，循环体必须，条件筛选可选；2. 键的唯一性：字典的键必须唯一，若推导式中生成重复键，后生成的键值对会覆盖前一个；3. 可迭代对象要求：循环体中的可迭代对象可是任意可迭代类型（如列表、元组、集合、字典items()等）；4. 结合zip()使用：当键和值分别存储在两个列表中时，用zip(keys, values)将其配对，再通过推导式生成字典；5. 效率优势：字典推导式由解释器优化执行，比传统for循环+键值对赋值效率高；6. 可读性边界：适合简单的键值对生成和筛选逻辑；若逻辑复杂（如多层嵌套、多条件判断、复杂表达式），建议改用传统for循环，避免可读性下降；7. 与列表推导式的区别：列表推导式用[]生成列表，字典推导式用{}生成字典，且需要键值对表达式（键:值）；8. 扩展：集合推导式与字典推导式语法类似，但只有值表达式（无键），用于生成集合（自动去重）。
字符串格式化（f-string）Python 3.6+引入的高效字符串格式化语法，通过前缀 f/F 标识字符串，在 {} 占位符内直接嵌入变量、表达式、函数调用或格式说明符，实现动态文本拼接。相比%格式化和str.format()，具有语法简洁、执行高效、可读性强的优势，是当前Python字符串格式化的首选方案。```python # 1. 基础用法：嵌入变量（直接映射变量值） name = "张三" age = 28 city = "深圳" # 最简洁的变量嵌入 print(f"我叫{name}，今年{age}岁，住在{city}。") # 输出：我叫张三，今年28岁，住在深圳。 # 2. 嵌入表达式（实时计算并替换结果） x = 15 y = 25 # 算术表达式 print(f"{x} + {y} = {x + y}") # 15 + 25 = 40 print(f"{x}的3次方是{x**3}") # 15的3次方是3375 # 条件表达式（三元运算） is_adult = age >= 18 print(f"是否成年：{'是' if is_adult else '否'}") # 是否成年：是 # 3. 嵌入函数调用（直接执行函数并取返回值） def get_full_name(last_name, first_name): return f"{last_name}{first_name}" print(f"全名：{get_full_name('李', '四')}") # 全名：李四 # 内置函数调用 text = "python" print(f"字符串大写：{text.upper()}") # 字符串大写：PYTHON print(f"列表长度：{len([1,2,3,4])}") # 列表长度：4 # 4. 数值格式化（通过格式说明符控制输出格式） pi = 3.141592653589793 salary = 12500 # 小数精度控制（.2f保留2位小数，.4f保留4位） print(f"圆周率（保留2位）：{pi:.2f}") # 圆周率（保留2位）：3.14 print(f"圆周率（保留4位）：{pi:.4f}") # 圆周率（保留4位）：3.1416 # 整数补零/补空格（5d表示占5位，不足补空格；05d不足补0） print(f"序号：{3:5d}") # 序号： 3（补4个空格） print(f"序号：{3:05d}") # 序号：00003（补4个0） # 百分比格式（%表示转换为百分比，.1%保留1位小数） print(f"正确率：{0.892:.1%}") # 正确率：89.2% # 千分位分隔符（,或_，Python 3.6+支持_） print(f"薪资：{salary:,}元") # 薪资：12,500元 print(f"大数值：{123456789:_}") # 大数值：123_456_789 # 5. 字符串对齐与填充（控制输出长度和对齐方式） title = "Python基础" # 左对齐（<）：总长度15，空白处补-（默认补空格） print(f"左对齐：{title:<15s}-") # 左对齐：Python基础 - # 右对齐（>）：总长度15，空白处补- print(f"右对齐：{title:>15s}-") # 右对齐： Python基础- # 居中对齐（^）：总长度15，空白处补- print(f"居中对齐：{title:^15s}-") # 居中对齐： Python基础 - # 6. 特殊场景处理 # 转义{}：用{{}}表示单个{}（f-string中{}是占位符，需转义） print(f"数学公式：{{x + y}} = {x + y}") # 数学公式：{x + y} = 40 # 原始f-string（rf/RF）：不转义字符串中的特殊字符（如\） file_path = r"C:\Users\Admin\Desktop" print(rf"文件路径：{file_path}") # 文件路径：C:\Users\Admin\Desktop # 嵌套f-string：在{}内再嵌套f-string（处理复杂格式化） product = "手机" price = 3999 discount = 0.85 print(f"商品信息：{f'{product}（折扣价）':<10s} ￥{price * discount:.0f}") # 输出：商品信息：手机（折扣价） ￥3399 ```1. 动态文本生成（如用户提示信息、日志记录、报告内容等）；2. 数据展示格式化（如数值精度控制、日期格式化、金额千分位显示等）；3. 字符串拼接（替代繁琐的+拼接，尤其是多变量拼接场景）；4. 函数/表达式结果嵌入（直接在字符串中嵌入计算逻辑，无需额外变量）；5. 命令行输出美化（如对齐展示表格数据、填充分隔符提升可读性）；6. 配置文件/模板生成（动态生成包含变量的配置内容或文本模板）1. 核心优势：语法简洁（直接嵌入变量，无需占位符映射）；执行高效（解释器直接解析，无需额外格式化步骤）；功能强大（支持表达式、函数、格式控制）；2. 版本要求：仅Python 3.6及以上版本支持，低版本需使用%格式化或str.format()；3. 格式说明符规则：{变量:格式说明符}，格式说明符由“填充符+对齐方式+宽度+类型”组成（部分可省略），如{pi:-^10.2f}表示“总长度10、居中对齐、补-、保留2位小数的浮点数”；4. 常见类型标识：d（整数）、f（浮点数）、s（字符串）、%（百分比）、e（科学计数法）；5. 性能对比：f-string > str.format() > %格式化，大量字符串格式化场景优先使用f-string；6. 注意事项：f-string中{}内的变量必须已定义，否则报错；嵌套f-string不宜过深（建议不超过2层），避免影响可读性；转义{}时需使用双大括号，不可遗漏；7. 扩展用法：可结合datetime模块实现日期格式化（如f"{datetime.now():%Y-%m-%d %H:%M:%S}"）。
字符串基础操作Python中字符串是不可变序列，用于表示文本数据。核心基础操作包括拼接、重复、切片、查找、替换、大小写转换等，支持多种字符串格式化方式，是处理文本数据的基础。```python # 1. 字符串定义（单引号、双引号、三引号） str1 = 'Hello' str2 = "Python" str3 = """这是 多行 字符串""" # 三引号支持多行文本 # 2. 基础操作：拼接、重复、长度 print(str1 + " " + str2) # 拼接：Hello Python print(str1 * 3) # 重复：HelloHelloHello print(len(str2)) # 长度：6 # 3. 字符串切片（[start:end:step]，左闭右开） s = "abcdefgh" print(s[0]) # 取单个字符：a print(s[2:5]) # 从索引2到4：cde print(s[:4]) # 从开头到3：abcd print(s[5:]) # 从5到结尾：fgh print(s[::2]) # 步长2，取偶数索引：aceg print(s[::-1]) # 步长-1，反转字符串：hgfedcba # 4. 常用字符串方法 text = " Hello Python World " # 去除首尾空格 print(text.strip()) # "Hello Python World" # 转换为小写/大写 print(text.lower()) # " hello python world " print(text.upper()) # " HELLO PYTHON WORLD " # 查找子串（返回索引，不存在返回-1） print(text.find("Python")) # 3 # 替换子串 print(text.replace("Python", "Java")) # " Hello Java World " # 分割字符串（返回列表） print("a,b,c".split(",")) # ["a", "b", "c"] # 判断开头/结尾 print(text.startswith("Hello")) # False（有空格） print(text.strip().endswith("World")) # True # 5. 字符串格式化（三种方式） name = "张三" age = 28 # 方式1：%格式化 print("姓名：%s，年龄：%d" % (name, age)) # 方式2：str.format() print("姓名：{}，年龄：{}".format(name, age)) # 方式3：f-string（Python 3.6+，推荐） print(f"姓名：{name}，年龄：{age}") ```1. 文本数据处理（如用户输入处理、文件内容读取与修改、日志文本生成）；2. 字符串格式化输出（如生成报告、拼接SQL语句、构造API请求参数）；3. 数据验证与清洗（如去除字符串空格、判断字符串格式、提取关键子串）；4. 文本匹配与替换（如批量修改文档中的特定文本、过滤敏感字符）；5. 所有涉及文本的场景（如网页爬虫的文本提取、自然语言处理的基础文本操作）1. 不可变特性：字符串创建后无法修改单个字符（如s[0] = "A"会报错），修改需创建新字符串；2. 索引规则：字符串索引从0开始（正向索引），也支持负索引（从-1开始，反向计数）；3. 切片特性：切片不会修改原字符串，返回新字符串；start/end/step均可省略，默认值分别为0、字符串长度、1；4. 字符串方法：所有字符串方法均返回新字符串，不修改原字符串；5. 格式化方式对比：%格式化兼容性好但繁琐；str.format()更灵活，支持位置参数、关键字参数；f-string最简洁高效，支持在{}内写表达式；6. 编码问题：Python 3中字符串默认是Unicode编码，支持所有字符；处理文件/网络数据时需注意编码转换（如str与bytes的转换）；7. 注意事项：拼接大量字符串时，避免使用+（效率低），推荐使用join()方法（如"".join(list)），效率更高。
...全文
38 回复 打赏 收藏 转发到动态 举报
写回复
用AI写文章
回复
切换为时间正序
请发表友善的回复…
发表回复
【Python】Python核心编程
Python核心编程 数据类型 数值类型（整数，浮点，布尔） 序列类型（字符串，列表，元组） 散列类型（字典，集合） 字节类型 a=bytes(‘123’)/a=b’123’ 字节数组bytearrary(‘123’) 数据类型的方法 字符串方法： 增：字符串拼接 1.str1+str2+str3 2.””.join([str1,str2,str3]) 3.’%s %s ...
Python核心编程笔记
简明Python教程 Python核心编程笔记
Python核心类型总结
Python核心类型总结 Python内置的核心数据类型如下表所示。 对象类型 分类 是否可变 数字 数值 否 字符串 序列 否 元组 序列 否 列表 序列 是 集合 集合 是 字典 映射 是 在使用的时候，需要我们注意的是python中的一切都是变量都是引用赋值的，除非你显示进行复制操作。变量本身没有数据类型，有数据类型的是对象。变量就是一个void *类型的指针。 列表，元组，字典可以包含任何种类的对象，可以任意嵌套。 集合只能包含不可变类型的对象 因为Pyt
python核心知识汇总
一、列表和元组 基本概念 列表和元组，都是一个可以放置任意数据类型的有序集合。其中列表是动态的，长度大小不固定，可以随意地增加、删减或者改变元素；而元组是静态的，长度大小固定，无法增加删减或者改变。 Python 中的列表和元组都支持负数索引，-1 表示最后一个元素，-2 表示倒数第二个元素，以此类推。 列表和元组都支持切片操作 列表和元组都可以随意嵌套 两者也可以通过 list() 和 tuple() 函数相互转换 列表和元组常用的内置函数： count(
python 列表主要元素代码
python 列表主要元素代码
OpenTK学习

3

社区成员

30

社区内容

发帖
与我相关
我的任务
社区描述
openTK、OpenGL、WebGL技术学习交流
图形渲染c#程序人生 技术论坛（原bbs） 广东省·深圳市
社区管理员
  • 亿只小灿灿
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章