• Python
  • 精通Python编程从零基础到实战
  • 8.1 Python初阶：基础语法
    • Python简介&环境搭建&以及环境变量原理
    • Python常用IDE以及免安装开发环境（如Anaconda、PyCharm等）
    • Python基础语法和基本数据类型（Number、String）
      • 一、基础语法
      • 二、基本数据类型：Number（数字）
      • 三、基本数据类型：String（字符串）
    • Python高级数据类型（Tuple、List、Set、Dict）
      • 一、List（列表）
      • 二、Tuple（元组）
      • 三、Set（集合）
      • 四、Dict（字典）
      • 总结对比
    • Python函数和模块基础知识以及高级应用
    • 一、函数基础
    • 二、模块基础
    • 一、定义包级别的变量
    • 二、定义包级别的函数
    • 三、高级技巧：控制包级成员的可见性
    • 四、注意事项
    • 三、包的导入方式
      • 1. 导入整个包
      • 2. 导入包中的模块
      • 3. 导入模块中的特定成员
      • 4. 导入子包
      • 5. 通配符导入（需 __all__ 支持）
    • 四、相对导入与绝对导入
    • 五、包的高级应用
      • 1. 命名空间包
      • 2. 条件导入
      • 3. 包的版本管理
      • 4. 包的分发
    • 六、最佳实践
    • 三、函数高级应用
      • 匿名函数（lambda）
    • 常见用途：
      • 2. 函数式编程工具
    • 一、核心内置函数
      • 1. map(func, iterable)
      • 2. filter(func, iterable)
      • 3. reduce(func, iterable[, initial])
    • 二、functools 模块工具
      • 1. functools.partial
      • 2. 装饰器（Decorators）
      • 3. 闭包（Closures）
      • 4. 迭代器与生成器函数
      • 2. 生成器表达式
        • yield 的作用
    • 四、函数式编程风格特点
    • 五、适用场景
    • 四、模块高级应用
      • 1. 模块重载
      • 2. 条件导入与延迟导入
      • 3. 模块私有成员
      • 4. 主模块判断
      • 5. 分布式模块结构
    • 五、实用技巧
    • Python运算符（算术、关系、赋值、逻辑、位、身份、三目等）
      • 一、算术运算符
      • 二、关系运算符（比较运算符）
      • 三、赋值运算符
      • 四、逻辑运算符
      • 五、位运算符
      • 六、身份运算符
      • 七、成员运算符
      • 八、三目运算符（条件表达式）
      • 九、运算符优先级（简化版）
    • Python流程控制之if判断
      • 一、基本语法
      • 二、单分支判断（仅 if）
      • 三、双分支判断（if-else）
      • 四、多分支判断（if-elif-else）
      • 五、条件表达式的类型
      • 六、嵌套 if 语句
      • 七、常见用法与技巧
      • 八、常见错误
    • Python流程控制之循环语句（While循环&For循环）
      • 一、while 循环：基于条件的重复
      • 二、for 循环：基于可迭代对象的遍历
      • 三、循环控制：break 与 continue
      • 四、嵌套循环
      • 五、while 循环 vs for 循环：适用场景对比
      • 六、常见错误与注意事项
      • 总结
    • Python流程控制之 try-except
      • 一、基本语法结构
      • 二、核心组件解析
      • 三、异常的传递性
      • 四、主动引发异常（raise）
      • 五、常见异常类型
      • 六、最佳实践
      • 示例：综合应用
  • Python：函数和类
    • 一、整体认知：代码组织的两种核心范式
    • 二、函数（Function）：封装独立功能的代码块
      • 1. 函数的基础：定义与调用
      • 2. 函数的核心特性：参数与返回值
      • 3. 函数的作用域：变量的可见范围
      • 4. 特殊函数类型：扩展函数的能力
    • 三、类（Class）：面向对象的核心载体
      • 1. 类的基础：定义与实例化
      • 2. 面向对象的三大特性
        • （1）封装：隐藏内部细节，暴露安全接口
        • （2）继承：复用代码，扩展功能
        • （3）多态：同一接口，不同实现
      • 3. 类的特殊成员
        • 一、类方法（@classmethod）
        • 二、静态方法（@staticmethod）
        • 三、类方法 vs 静态方法 vs 实例方法
        • 四、典型应用场景
        • 总结
        • 四、函数与类的区别与适用场景
        • 五、相关扩展概念
        • 总结
  • 8.2 Python初阶：函数和模块
    • Python函数（def）以及函数的分类
      • 一、函数的基本定义与调用
      • 二、函数的分类
      • 三、函数的核心特性
      • 总结
    • Python函数参数分类（必选参数&关键字参数&默认参数&不定长参数）
      • 一、必选参数（Positional Arguments）
      • 二、默认参数（Default Arguments）
      • 三、关键字参数（Keyword Arguments）
      • 四、不定长参数（Variable-Length Arguments）
      • 五、参数定义的顺序规则
      • 六、参数解包（Unpacking）
      • 总结
    • Python函数的嵌套、函数递归、匿名函数
      • 一、函数的嵌套（Nested Functions）
        • 1. 基本语法
        • 2. 核心特性
        • 3. 典型应用：闭包（Closure）
      • 二、函数递归（Recursion）
        • 1. 核心要素
        • 2. 基本示例：计算阶乘
        • 3. 常见应用场景
        • 4. 优缺点与注意事项
      • 三、匿名函数（Lambda Functions）
        • 1. 基本语法
        • 2. 与普通函数的对比
        • 3. 典型应用场景
        • 4. 局限性
        • 总结
      • Python函数装饰器（用例讲解）
        • 一、装饰器的基本原理
        • 二、装饰器用例详解
        • 三、装饰器的常见应用场景
        • 总结
    • Python模块和包的分类
      • 一、模块（Module）的分类
        • 1. 按来源分类（最常用）
        • 2. 按功能分类
        • 3. 按加载方式分类
      • 二、包（Package）的分类
        • 1. 按来源分类（与模块对应）
        • 2. 按结构分类
        • 3. 按功能分类
      • 三、模块与包的核心区别
      • 总结
    • Python模块的导入（import&from…import…）
      • 一、基本导入方式：import 模块名
        • 1. 基础用法
        • 2. 别名（as）：简化模块名
        • 3. 一次导入多个模块
      • 二、部分导入：from...import...
        • 1. 导入单个成员
        • 2. 导入多个成员
        • 3. 别名（as）：避免命名冲突
        • 4. 导入所有成员（*）
      • 三、从包中导入模块 / 成员
        • 1. 导入包中的模块（import）
        • 2. 从包中导入模块的成员（from...import...）
      • 四、导入的搜索路径
      • 五、常见问题与最佳实践
      • 总结
    • Python标准库（date, datetime, os模块, json模块, jsonpath模块, 文件处理）
      • 一、datetime 模块：日期与时间处理
        • 1. 核心类及用法
        • 2. 格式化与解析（strftime 与 strptime）
      • 二、os 模块：与操作系统交互
        • 1. 常用功能
      • 三、json 模块：JSON 数据处理
        • 1. 核心函数
        • 2. 注意事项
      • 四、jsonpath 模块：JSON 数据解析（非标准库）
        • 基本用法
      • 五、文件处理（内置 open 函数 + 标准库）
        • 1. 文件读写基础（open 函数）
        • 2. 高级文件操作（shutil 模块）
      • 总结
      • 六、资源管理
        • 一、with 语句的核心作用
        • 二、基本语法与执行流程
        • 三、为什么要用 with 语句？（对比手动管理）
        • 四、常见应用场景
        • 五、上下文管理器：with 语句的底层原理
        • 六、总结
    • Python输入输出（print&input及基础输出优化）
      • 一、输出函数：print()
      • 二、输入函数：input()
      • 三、输出优化：格式化输出技巧
        • 1. 百分号（%）格式（传统方式）
        • str.format() 方法（Python 3.0+）
        • 3. f-string（Python 3.6+，推荐）
        • 4. 对齐与填充（格式化进阶）
      • 四、总结与最佳实践
    • Python异常处理（捕获异常try…except…finally&抛出异常raise）
      • 一、异常的基本概念
      • 二、捕获异常：try...except...finally
        • 1. 基本结构与执行流程
        • 2. 核心组件解析
      • 三、抛出异常：raise
      • 四、异常处理的最佳实践
      • 五、总结
  • 8.3 Python高阶：面向对象编程
    • 面向对象编程（类的创建，init，self，del）
      • 一、类的创建：定义 “模板”
      • 二、对象的创建：实例化类
      • 三、__init__ 方法：初始化对象属性
      • 四、self：引用实例本身
      • 注意事项
      • 五、__del__ 方法：销毁对象时的清理
      • 六、综合示例：完整流程
      • 总结
    • 面向对象编程（类属性、实例属性、内置属性）
      • 一、类属性：类级别的共享数据
        • 1. 定义与访问
        • 2. 修改类属性
        • 3. 适用场景
      • 二、实例属性：对象独有的个性化数据
        • 1. 定义与访问
        • 2. 修改实例属性
        • 3. 动态添加实例属性
        • 4. 适用场景
      • 三、内置属性：Python 自带的特殊属性
        • 常用内置属性及说明
      • 四、类属性 vs 实例属性：核心区别
      • 五、总结
    • 面向对象编程（类方法、实例方法、内置方法、静态方法）
      • 一、实例方法：绑定到对象的方法
        • 1. 定义与特点
        • 2. 示例：Person 类的实例方法
        • 3. 适用场景
      • 二、类方法：绑定到类的方法
        • 1. 定义与特点
        • 2. 示例：Student 类的类方法
        • 3. 适用场景
      • 三、静态方法：与类和实例无关的方法
        • 1. 定义与特点
        • 2. 示例：MathUtil 类的静态方法
        • 3. 适用场景
      • 四、内置方法（魔术方法）：特殊功能的预定义方法
        • 1. 特点与核心作用
        • 2. 常用内置方法示例
        • 3. 示例：自定义 Book 类的内置方法
      • 五、四种方法的核心区别对比
      • 六、总结
    • 面向对象三大特性：封装、继承（继承的好处和多继承）、多态
      • 一、封装（Encapsulation）：隐藏细节，暴露接口
        • 1. 核心目的
        • 2. 实现方式（Python）
        • 3. 示例：封装 Person 类的年龄属性
      • 二、继承（Inheritance）：复用代码，扩展功能
        • 1. 继承的好处
        • 2. 基本实现（单继承）
        • 3. 多继承：一个子类继承多个父类
      • 三、多态（Polymorphism）：同一接口，不同实现
        • 1. 实现条件
        • 2. 示例：动物叫声的多态
        • 3. 多态的好处
      • 四、三大特性的关系总结
    • Python常用第三方库的应用
      • 一、Web 开发
        • 1. Flask：轻量级 Web 框架
        • 2. Django：全栈 Web 框架
        • 3. FastAPI：高性能 API 框架
      • 二、数据分析与科学计算
        • 1. pandas：数据处理核心库
        • 2. numpy：数值计算基础库
      • 三、数据可视化
        • 1. matplotlib：基础可视化库
        • 2. seaborn：统计可视化库
      • 四、自动化与工具
        • 1. requests：HTTP 网络请求库
        • 2. python-docx：操作 Word 文档
        • 3. PyPDF2/pdfplumber：PDF 处理
      • 五、机器学习与人工智能
        • 1. scikit-learn：机器学习入门库
        • 2. tensorflow/pytorch：深度学习框架
      • 六、安装第三方库的通用方法
      • 总结
    • Python面向对象和异常以及应用
      • 一、面向对象与异常处理的协同设计
      • 二、实例：图书管理系统（面向对象 + 异常处理）
        • 1. 定义自定义异常（错误类型）
        • 2. 设计 Book 类（封装图书信息）
        • 3. 设计 Library 类（管理图书，实现核心功能）
        • 4. 系统使用示例（多态与异常的实际交互）
      • 三、面向对象与异常处理结合的核心优势
      • 四、总结
      • 为何使用if name == “main”
        • 一、先理解 __name__ 变量
        • 二、if __name__ == "__main__": 的作用
        • 三、举个例子：直观理解
      • 四、为什么需要这个结构？
      • 五、总结
    • Python面向对象异常详解（类的缺陷，自定义缺陷）
      • 一、类的常见 “缺陷” 场景
      • 二、自定义异常：为类的 “缺陷” 定制错误类型
        • 1. 自定义异常的基本定义
        • 2. 在类中使用自定义异常处理 “缺陷”
        • 3. 调用类时捕获并处理自定义异常
      • 三、面向对象中异常处理的设计原则
      • 四、总结
  • 8.4 Python高阶：自动化框架专题
    • Logging日志处理模块（logging, FileHandler, StreamHandler, 日志等级）
      • 一、logging 模块的核心优势
      • 二、日志等级（Logging Levels）
      • 三、日志处理器（Handlers）
      • 四、日志格式化（Formatters）
      • 五、实战：自动化框架中的日志配置
        • 完整配置代码
        • 输出效果
      • 六、在自动化框架中的最佳实践
      • 总结
    • Python序列化和反序列化详解
      • 一、为什么需要序列化和反序列化？
      • 二、Python 常用序列化模块
        • 1. pickle：Python 专属序列化（推荐内部使用）
        • 2. json：跨语言通用序列化（推荐跨平台 / 网络使用）
        • 3. 其他序列化模块
      • 三、核心模块对比
      • 四、最佳实践
      • 总结
    • 外部数据库MySQL高级应用（MySqldb、Python操作实现CURD、事务机制）
      • 一、环境准备
        • 1. 依赖安装
        • 2. MySQL 服务准备
      • 二、Python 操作 MySQL 基础：连接与资源管理
        • 1. 核心连接参数
        • 2. 安全的连接管理（推荐 with 语句）
      • 三、核心应用：CURD 实现（参数化查询防注入）
        • 1. Create（插入数据）
          • （1）单条插入
          • （2）批量插入
        • 2. Read（查询数据）
          • （1）查询单条数据（按条件）
          • （2）查询多条数据（带分页）
          • 3. Update（更新数据）
          • 4. Delete（删除数据）
      • 四、高级应用：事务机制（保证数据一致性）
        • 1. 事务的 ACID 特性
        • 2. Python 中事务的控制
        • 3. 事务隔离级别（高级配置）
      • 五、性能优化：连接池（DBUtils）
      • 六、最佳实践与注意事项
      • 总结
    • 外部数据库Mysql常用管理（yum安装、yum卸载、pyyaml模块操作）
      • 一、YUM 安装 MySQL（CentOS/RHEL 系统）
      • 二、YUM 卸载 MySQL
      • 三、PyYAML 模块在 MySQL 管理中的应用
    • 外部配置文件Excel/Csv的读取（xlrd、xlwt、pandas、openpyxl、二次封装）
      • 一、核心库对比与适用场景
      • 二、Excel 文件读取（.xls/.xlsx）
      • 三、CSV 文件读取
      • 四、二次封装：通用文件读取工具类
      • 五、关键注意事项
      • 总结
    • Python正则表达式（json、Xpath、email、ip地址等）
      • 一、正则表达式核心语法（快速回顾）
      • 二、常见场景实战
        • 1. 邮箱地址（Email）验证
        • 2. IP 地址（IPv4）验证
        • 3. JSON 格式简易检查（非完整解析）
        • 4. XPath 表达式模式匹配
        • 5. 从文本中提取目标信息（综合示例）
      • 三、Python re 模块核心方法
      • 四、最佳实践与注意事项
      • 总结

Python

精通Python编程从零基础到实战

8.1 Python初阶：基础语法

Python简介&环境搭建&以及环境变量原理

Python常用IDE以及免安装开发环境（如Anaconda、PyCharm等）

Python基础语法和基本数据类型（Number、String）

一、基础语法

1. **注释**：用于解释代码，不被执行

单行注释：以 `#` 开头

 # 这是一条单行注释
 print("Hello World")  # 这也是注释，在代码后面

多行注释：用三个单引号 ''' 或三个双引号 """ 包裹

'''
这是多行注释第一行
这是多行注释第二行
'''

缩进：Python 用缩进来区分代码块，通常使用 4 个空格

if 5 > 2:
   print("5 大于 2")  # 缩进部分属于 if 代码块

  2. **变量**：用于存储数据，无需声明类型，直接赋值

x = 10  # 整数
name = "Alice"  # 字符串

  3. **关键字**：Python 保留的特殊单词，不能作为变量名，如 `if`、`else`、`for`、`while` 等

二、基本数据类型：Number（数字）

包含整数（int）、浮点数（float）、复数（complex）

  1. **整数（int）**：没有小数部分的数字

a = 10
b = 5
c = 0

  2. **浮点数（float）**：带小数部分的数字

x = 3.14
y = 0.5
z = 2.0  # 虽然值是整数，但类型是 float

  3. **复数（complex）**：由实部和虚部组成，虚部用 `j` 表示

m = 3 + 4j
n = 5j  # 实部为 0 的复数

  4. **数字运算**

# 基本运算
print(5 + 3)  # 加法，输出 8
print(10  4)  # 减法，输出 6
print(3 * 7)  # 乘法，输出 21
print(15 / 4)  # 除法，输出 3.75
print(15 // 4)  # 整除，输出 3
print(15 % 4)  # 取余，输出 3
print(2 **3)  # 幂运算，输出 8（2的3次方）

三、基本数据类型：String（字符串）

由字符组成的序列，用单引号 ' 或双引号 " 包裹

1.字符串定义

s1 = 'Hello'
s2 = "World"
s3 = ''' 多行字符串 ''' # 三个单引号可定义多行字符串

2.字符串访问 通过索引访问单个字符（索引从 0 开始）

s = "Python"
print(s[0])  # 输出 'P'
print(s[1])  # 输出 'n'（1 表示最后一个字符）

切片：获取子字符串 `[起始索引:结束索引:步长]`

s = "Hello World"
print(s[0:5])  # 输出 'Hello'（从索引0到4，不包含5）
print(s[6:])  # 输出 'World'（从索引6到结尾）
print(s[::2])  # 输出 'HloWrd'（步长为2，间隔取字符）

3.字符串常用操作 s = “Hello”

拼接字符串

print (s + “World”) # 输出 ‘Hello World’

重复字符串

print (s * 2) # 输出 ‘HelloHello’

字符串长度

print (len (s)) # 输出 5

转换为大写 / 小写

print (s.upper ()) # 输出 ‘HELLO’ print (s.lower ()) # 输出 ‘hello’

替换字符

print (s.replace (‘l’, ‘x’)) # 输出 ‘Hexxo’

分割字符串

print (“a,b,c”.split (‘,’)) # 输出 [‘a’, ‘b’, ‘c’]

Python高级数据类型（Tuple、List、Set、Dict）

Python 中的高级数据类型用于存储和组织复杂的数据集合，主要包括 Tuple（元组）、List（列表）、Set（集合）和 Dict（字典）。它们各有特点，适用于不同场景。

一、List（列表）

列表是有序、可变的元素集合，元素可以重复，用方括号 [] 表示。

  1. **定义与基本操作**

# 定义列表
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4]
mixed = [1, "hello", 3.14, True]  # 可包含不同类型元素

# 访问元素（通过索引）
print(fruits[0])  # 输出 'apple'
print(fruits[1])  # 输出 'cherry'（最后一个元素）

# 修改元素
fruits[1] = "orange"
print(fruits)  # 输出 ['apple', 'orange', 'cherry']

  2. **常用方法**

fruits = ["apple", "banana", "cherry"]

fruits.append("date")  # 添加元素到末尾
print(fruits)  # ['apple', 'banana', 'cherry', 'date']

fruits.insert(1, "blueberry")  # 在指定位置插入
print(fruits)  # ['apple', 'blueberry', 'banana', 'cherry', 'date']

fruits.remove("banana")  # 删除指定元素
print(fruits)  # ['apple', 'blueberry', 'cherry', 'date']

popped = fruits.pop()  # 删除并返回最后一个元素
print(popped)  # 'date'

print(len(fruits))  # 输出 3（列表长度）

二、Tuple（元组）

元组是有序、不可变的元素集合，元素可以重复，用圆括号 () 表示。

  1. **定义与特点**

# 定义元组
colors = ("red", "green", "blue")
single = (5,)  # 单个元素的元组需加逗号

# 访问元素（与列表相同）
print(colors[1])  # 输出 'green'

# 元组不可修改（会报错）
# colors[0] = "yellow"  # TypeError

  2. **常用操作**

numbers = (1, 2, 3, 4, 3)

print(len(numbers))  # 输出 5（长度）
print(numbers.count(3))  # 输出 2（元素出现次数）
print(numbers.index(2))  # 输出 1（元素首次出现的索引）

适用场景：存储不可变的数据（如坐标、配置信息），或作为字典的键。

三、Set（集合）

集合是无序、不可重复的元素集合，用大括号 {} 表示，或通过 set() 创建。

  1. **定义与去重特性**

# 定义集合
fruits = {"apple", "banana", "cherry", "apple"}  # 自动去重
print(fruits)  # 输出 {'apple', 'banana', 'cherry'}（顺序不固定）

# 从列表创建集合
numbers = set([1, 2, 3, 2, 4])
print(numbers)  # {1, 2, 3, 4}

  2. **常用方法与运算**

a = {1, 2, 3}
b = {3, 4, 5}

a.add(6)  # 添加元素
print(a)  # {1, 2, 3, 6}

a.remove(6)  # 删除元素

print(a.union(b))  # 并集 {1, 2, 3, 4, 5}
print(a.intersection(b))  # 交集 {3}
print(a.difference(b))  # 差集 {1, 2}

适用场景：去重、集合运算（如交集、并集）。

四、Dict（字典）

字典是键值对（keyvalue）的无序集合，键唯一且不可变，用 {key: value} 表示。

  1. **定义与访问**

# 定义字典
person = {
   "name": "Alice",
   "age": 30,
   "is_student": False
}

# 访问值（通过键）
print(person["name"])  # 输出 'Alice'
print(person.get("age"))  # 输出 30（get方法更安全，键不存在时返回None）

  2. **常用操作**

person = {"name": "Alice", "age": 30}

person["gender"] = "female"  # 添加新键值对
print(person)  # {'name': 'Alice', 'age': 30, 'gender': 'female'}

person["age"] = 31  # 修改值

del person["gender"]  # 删除键值对

print(person.keys())  # 所有键：dict_keys(['name', 'age'])
print(person.values())  # 所有值：dict_values(['Alice', 31])
print(person.items())  # 所有键值对：dict_items([('name', 'Alice'), ('age', 31)])

适用场景：存储关联数据（如用户信息、配置参数），通过键快速查找值。

总结对比

根据数据特性选择合适的类型，能让代码更高效、易读。例如：列表适合存储有序序列，字典适合存储键值关联数据，集合适合去重操作。

Python函数和模块基础知识以及高级应用

Python 的函数和模块是构建程序的核心组件，从基础到高级应用涵盖了丰富的编程思想和实践技巧。以下是系统的知识梳理：

一、函数基础

1. 函数定义与调用

函数通过def关键字定义，使用缩进区分代码块：

def greet(name):
    return f"Hello, {name}!"

print(greet("Python"))  # 调用函数

1. 参数类型

• 位置参数：按顺序传递的参数

位置参数是指按参数定义顺序传递的参数，必须按照函数定义时的参数顺序依次提供，否则会导致逻辑错误。

特点：

• 必须按顺序传递，数量需与函数定义一致（除非有默认值）

• 调用时直接写参数值，不指定参数名

• 关键字参数：指定参数名传递，可改变顺序

关键字参数是指通过 “参数名 = 值” 形式传递的参数，可以不按定义顺序传递，因为参数名明确指定了对应的参数。

特点：

• 传递时需指定参数名（参数名=值）
• 顺序可以任意调整
• 通常用于可选参数或默认参数

位置参数和关键字参数可以混合使用，但必须遵循 “位置参数在前，关键字参数在后” 的原则。

• 默认参数

  ：定义时指定默认值，调用时可省略

  def power(base, exp=2):
      return base **exp
  

• 可变参数：接受任意数量参数，用*表示元组，**表示字典

def sum_all(*args, **kwargs):
    total = sum(args)
    for k, v in kwargs.items():
        total += v
    return total

*args 与 **kwargs 的特殊作用

• *args：收集多余的位置参数，打包成元组（用于可变数量的位置参数）
• **kwargs：收集多余的关键字参数，打包成字典（用于可变数量的关键字参数）

1. 返回值

• 用return返回结果，可返回多个值（实际是元组）
• 无return时默认返回None

二、模块基础

1. 模块定义与导入

• 一个.py文件就是一个模块

• 导入方式：

  import module_name          # 导入整个模块
  from module_name import func  # 导入特定成员
  from module_name import *    # 导入所有成员（不推荐）
  import module_name as mn     # 别名导入
  

1. 包（Packages）

在 Python 中，包（Packages）是一种组织模块的层级结构，用于管理多个相关模块，使代码结构更清晰、可维护性更高。

• 定义：包是包含多个模块（.py文件）的目录，且必须包含一个特殊文件 __init__.py（Python 3.3+ 后允许省略，但仍推荐保留）
• 作用：避免模块名冲突，实现代码的模块化和层级化管理
• 结构：包可以嵌套，形成多层级结构
• 一个典型的包结构如下：

mypackage/
├── __init__.py
├── module1.py
├── module2.py
└── subpackage/
    ├── __init__.py
    └── module3.py

__init__.py 文件的作用

__init__.py 文件是包的标识，主要功能包括：

1. 初始化包：当包被导入时，会自动执行该文件中的代码
2. 控制导出内容：通过 __all__ 变量指定 from package import * 时导入的模块列表

# mypackage/__init__.py
__all__ = ['module1', 'module2']  # 定义可导出的模块

3.简化导入路径：在 __init__.py 中导入子模块，简化外部导入

# mypackage/__init__.py
from . import module1  # 这样外部可以直接 import mypackage.module1

1. 包级别的变量和函数：定义包级别的常量、函数等

在 Python 中，定义包级别的变量和函数可以让整个包内的模块共享数据或功能，也能对外提供统一的接口。这些变量和函数通常定义在包的 __init__.py 文件中，因为该文件会在包被导入时自动执行，是包的初始化入口。

一、定义包级别的变量

包级变量可以是常量、配置信息、版本号等，供整个包内的模块或外部导入者使用。

示例结构：

mypackage/
├── __init__.py
├── module1.py
└── module2.py

定义方式：在 __init__.py 中直接声明变量：

# mypackage/__init__.py

# 包版本号
__version__ = "1.0.2"

# 作者信息
__author__ = "Alice"

# 包级常量（如配置参数）
MAX_CONNECTIONS = 10
DEFAULT_TIMEOUT = 30

# 包级变量（可被修改）
global_counter = 0

使用方式：

1. 外部导入使用：

   import mypackage
   print(mypackage.__version__)  # 输出：1.0.2
   print(mypackage.MAX_CONNECTIONS)  # 输出：10
   

2. 包内部模块使用（如 module1.py）：

   # mypackage/module1.py
   from . import __version__, MAX_CONNECTIONS
      
   def get_version():
       return __version__
      
   def check_limit():
       return MAX_CONNECTIONS > 5
   

二、定义包级别的函数

包级函数是为整个包提供通用功能的函数，例如工具函数、初始化函数等，同样定义在 __init__.py 中。

定义方式：在 __init__.py 中定义函数：

# mypackage/__init__.py

# 包级函数：初始化包配置
def init_config(timeout=None):
    global DEFAULT_TIMEOUT
    if timeout:
        DEFAULT_TIMEOUT = timeout
    print(f"配置初始化完成，超时时间：{DEFAULT_TIMEOUT}")

# 包级工具函数
def format_message(msg):
    return f"[{__version__}] {msg}"

使用方式：

1. 外部调用：

   import mypackage
   mypackage.init_config(60)  # 调用包级函数修改配置
   print(mypackage.format_message("操作完成"))  # 输出：[1.0.2] 操作完成
   

2. 内部模块调用（如 module2.py）：

   # mypackage/module2.py
   from . import format_message
      
   def process():
       message = format_message("处理中")
       print(message)
   

三、高级技巧：控制包级成员的可见性

通过 __all__ 变量可以控制 from mypackage import * 时对外暴露的成员，避免内部实现细节被意外导入：

# mypackage/__init__.py

# 定义对外暴露的成员（变量、函数、模块）
__all__ = [
    "__version__", 
    "MAX_CONNECTIONS", 
    "init_config", 
    "format_message"
]

# 私有变量（不希望被外部导入）
_internal_secret = "hidden"

# 私有函数
def _helper():
    return _internal_secret

此时使用 from mypackage import * 只会导入 __all__ 中列出的成员，保护内部实现。

四、注意事项

1. 全局状态管理：包级变量是全局的，修改后会影响整个程序中使用该包的部分，需谨慎操作（尤其在多线程环境）。
2. 初始化逻辑：复杂的初始化代码（如读取配置文件、连接数据库）可以放在包级函数中，而非直接写在 __init__.py 顶层，避免导入包时就执行耗时操作。
3. 相对导入：包内部模块引用包级成员时，需使用相对导入（from . import xxx），避免绝对路径导致的可移植性问题。
4. 命名规范：
   • 公开的包级变量 / 函数使用常规命名（如 MAX_SIZE、setup()）。
   • 内部私有成员以单下划线开头（如 _internal_var），表示不建议外部使用。

通过这种方式，能够让包的结构更清晰，对外提供统一的接口，同时方便内部模块共享资源，是大型 Python 项目组织代码的常用技巧。

三、包的导入方式

导入包内模块：from package.subpackage import module

1. 导入整个包

import mypackage
# 使用：mypackage.module1.function()

2. 导入包中的模块

from mypackage import module1
# 或
import mypackage.module1 as m1

3. 导入模块中的特定成员

from mypackage.module1 import function1, ClassA

4. 导入子包

from mypackage.subpackage import module3
# 或
import mypackage.subpackage.module3

5. 通配符导入（需 __all__ 支持）

from mypackage import *  # 仅导入 __all__ 中指定的模块

四、相对导入与绝对导入

在包内部模块之间导入时，可以使用：

1. 绝对导入：从顶层包开始的完整路径

   # 在 subpackage/module3.py 中
   from mypackage.module1 import function1
   

2. 相对导入：使用 . 表示当前目录，.. 表示父目录（仅在包内部使用）

   # 在 subpackage/module3.py 中
   from ..module1 import function1  # 导入父包中的 module1
   from . import some_module        # 导入同目录下的模块
   

五、包的高级应用

1. 命名空间包

用于将多个目录合并为一个逻辑包，无需 __init__.py，适合大型项目的代码拆分：

project/
├── part1/
│   └── mypackage/
│       └── moduleA.py
└── part2/
    └── mypackage/
        └── moduleB.py

通过设置 PYTHONPATH 包含 part1 和 part2，可以将两个 mypackage 视为一个包。

2. 条件导入

根据不同环境导入不同模块，提高包的兼容性：

# mypackage/__init__.py
import sys
if sys.version_info >= (3, 10):
    from . import new_features
else:
    from . import legacy_support

3. 包的版本管理

在 __init__.py 中定义版本信息，方便用户查看：

# mypackage/__init__.py
__version__ = '1.0.0'
__author__ = 'Your Name'

用户可通过以下方式获取：

import mypackage
print(mypackage.__version__)  # 输出：1.0.0

4. 包的分发

将包打包为可安装的发行版，需创建 setup.py 或 pyproject.toml，例如：

# setup.py
from setuptools import setup, find_packages

setup(
    name="mypackage",
    version="1.0.0",
    packages=find_packages(),
)

六、最佳实践

1. 始终在包目录中添加 __init__.py，明确标识包并控制导出内容
2. 避免使用 from package import *，除非是有意设计的公共 API
3. 包内部优先使用相对导入，外部使用绝对导入
4. 大型项目采用分层结构，合理划分子包
5. 通过 __all__ 明确指定公共接口，隐藏内部实现细节

掌握包的使用可以帮助你构建结构清晰、易于维护的大型 Python 项目，是从脚本开发转向工程化开发的重要一步。

1. 模块搜索路径

Python 按以下顺序查找模块：

1. 当前目录
2. 环境变量PYTHONPATH指定的路径
3. Python 安装目录的标准库路径

可通过sys.path查看和修改搜索路径。

三、函数高级应用

1. 匿名函数（lambda）

简洁的单行函数，适用于简单逻辑：

add = lambda x, y: x + y
print(add(3, 5))  # 输出：8

​ 在 Python 中，lambda 是用于创建匿名函数的关键字，它允许你快速定义简单的、单行的函数，而无需使用 def 关键字进行完整的函数定义。

lambda 的特点：

1. 匿名性：lambda 函数没有正式名称，通常通过赋值给变量来使用
2. 简洁性：只能包含一个表达式，适合简单逻辑
3. 单行性：通常写在一行内
4. 表达式限制：只能是单个表达式，不能包含复杂结构（如循环、条件语句只能用三元表达式）

与普通函数的对比：

上面的 lambda 表达式等价于：

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

常见用途：

1. 作为简单函数的快捷方式，尤其是在需要临时函数的场景

2. 与高阶函数（如 map()、filter()、sorted()）配合使用：

   numbers = [(1, 3), (4, 1), (2, 5)]
   # 按元组第二个元素排序
   sorted_numbers = sorted(numbers, key=lambda x: x[1])
   

3. 作为回调函数或简单的处理逻辑

lambda 适合处理简单的运算或逻辑，对于复杂功能，仍建议使用 def 定义常规函数以保证可读性。

2. 函数式编程工具

• Python 提供了一系列函数式编程工具，这些工具允许你以函数为核心进行编程，强调使用纯函数、不可变数据和函数组合。以下是主要的函数式编程工具及其应用：

一、核心内置函数

1. map(func, iterable)

• 功能：将函数 func 应用于可迭代对象 iterable 的每个元素，返回一个迭代器。

  numbers = [1, 2, 3, 4]
  squared = map(lambda x: x** 2, numbers)
  print(list(squared))  # 输出：[1, 4, 9, 16]
  

2. filter(func, iterable)

• 功能：通过函数 func 过滤可迭代对象，保留 func 返回 True 的元素，返回迭代器。

  numbers = [1, 2, 3, 4, 5, 6]
  even_numbers = filter(lambda x: x % 2 == 0, numbers)
  print(list(even_numbers))  # 输出：[2, 4, 6]
  

3. reduce(func, iterable[, initial])

• 功能：从左到右累积应用函数 func 到可迭代对象的元素，最终得到单个结果（需从 functools 导入）。

  from functools import reduce
  numbers = [1, 2, 3, 4]
  product = reduce(lambda x, y: x * y, numbers)  # 1*2*3*4
  print(product)  # 输出：24
  

二、functools 模块工具

1. functools.partial

• 功能：固定函数的部分参数，生成一个新的简化函数（函数柯里化）。

• from functools import partial
      
  def power(base, exp):
      return base **exp
      
  square = partial(power, exp=2)  # 固定指数为2
  print(square(5))  # 输出：25（等价于 power(5, 2)）
  

2. 装饰器（Decorators）

动态增强函数功能，不修改原函数代码：

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        result = func(*args, **kwargs)
        print(f"{func.__name__} returned {result}")
        return result
    return wrapper

@log_decorator
def add(a, b):
    return a + b

add(2, 3)  # 会自动添加日志功能

@functools.wraps(func)：保留被装饰函数的元信息（如名称、文档字符串）。

from functools import wraps

def decorator(func):
    @wraps(func)  # 保留原函数信息
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@decorator
def add(a, b):
    """返回两数之和"""
    return a + b

print(add.__name__)  # 输出：add（而非 wrapper）
print(add.__doc__)   # 输出：返回两数之和

• @functools.lru_cache(maxsize)：缓存函数调用结果，优化重复计算（如递归、查询）。

  from functools import lru_cache
    
  @lru_cache(maxsize=None)  # 无限制缓存
  def fibonacci(n):
      if n <= 1:
          return n
      return fibonacci(n-1) + fibonacci(n-2)
    
  print(fibonacci(100))  # 快速计算，重复调用直接取缓存
  

• @functools.singledispatch：实现函数的单分派泛型（根据第一个参数类型动态选择实现）。

  from functools import singledispatch
    
  @singledispatch
  def process(data):
      raise NotImplementedError("未支持的数据类型")
    
  @process.register(int)
  def _(data):
      return f"整数: {data * 2}"
    
  @process.register(str)
  def _(data):
      return f"字符串: {data.upper()}"
    
  print(process(10))    # 输出：整数: 20
  print(process("hello"))  # 输出：字符串: HELLO
  

3. 闭包（Closures）

内层函数引用外层函数变量，形成封装的作用域：

def outer(x):
    def inner(y):
        return x + y
    return inner

add5 = outer(5)
print(add5(3))  # 输出：8

4. 迭代器与生成器函数

itertools 模块

提供了高效处理迭代器的工具函数，如：

• itertools.chain：拼接多个可迭代对象

  import itertools
  a = [1, 2]
  b = [3, 4]
  combined = itertools.chain(a, b)
  print(list(combined))  # 输出：[1, 2, 3, 4]
  

• itertools.islice：对迭代器进行切片

与列表的 [start:stop:step] 切片类似，但 islice 直接作用于迭代器（无需先转换为列表），更节省内存（尤其对大迭代器）。 注意：迭代器是一次性的，islice 会消耗迭代器元素。

import itertools

# 生成一个无限迭代器（0,1,2,3,...）
count = itertools.count(start=0, step=1)

# 从迭代器中取第2到第6个元素（左闭右开），步长为2
sliced = itertools.islice(count, 2, 6, 2)
print(list(sliced))  # 输出：[2, 4]

###

• itertools.groupby：按 key 分组

将迭代器中相邻的、具有相同 key 的元素分组。 注意：分组前需先按 key 排序，否则相同 key 可能被分到不同组。

import itertools

# 待分组的列表（先按key排序）
data = [('a', 1), ('a', 2), ('b', 3), ('b', 4), ('a', 5)]
data_sorted = sorted(data, key=lambda x: x[0])  # 按第一个元素排序

# 按第一个元素分组
groups = itertools.groupby(data_sorted, key=lambda x: x[0])

# 遍历分组结果
for key, group in groups:
    print(f"key: {key}, 元素: {list(group)}")
# 输出：
# key: a, 元素: [('a', 1), ('a', 2)]
# key: b, 元素: [('b', 3), ('b', 4)]
# key: a, 元素: [('a', 5)]  # 未排序的话，这里会被单独分组

• itertools.product：计算笛卡尔积

生成多个可迭代对象的所有可能组合（类似嵌套循环的结果）。

import itertools

a = [1, 2]
b = ['x', 'y']

# 计算a和b的笛卡尔积
product_result = itertools.product(a, b)
print(list(product_result))  # 输出：[(1, 'x'), (1, 'y'), (2, 'x'), (2, 'y')]

# 可指定repeat参数，计算自身的多次笛卡尔积
c = [0, 1]
product_self = itertools.product(c, repeat=2)  # 等价于product(c, c)
print(list(product_self))  # 输出：[(0, 0), (0, 1), (1, 0), (1, 1)]

这些函数返回的都是迭代器，可直接用于循环或转换为列表，适合处理大型数据集时减少内存占用。

2. 生成器表达式

轻量级迭代器，语法为 (expr for item in iterable)，适合惰性计算：

numbers = (x** 2 for x in range(10))  # 生成器表达式
print(next(numbers))  # 输出：0
print(next(numbers))  # 输出：1

使用yield返回迭代器，节省内存：

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

for num in fibonacci(5):
    print(num)  # 0, 1, 1, 2, 3

yield 的作用

yield 是 Python 中用于定义生成器函数的关键字，它的作用是：

• 暂停函数执行，并返回一个值（类似 return）。
• 下次调用生成器时，从上次暂停的位置继续执行（而不是从头开始）。

生成器的核心优势是惰性计算：不会一次性生成所有结果，而是按需产生，节省内存（尤其适合处理大量数据或无限序列）。

四、函数式编程风格特点

1. 纯函数优先：函数输出仅由输入决定，无副作用（不修改外部状态）。

2. 不可变数据：避免修改原有数据，而是返回新数据（如使用元组、冻结集合）。

3. 函数组合

   ：将复杂逻辑拆分为多个简单函数，通过组合实现功能。

   # 函数组合示例
   def add_one(x):
       return x + 1
      
   def multiply_two(x):
       return x * 2
      
   # 组合：先加1，再乘2
   def compose(f, g):
       return lambda x: f(g(x))
      
   result = compose(multiply_two, add_one)(3)  # (3+1)*2=8
   

五、适用场景

• 数据处理与转换（如列表推导的函数式替代）
• 并行计算（纯函数无副作用，适合并发）
• 配置化逻辑（通过函数组合动态构建功能）
• 简化代码（用内置函数替代循环）

这些工具的核心价值在于减少副作用、提高代码复用性，并使逻辑更简洁清晰。对于复杂场景，也可结合第三方库（如 toolz、fn）增强函数式编程能力。

四、模块高级应用

1. 模块重载

使用importlib.reload()重新加载已导入的模块：

import importlib
import my_module
importlib.reload(my_module)  # 重新加载模块

2. 条件导入与延迟导入

根据环境或条件导入模块，优化启动速度：

if platform.system() == "Windows":
    import windows_module as os_module
else:
    import unix_module as os_module

# 延迟导入（仅在需要时导入）
def heavy_operation():
    import heavy_module
    heavy_module.do_work()

3. 模块私有成员

以双下划线__开头的成员为私有，对外不可见（实际是名称修饰）：

# my_module.py
def __private_func():
    return "This is private"

def public_func():
    return __private_func()

4. 主模块判断

使用__name__ == "__main__"区分模块直接运行和被导入：

# 当模块直接运行时执行测试代码
if __name__ == "__main__":
    test_function()  # 仅在直接运行模块时执行

5. 分布式模块结构

大型项目中使用命名空间包、相对导入等组织代码：

# 相对导入（同一包内）
from . import module1
from .subpackage import module2

五、实用技巧

1.函数文档 ：使用文档字符串"""描述函数功能，可通过help()查看 2. 类型提示 ：增强代码可读性和 IDE 支持

def add(a: int, b: int) -> int:
    return a + b

3.缓存装饰器：functools.lru_cache缓存函数结果，优化性能

from functools import lru_cache

@lru_cache(maxsize=None)
def factorial(n):
    return n * factorial(n-1) if n else 1

掌握这些知识可以帮助你编写更模块化、高效和可维护的 Python 代码，从简单脚本到大型应用都能应对自如。

Python运算符（算术、关系、赋值、逻辑、位、身份、三目等）

Python 提供了丰富的运算符用于各种操作，按功能可分为以下几类：

一、算术运算符

用于基本数学运算，支持整数、浮点数等数值类型。

特殊用法：

• + 可用于字符串拼接："Hello" + " World" → "Hello World"
• * 可用于重复序列：[1] * 3 → [1, 1, 1]

二、关系运算符（比较运算符）

用于比较两个值，返回布尔值 True 或 False。

注意：

• == 比较值是否相等，is 比较身份（见下文 “身份运算符”）
• 支持链式比较：1 < 3 < 5 → True

三、赋值运算符

用于给变量赋值，可结合算术运算符简化写法。

多变量赋值：

a, b = 1, 2  # 同时给多个变量赋值
x = y = 10   # 链式赋值

四、逻辑运算符

用于组合布尔表达式，返回 True 或 False。

短路特性：

• and：左侧为 False 时，右侧不执行
• or：左侧为 True 时，右侧不执行

False and print("不会执行")  # 无输出
True or print("不会执行")   # 无输出

五、位运算符

对整数的二进制位进行操作。

| 运算符 | 描述 | 示例（二进制） | 结果（十进制） | | | | ———————————————————— | —————————— | —————————- | ————– | —- | —- | | & | 按位与（都为 1 则 1） | 0b1010 & 0b1100 → 0b1000 | 8 | | | | ` | 按位或（有 1 则 1） | 0b10100b1100→0b1110 | 14 | | | | | | ^ | 按位异或（不同则 1） | 0b1010 ^ 0b1100 → 0b0110 | 6 | | | | ~ | 按位取反（0 变 1，1 变 0） | ~0b1010 → -0b1011 | -11 | | | | « | 左移（高位丢弃，低位补 0） | 0b1010 « 1 → 0b10100 | 20 | | | | » | 右移（低位丢弃，高位补符号位） | 0b1010 » 1 → 0b101 | 5` | | |

应用场景：

• 权限控制（通过位标记表示不同权限）
• 数据压缩与加密
• 高效计算（如 x << 1 等价于 x * 2）

六、身份运算符

用于判断两个对象是否为同一个（内存地址相同）。

与 == 的区别：

• == 比较值是否相等
• is 比较内存地址是否相同（是否为同一个对象）

a = [1, 2]
b = [1, 2]
print(a == b)  # True（值相等）
print(a is b)  # False（不同对象）

注意：小整数（-5 到 256）和短字符串在 Python 中会被缓存，可能导致 is 返回 True：

x = 10
y = 10
print(x is y)  # True（缓存机制）

七、成员运算符

用于判断元素是否在序列（列表、字符串、元组等）中。

八、三目运算符（条件表达式）

简化 if-else 语句，格式：表达式1 if 条件 else 表达式2

示例：

x = 5
result = "正数" if x > 0 else "非正数"
print(result)  # "正数"

嵌套使用：

score = 85
grade = "优秀" if score >= 90 else "良好" if score >= 80 else "及格"
print(grade)  # "良好"

九、运算符优先级（简化版）

从高到低排序（可通过括号 () 改变优先级）：

1. 幂运算 **
2. 正负号 +x、-x
3. 算术运算符（*、/、//、% 高于 +、-）
4. 位运算符（~ 高于 <<、>> 高于 & 高于 ^ 高于 |）
5. 关系运算符（==、!=、>、< 等）
6. 身份运算符（is、is not）
7. 成员运算符（in、not in）
8. 逻辑非 not
9. 逻辑与 and
10. 逻辑或 or

示例：

print(2 + 3 * 4)  # 14（乘法优先于加法）
print((2 + 3) * 4)  # 20（括号改变优先级）

掌握这些运算符及其优先级，能帮助你写出简洁、高效的代码，避免因运算顺序导致的逻辑错误。

Python流程控制之if判断

在 Python 中，if 语句是最基础的流程控制结构之一，用于根据条件判断执行不同的代码块。它允许程序根据特定条件动态选择执行路径，是实现分支逻辑的核心工具。

一、基本语法

if 语句的基本结构由 if、可选的 elif（else if）和 else 组成，语法如下：

if 条件表达式1:
    # 条件1为True时执行的代码块
    语句1
elif 条件表达式2:
    # 条件1为False且条件2为True时执行的代码块
    语句2
elif 条件表达式3:
    # 前序条件都为False且条件3为True时执行的代码块
    语句3
else:
    # 所有条件都为False时执行的代码块
    语句4

关键点：

• 条件表达式的结果必须是布尔值（True 或 False）
• 代码块必须通过缩进（通常是 4 个空格）区分，缩进是 Python 语法的一部分
• elif 和 else 都是可选的，可根据需求组合使用

二、单分支判断（仅 if）

当只需要在条件满足时执行某些操作，不满足时不做处理，可使用单独的 if 语句：

age = 18
if age >= 18:
    print("已成年，可独立办理业务")

# 输出：已成年，可独立办理业务

如果条件不成立，则代码块不执行：

age = 16
if age >= 18:
    print("已成年")  # 条件不成立，此句不执行

三、双分支判断（if-else）

当需要根据条件二选一执行时，使用 if-else 结构：

score = 85
if score >= 60:
    print("考试通过")
else:
    print("考试未通过")

# 输出：考试通过

应用场景：二选一的逻辑，如 “登录成功 / 失败”“数据存在 / 不存在” 等。

四、多分支判断（if-elif-else）

当需要判断多个条件时，使用 if-elif-else 结构，程序会依次检查条件，执行第一个满足的分支：

score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
elif score >= 60:
    print("及格")
else:
    print("不及格")

# 输出：良好

注意：

• 条件判断是 “短路” 的，一旦某个条件成立，后续条件不再检查
• 条件顺序很重要，需从严格到宽松排列（如先判断 90 分以上，再判断 80 分以上）

五、条件表达式的类型

if 后的条件表达式不仅可以是比较运算，还可以是任何返回布尔值的表达式：

1. 比较运算（最常用）：

   x = 10
   if x > 5 and x < 15:  # 逻辑运算符组合条件
       print("x在5到15之间")
   

2. 成员判断（in/not in）：

   fruits = ["apple", "banana"]
   if "apple" in fruits:
       print("苹果在列表中")
   

3. 身份判断（is/is not）：

   a = None
   if a is None:
       print("变量a未赋值")
   

4. 真值判断（利用 Python 中 “假值” 的特性）： Python 中以下值被视为 False：None、0、""、[]、{}、() 等空对象。

   name = ""
   if not name:  # 空字符串视为False，not后变为True
       print("请输入姓名")
   

六、嵌套 if 语句

if 语句内部可以嵌套另一个 if 语句，用于处理更复杂的多层条件判断：

age = 20
has_id = True

if age >= 18:
    print("已成年")
    if has_id:
        print("可进入网吧")
    else:
        print("请出示身份证")
else:
    print("未成年，禁止进入")

# 输出：
# 已成年
# 可进入网吧

注意：嵌套层次越多，代码可读性越差，建议尽量控制嵌套层数（通常不超过 3 层）。

七、常见用法与技巧

1. 多条件并列： 使用逻辑运算符 and（且）、or（或）组合多个条件：

   # 判断年份是否为闰年（能被4整除且不能被100整除，或能被400整除）
   year = 2020
   if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
       print(f"{year}是闰年")
   

2. 与三目运算符结合： 简单的 if-else 可简化为三目表达式：

   # 等价于 if-else 结构
   result = "通过" if score >= 60 else "未通过"
   

3. 提前退出（卫语句）： 对于复杂条件，可先判断 “不满足条件” 的情况并提前退出，减少嵌套：

   def calculate(a, b):
       if b == 0:  # 提前判断异常情况
           print("除数不能为0")
           return
       # 正常逻辑（无需嵌套）
       print(a / b)
   

八、常见错误

1. 缩进错误：忘记缩进或缩进不一致会导致 IndentationError
2. 条件后缺少冒号：if、elif、else 后必须加冒号 :
3. 误用 = 代替 ==：if x = 5 是赋值而非判断，会导致语法错误
4. 条件顺序错误：如先判断 score >= 60 再判断 score >= 90，会导致高分条件永远不触发

if 语句是 Python 中实现分支逻辑的基础，掌握其用法能让程序根据不同情况做出灵活响应。在实际开发中，合理组织条件判断的结构，能显著提高代码的可读性和可维护性。

Python流程控制之循环语句（While循环&For循环）

在 Python 中，循环语句用于重复执行一段代码，是实现 “批量处理”“迭代遍历” 等逻辑的核心工具。主要分为 while 循环（基于条件重复）和 for 循环（基于可迭代对象遍历），两者适用场景不同，但都支持灵活的流程控制（如 break、continue）。

一、while 循环：基于条件的重复

while 循环的核心逻辑是：只要条件表达式为 True，就持续执行循环体，直到条件变为 False 时退出。

1. 基本语法

while 条件表达式:
    # 循环体（缩进代码块）
    语句1
    语句2
    # （可选）更新条件的语句（避免死循环）

执行流程：

1. 判断 条件表达式 的值（True/False）。
2. 若为 True，执行循环体；若为 False，退出循环，执行后续代码。
3. 循环体执行完毕后，回到步骤 1，重新判断条件（直到条件为 False）。

2. 典型示例

示例 1：基本计数循环（从 1 到 5）

count = 1  # 初始化计数器
while count <= 5:  # 条件：count不超过5
    print(f"当前计数：{count}")
    count += 1  # 更新计数器（关键：避免死循环）

# 输出：
# 当前计数：1
# 当前计数：2
# 当前计数：3
# 当前计数：4
# 当前计数：5

示例 2：用户输入验证（直到输入正确）

password = ""
while password != "123456":  # 条件：密码不正确则重复
    password = input("请输入密码：")
print("密码正确，登录成功！")

# 执行过程：
# 若输入错误（如"abc"），会反复提示输入；直到输入"123456"，退出循环。

3. 注意：避免死循环

while 循环的最大风险是死循环（条件永远为 True，循环永不退出），需确保循环体内有 “更新条件” 的逻辑：

# 错误示例：死循环（count始终为1，条件永远True）
count = 1
while count <= 5:
    print(count)
    # 缺少 count += 1，导致无限循环

# 正确示例：通过用户输入控制退出
while True:  # 条件恒为True，需手动控制退出
    user_input = input("输入'q'退出：")
    if user_input == "q":
        break  # 用break强制退出循环
    print(f"你输入的是：{user_input}")

二、for 循环：基于可迭代对象的遍历

for 循环的核心逻辑是：遍历 “可迭代对象”（如列表、字符串、元组等）中的每个元素，执行一次循环体，元素遍历完毕后自动退出。

Python 的 for 循环与其他语言（如 C/C++）的 “计数式 for 循环” 不同，更强调 “迭代遍历”，语法更简洁。

1. 基本语法

for 变量名 in 可迭代对象:
    # 循环体：变量名依次代表可迭代对象的每个元素
    语句1
    语句2

可迭代对象：指能被 for 循环遍历的对象，常见类型包括：

• 序列：列表（list）、字符串（str）、元组（tuple）
• 集合：集合（set）、字典（dict，默认遍历键）
• 生成器：range()、生成器表达式等

2. 典型示例

示例 1：遍历列表（批量处理元素）

fruits = ["apple", "banana", "orange"]
for fruit in fruits:  # fruit依次代表列表中的每个元素
    print(f"我喜欢吃：{fruit}")

# 输出：
# 我喜欢吃：apple
# 我喜欢吃：banana
# 我喜欢吃：orange

示例 2：遍历字符串（逐个字符）

text = "Python"
for char in text:  # char依次代表字符串的每个字符
    print(f"字符：{char}")

# 输出：
# 字符：P
# 字符：y
# 字符：t
# 字符：h
# 字符：o
# 字符：n

示例 3：遍历字典（键、值、键值对）

字典默认遍历 “键”，可通过 keys()、values()、items() 分别遍历键、值、键值对：

student = {"name": "Alice", "age": 18, "grade": "A"}

# 遍历键（默认）
for key in student:
    print(f"键：{key}")

# 遍历值
for value in student.values():
    print(f"值：{value}")

# 遍历键值对（用元组解包）
for key, value in student.items():
    print(f"{key}: {value}")

示例 4：range() 生成数字序列（模拟计数循环）

range() 是 Python 内置函数，生成一个 “不可见的数字序列”，常用于 for 循环的计数场景：

• range(n)：生成 0 ~ n-1 的整数（如 range(3) → 0,1,2）
• range(start, end)：生成 start ~ end-1 的整数（如 range(1,4) → 1,2,3）
• range(start, end, step)：指定步长（如 range(1,10,2) → 1,3,5,7,9）

# 示例：计算1~10的和
total = 0
for num in range(1, 11):  # 1到10（end=11，所以包含10）
    total += num
print(f"1~10的和：{total}")  # 输出：55

三、循环控制：break 与 continue

break 和 continue 是用于 “精细控制循环流程” 的关键字，可在循环体内根据条件调整执行逻辑。

1. break：强制退出循环

break 会立即终止当前循环，跳出循环体，执行循环后的代码（无论循环条件是否满足）。

示例：查找列表中的目标元素

numbers = [10, 20, 30, 40, 50]
target = 30

for num in numbers:
    if num == target:
        print(f"找到目标：{num}")
        break  # 找到后立即退出循环，不再遍历后续元素
    print(f"当前元素：{num}")

# 输出：
# 当前元素：10
# 当前元素：20
# 找到目标：30
# （40、50未被遍历）

1. continue：跳过当前迭代，进入下一次

continue 会跳过当前循环体的剩余代码，直接回到循环开头，判断下一次迭代是否执行（不终止整个循环）。

示例：打印 1~10 中的奇数

for num in range(1, 11):
    if num % 2 == 0:  # 若为偶数，跳过后续打印
        continue
    print(f"奇数：{num}")  # 仅奇数会执行此句

# 输出：
# 奇数：1
# 奇数：3
# 奇数：5
# 奇数：7
# 奇数：9

3. break 与 continue 的区别

四、嵌套循环

循环内部可以嵌套另一个循环（while 或 for 均可），用于处理 “多层结构” 的数据（如二维列表、矩阵等）。

示例：打印九九乘法表（for 嵌套）

# 外层循环控制行数（1~9）
for i in range(1, 10):
    # 内层循环控制每行的列数（1~i）
    for j in range(1, i+1):
        print(f"{j}×{i}={i*j}", end="\t")  # end="\t" 用制表符分隔
    print()  # 每行结束后换行

# 输出：
# 1×1=1	
# 1×2=2	2×2=4	
# 1×3=3	2×3=6	3×3=9	
# ...（直到9×9=81）

注意：嵌套循环的执行效率会随层数增加而降低，建议尽量控制嵌套层数（通常不超过 3 层）。

五、while 循环 vs for 循环：适用场景对比

六、常见错误与注意事项

1. while 循环的死循环：忘记更新循环条件（如 count 未递增），导致条件永远为 True。
2. for 循环修改可迭代对象：遍历列表时直接修改列表（如 del 或 append），可能导致遍历异常（建议遍历副本，如 for x in list.copy()）。
3. 缩进错误：循环体必须缩进（4 个空格），否则会报 IndentationError，或导致代码逻辑错误（如循环体外的代码被误判为循环内）。
4. range() 的边界问题：range(start, end) 包含 start 但不包含 end，需注意边界值（如 range(1,5) 是 1,2,3,4，而非 5）。

总结

• while 循环：适合 “条件驱动” 的重复场景，需手动控制循环变量和退出条件。
• for 循环：适合 “遍历驱动” 的场景，尤其对序列、集合等可迭代对象，语法更简洁高效。
• 循环控制：break 终止循环，continue 跳过当前迭代，可灵活调整执行逻辑。

掌握两种循环的用法和适用场景，能高效实现批量处理、数据遍历等核心需求，是编写 Python 程序的基础技能。

Python流程控制之 try-except

try-except 是 Python 中用于异常处理的核心结构，它允许程序在运行时捕获并处理错误，而不是直接崩溃。这种机制能显著提高程序的健壮性，尤其常用于处理不可预见的情况（如用户输入错误、文件操作失败等）。

一、基本语法结构

try-except 的基本框架如下：

try:
    # 可能发生异常的代码块（尝试执行）
    危险操作
except 异常类型1:
    # 当发生“异常类型1”时执行的代码
    处理方式1
except 异常类型2:
    # 当发生“异常类型2”时执行的代码
    处理方式2
else:
    # 当 try 块无异常常时执行的代码（可选）
    正常逻辑
finally:
    # 无论是否发生异常，都会执行的代码（可选）
    清理操作

执行流程：

1. 执行 try 块中的代码。
2. 如果发生异常，立即跳转到对应的 except 块处理。
3. 如果无异常，执行 else 块（若有）。
4. 最后一定会执行 finally 块（若有）。

二、核心组件解析

1. try 块

• 包含可能引发异常的代码（如文件操作、网络请求、数据转换等）。
• 一旦某行代码引发异常，后续代码不再执行，直接进入异常处理流程。

try:
    print("尝试转换数字...")
    num = int("abc")  # 这里会引发 ValueError
    print("转换成功")  # 此行不会执行（因为上一行已出错）

1. except 块：捕获指定异常

except 用于捕获特定类型的异常，并定义处理逻辑。

• 捕获单一异常：

  try:
      num = int("abc")
  except ValueError:  # 只处理 ValueError 类型的异常
      print("转换失败：输入不是有效数字")
  

• 捕获多个异常： 可以用元组指定多种异常类型，共用同一种处理逻辑：

  try:
      result = 10 / 0  # 可能引发 ZeroDivisionError
      # 或 num = int("abc")  # 可能引发 ValueError
  except (ZeroDivisionError, ValueError) as e:  # 用 as e 获取异常对象
      print(f"发生错误：{e}")  # 打印错误详情
  

• 捕获所有异常（不推荐）： 用 except Exception 可捕获几乎所有非系统退出的异常，但可能掩盖未知错误：

  try:
      risky_operation()
  except Exception as e:  # 捕获所有常规异常
      print(f"发生未知错误：{e}")
  

  注意：永远不要用空的 except 块（except:），这会隐藏所有错误，包括键盘中断（Ctrl+C）。

1. else 块（可选）

当 try 块没有发生任何异常时执行，用于分离 “正常逻辑” 和 “异常处理逻辑”：

try:
    num = int(input("请输入数字："))
except ValueError:
    print("输入错误")
else:
    # 只有转换成功时才执行
    print(f"你输入的数字是：{num}")

4. finally 块（可选）

无论是否发生异常，一定会执行的代码块，常用于资源清理（如关闭文件、释放连接等）：

file = None
try:
    file = open("data.txt", "r")
    content = file.read()
except FileNotFoundError:
    print("文件不存在")
finally:
    # 确保文件无论如何都会关闭
    if file:
        file.close()
        print("文件已关闭")

现代替代方案：对于文件、网络连接等资源，更推荐用 with 语句（自动管理资源），但 finally 仍适用于其他场景。

三、异常的传递性

如果异常在当前 try-except 中未被捕获，会向上层调用栈传递，直到被捕获或导致程序终止：

def func1():
    func2()  # 调用 func2，可能传递异常

def func2():
    num = int("abc")  # 引发 ValueError

try:
    func1()  # 调用链的顶层
except ValueError:
    print("在顶层捕获到异常")  # 会执行此句

四、主动引发异常（raise）

除了捕获系统自动引发的异常，也可以用 raise 主动抛出异常，用于验证输入或标记错误状态：

def withdraw(amount):
    if amount < 0:
        # 主动引发 ValueError，并附带错误信息
        raise ValueError("取款金额不能为负数")
    print(f"取款 {amount} 元成功")

try:
    withdraw(-100)
except ValueError as e:
    print(f"操作失败：{e}")  # 输出：操作失败：取款金额不能为负数

五、常见异常类型

Python 内置了多种异常类型，常见的有：

• ValueError：值无效（如 int("abc")）
• TypeError：类型错误（如 "2" + 2）
• ZeroDivisionError：除零错误
• FileNotFoundError：文件不存在
• PermissionError：权限不足
• IndexError：列表索引越界
• KeyError：字典键不存在
• AttributeError：对象属性不存在

可以通过官方文档查看完整的异常层级结构。

六、最佳实践

1. 捕获具体异常：避免用 except Exception 捕获所有异常，应针对性处理已知错误。
2. 提供有用信息：在异常处理中说明错误原因，便于调试（如 print(f"错误：{e}")）。
3. 清理资源优先：用 finally 或 with 语句确保资源（文件、网络连接等）被正确释放。
4. 不滥用异常：简单的条件判断（如 if x < 0）比 try-except 更高效，不应替代 if 使用。
5. 避免空 except 块：至少打印错误信息，否则难以排查问题。

示例：综合应用

def process_data(input_str):
    try:
        # 尝试转换为整数
        num = int(input_str)
    except ValueError as e:
        print(f"数据转换失败：{e}")
        return None  # 转换失败返回 None
    else:
        # 转换成功则处理数据
        result = num * 2
        print(f"处理后的数据：{result}")
        return result
    finally:
        # 无论成功失败，都记录日志
        print(f"处理结束，输入内容：{input_str}")

# 测试
process_data("10")   # 正常情况
process_data("abc")  # 异常情况

输出：

处理后的数据：20
处理结束，输入内容：10
数据转换失败：invalid literal for int() with base 10: 'abc'
处理结束，输入内容：abc

try-except 是编写健壮 Python 程序的必备工具，它让程序在面对错误时能优雅处理，而不是直接崩溃。合理使用异常处理，能显著提升代码的可靠性和用户体验。

Python：函数和类

在 Python 中，函数（Function） 和类（Class） 是组织代码的核心工具，分别对应函数式编程和面向对象编程两种主流范式。理解它们的设计目的、核心特性和适用场景，是掌握 Python 编程的基础。以下从整体框架到细节特性进行系统介绍：

一、整体认知：代码组织的两种核心范式

编程的本质是 “用代码解决问题”，而函数和类是两种不同的代码组织方式：

• 函数式编程 **：用函数 **封装独立功能，通过函数调用和参数传递实现逻辑（强调 “过程和操作”）。
• 面向对象编程（OOP：用**类 ** 封装数据和操作数据的方法，通过 “对象”（类的实例）交互实现逻辑（强调 “实体和关系”）。

举个生活例子：

• 函数像 “工具”（如 “计算器”），输入参数（如两个数字），输出结果（如和），专注于 “做什么”。
• 类像 “模板”（如 “汽车模板”），包含属性（如颜色、排量）和方法（如启动、刹车），实例化后的 “对象”（如一辆具体的车）既有数据又有行为，专注于 “是什么” 和 “能做什么”。

二、函数（Function）：封装独立功能的代码块

函数是一段实现特定功能的可重用代码，通过函数名调用，可接收输入（参数）并返回输出（结果）。

1. 函数的基础：定义与调用

用 def 关键字定义函数，基本语法：

def 函数名(参数列表):
    """文档字符串（描述函数功能、参数、返回值）"""
    # 函数体（实现功能的代码）
    return 返回值  # 可选，无return则默认返回None

示例：定义一个计算面积的函数

def calculate_area(radius):
    """计算圆的面积
    参数：
        radius: 圆的半径（正数）
    返回：
        圆的面积（π×radius²）
    """
    if radius <= 0:
        return 0  # 无效半径返回0
    return 3.14 * radius** 2

# 调用函数：传入参数，获取返回值
area = calculate_area(5)
print(area)  # 输出：78.5

2. 函数的核心特性：参数与返回值

函数的灵活性主要体现在参数传递和返回值处理上。

（1）参数类型：适配不同调用场景

• 必选参数：必须传递的参数，按位置匹配。

  def subtract(a, b):  # a和b是必选参数
      return a - b
  subtract(10, 3)  # 输出：7（a=10, b=3）
  

• 默认参数：定义时指定默认值，调用时可省略（简化常见场景）。

  def power(base, exp=2):  # exp默认值为2（平方）
      return base **exp
  power(3)  # 省略exp，用默认值 → 3²=9
  power(3, 3)  # 传递exp=3 → 3³=27
  

• 关键字参数：调用时用 参数名=值 传递，可打乱顺序（增强可读性）。

def greet(name, message):
    return f"{message}, {name}!"
greet(message="Hello", name="Alice")  # 顺序无关 → "Hello, Alice!"

• **不定长参数 **：接收任意数量的参数（参数数量不确定时使用）。

• *args：收集所有位置参数为元组。
• **kwargs：收集所有关键字参数为字典。

def print_info(*args, **kwargs):
    print("位置参数：", args)    # 元组形式
    print("关键字参数：", kwargs)  # 字典形式

print_info(1, 2, name="Bob", age=20)
# 输出：
# 位置参数： (1, 2)
# 关键字参数： {'name': 'Bob', 'age': 20}

（2）返回值：函数执行的结果

• 可返回单个值、多个值（自动打包为元组），或无返回值（默认返回none

  def divide(a, b):
      quotient = a // b    # 商
      remainder = a % b    # 余数
      return quotient, remainder  # 返回多个值（元组）
    
  q, r = divide(10, 3)  # 解包返回值
  print(f"商：{q}，余数：{r}")  # 输出：商：3，余数：1
  

3. 函数的作用域：变量的可见范围

函数内部的变量与外部变量相互隔离，避免命名冲突：

• **局部变量 **：函数内定义的变量，仅在函数内有效（函数执行结束后销毁）
• **全局变量 **：函数外定义的变量，可在函数内访问（需用 global 声明才能修改）。
• **非局部变量 **：嵌套函数中，内部函数修改外部函数的变量需用 nonlocal 声明。

x = 10  # 全局变量

def outer():
    y = 20  # 外部函数的局部变量
    def inner():
        nonlocal y  # 声明修改外部函数的变量
        y = 200
        global x    # 声明修改全局变量
        x = 100
    inner()
    print(y)  # 输出：200（被inner修改）

outer()
print(x)  # 输出：100（被inner修改）

4. 特殊函数类型：扩展函数的能力

• 匿名函数（lambda）：用 lambda 定义的单行短函数，无名称，适用于简单逻辑（作为参数传递时常用）。

# 等价于 def add(x,y): return x+y
add = lambda x, y: x + y
print(add(2, 3))  # 输出：5

# 作为sorted的排序键
students = [("Alice", 20), ("Bob", 18)]
sorted_students = sorted(students, key=lambda s: s[1])  # 按年龄排序

-**递归函数 **：函数调用自身，用于分治问题（将复杂问题分解为同类子问题）。

def factorial(n):
    if n == 1:  # 基线条件（终止递归）
        return 1
    return n * factorial(n-1)  # 递归调用（n! = n × (n-1)!）

print(factorial(5))  # 输出：120（5×4×3×2×1）

• **生成器函数 **：用 yield 关键字返回迭代器，惰性生成数据（节省内存，适合大数据场景）。

def generate_even_numbers(n):
    for i in range(n):
        if i % 2 == 0:
            yield i  # 每次返回一个偶数，暂停执行

# 迭代生成器（逐个获取值）
for num in generate_even_numbers(10):
    print(num, end=" ")  # 输出：0 2 4 6 8

• **高阶函数 **：接收函数作为参数，或返回函数（实现函数的灵活组合）。

def apply(func, x, y):
    """接收函数作为参数并调用"""
    return func(x, y)

# 传递lambda函数作为参数
print(apply(lambda a, b: a * b, 3, 4))  # 输出：12

三、类（Class）：面向对象的核心载体

类是描述 “对象” 共同属性和行为的模板，而 “对象” 是类的具体实例。面向对象编程通过类和对象实现 “封装、继承、多态” 三大特性，更适合描述复杂实体（如 “用户”“订单”“汽车”）。

1. 类的基础：定义与实例化

用 class 关键字定义类，通过类创建对象（实例化）：

class 类名:
    # 类属性（所有实例共享的变量）
    类变量 = 值
    
    def __init__(self, 参数):  # 构造方法（初始化对象）
        # 实例属性（每个实例独有的变量，用self.xxx定义）
        self.实例变量1 = 参数1
        self.实例变量2 = 参数2
    
    def 方法名(self, 参数):  # 实例方法（操作实例的行为）
        # 方法体（可访问self.实例变量）
        return 结果

示例：定义一个 “学生” 类并创建对象

class Student:
    # 类属性：所有学生共享的学校名称
    school = "阳光中学"
    
    # 构造方法：初始化学生的姓名和年龄
    def __init__(self, name, age):
        self.name = name  # 实例属性：姓名（每个学生不同）
        self.age = age    # 实例属性：年龄（每个学生不同）
    
    # 实例方法：学生打招呼
    def greet(self):
        return f"大家好，我是{self.name}，今年{self.age}岁，来自{self.school}。"

# 实例化：创建两个Student对象（具体学生）
student1 = Student("小明", 15)
student2 = Student("小红", 14)

# 访问对象的属性和方法
print(student1.name)       # 输出：小明（实例属性）
print(student1.school)     # 输出：阳光中学（类属性）
print(student1.greet())    # 输出：大家好，我是小明，今年15岁，来自阳光中学。

2. 面向对象的三大特性

（1）封装：隐藏内部细节，暴露安全接口

将数据（属性）和操作数据的方法捆绑在类中，通过 “访问控制” 保护数据（Python 用命名规范实现）：

• 公开属性 / 方法：直接访问（如 self.name）。
• 私有属性 / 方法：用 _ 或 __ 前缀（约定不直接访问，通过公开方法操作）。

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # 私有属性（双下划线，强制隐藏）
    
    # 公开方法：安全操作私有属性
    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
    
    def get_balance(self):
        return self.__balance

account = BankAccount(1000)
account.deposit(500)
print(account.get_balance())  # 输出：1500
# print(account.__balance)  # 报错：无法直接访问私有属性

（2）继承：复用代码，扩展功能

子类（派生类）继承父类（基类）的属性和方法，并可添加新属性 / 方法或重写父类方法（避免重复代码）。

# 父类：Person
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def greet(self):
        return f"我是{self.name}，{self.age}岁。"

# 子类：Student（继承Person）
class Student(Person):
    def __init__(self, name, age, grade):
        # 调用父类的构造方法（复用初始化逻辑）
        super().__init__(name, age)
        self.grade = grade  # 新增属性：年级
    
    # 重写父类的greet方法（扩展功能）
    def greet(self):
        return f"我是{self.name}，{self.age}岁，读{self.grade}年级。"

student = Student("小李", 13, 7)
print(student.greet())  # 输出：我是小李，13岁，读7年级。（调用重写后的方法）

（3）多态：同一接口，不同实现

不同类的对象调用同名方法时，表现出不同行为（通过方法重写实现），提高代码灵活性。

# 定义一个通用函数（接收Person或其子类对象）
def introduce(person):
    print(person.greet())  # 调用greet()，行为取决于对象类型

p = Person("老王", 40)
s = Student("小张", 16, 10)

introduce(p)  # 输出：我是老王，40岁。（调用Person的greet）
introduce(s)  # 输出：我是小张，16岁，读10年级。（调用Student的greet）

3. 类的特殊成员

• 特殊方法（魔术方法）：以 __ 开头和结尾，用于实现类的特殊行为（如初始化、字符串表示、运算符重载）。

  class Book:
      def __init__(self, title, price):
          self.title = title
          self.price = price
        
      def __str__(self):  # 打印对象时调用（友好显示）
          return f"《{self.title}》，价格：{self.price}元"
        
      def __add__(self, other):  # 重载+运算符
          return self.price + other.price
    
  book1 = Book("Python入门", 50)
  book2 = Book("Python进阶", 70)
    
  print(book1)        # 输出：《Python入门》，价格：50元（调用__str__）
  print(book1 + book2)  # 输出：120（调用__add__）
  

• 类方法与静态方法：

  • 类方法（@classmethod）：操作类属性，第一个参数为 cls（代表类本身）。
  • 静态方法（@staticmethod）：与类和实例无关，无默认参数（类似独立函数，只是放在类中组织）。

  class MathUtil:
      pi = 3.14  # 类属性：圆周率
        
      @classmethod
      def circle_area(cls, radius):  # 类方法：用cls访问类属性
          return cls.pi * radius **2
        
      @staticmethod
      def add(a, b):  # 静态方法：与类属性无关
          return a + b
    
  # 调用类方法（无需创建对象）
  print(MathUtil.circle_area(2))  # 输出：12.56
  # 调用静态方法
  print(MathUtil.add(2, 3))      # 输出：5
  

这段代码展示了 Python 中类的两种特殊方法：类方法（@classmethod） 和 静态方法（@staticmethod），它们与普通的实例方法（def method(self):）在功能和使用场景上有显著区别。以下是详细解析：

一、类方法（@classmethod）

类方法是与类本身绑定的方法，而非与类的实例绑定。它的核心特点是：

1. 定义与参数

• 用 @classmethod 装饰器声明。
• 第一个参数必须是 cls（约定俗成的名称，代表类本身，类似实例方法的 self）。
• 通过 cls 可以访问和修改类属性（所有实例共享的属性），但不能直接访问实例属性（需通过实例对象）。

2. 代码解析（circle_area 方法）

class MathUtil:
    pi = 3.14  # 类属性（所有实例共享）
    
    @classmethod
    def circle_area(cls, radius):
        # 通过 cls 访问类属性 pi
        return cls.pi * radius **2

• **调用方式 **：可通过类名直接调用（无需创建实例），也可通过实例调用：

# 类名直接调用（推荐）
print(MathUtil.circle_area(2))  # 输出：12.56（3.14 × 2²）

# 实例调用（也可行，但逻辑上没必要创建实例）
mu = MathUtil()
print(mu.circle_area(2))  # 输出：12.56

• **核心作用 **：操作类属性或实现与类相关的逻辑（如创建 “替代构造函数”）。 例如，扩展一个根据直径计算面积的类方法：

@classmethod
def circle_area_by_diameter(cls, diameter):
    radius = diameter / 2
    return cls.circle_area(radius)  # 调用同类的其他类方法

MathUtil.circle_area_by_diameter(4)  # 直径4 → 半径2 → 面积12.56

二、静态方法（@staticmethod）

静态方法是定义在类中的普通函数，它与类和实例都没有绑定关系。核心特点是：

1. 定义与参数

• 用 @staticmethod 装饰器声明。
• 没有默认参数（既不需要 self，也不需要 cls）。
• 不能直接访问类属性或实例属性（除非通过参数传递类或实例对象）。

2. 代码解析（add 方法）

class MathUtil:
    @staticmethod
    def add(a, b):
        # 仅依赖输入参数，与类属性/实例属性无关
        return a + b

• **调用方式 **：同样可通过类名或实例调用，但逻辑上与类无关：

# 类名调用（推荐）
print(MathUtil.add(2, 3))  # 输出：5

# 实例调用（可行，但无意义）
mu = MathUtil()
print(mu.add(2, 3))  # 输出：5

• **核心作用 **：封装与类相关但不依赖类状态的工具逻辑（相当于 “放在类里的普通函数”，仅为了代码组织）。 例如，添加一个判断数字是否为偶数的静态方法：

@staticmethod
def is_even(num):
    return num % 2 == 0

MathUtil.is_even(4)  # 输出：True

三、类方法 vs 静态方法 vs 实例方法

为了更清晰区分，对比三种方法的核心差异：

四、典型应用场景

1.**类方法的典型场景 **：

• 访问 / 修改类属性（如 circle_area 中使用 cls.pi）。

• 实现 “替代构造函数”（通过不同参数创建实例）：

  class Date:
      def __init__(self, year, month, day):
          self.year = year
          self.month = month
          self.day = day
        
      @classmethod
      def from_string(cls, date_str):  # 从字符串创建日期（如 "2023-10-01"）
          year, month, day = map(int, date_str.split("-"))
          return cls(year, month, day)  # 返回新实例
    
  date = Date.from_string("2023-10-01")  # 替代构造函数
  

2.**静态方法的典型场景 **：

• 封装与类相关的工具函数（如数学计算、数据验证）。

• 避免创建独立的工具模块，将相关函数组织在类中：

  class StringUtil:
      @staticmethod
      def is_email(s):  # 验证邮箱格式（与类状态无关）
          return "@" in s and "." in s
  

总结

• 类方法（@classmethod）：依赖类本身（通过 cls 访问类属性），用于类级别的操作。

• 静态方法（@staticmethod）：与类和实例均无关，仅为代码组织而放在类中，功能上等价于独立函数。

选择原则：

• 需要访问类属性 → 用类方法。
• 不需要访问类 / 实例属性，但逻辑上属于该类 → 用静态方法。
• 需要访问实例属性 → 用普通实例方法（self 参数）。

四、函数与类的区别与适用场景

五、相关扩展概念

• 模块（Module）：以 .py 为扩展名的文件，用于组织函数、类和变量（通过 import 导入复用）。
• 包（Package：包含多个模块的目录（需有 __init__.py），用于大型项目的代码分层（如 src/、utils/）。
• 装饰器（Decorator）：动态给函数或类添加功能（如日志、缓存），本质是高阶函数（或类）。

总结

• 函数是 “功能的封装”，专注于 “做什么”，适合实现独立、无状态的操作
• **类 ** 是 “实体的模板”，专注于 “是什么” 和 “能做什么”，适合描述复杂对象及其行为，支持封装、继承、多态。

在实际开发中，函数和类并非对立关系：类中可以包含函数（方法），函数也可以操作类的对象。合理结合两者，才能写出简洁、可维护的代码。例如：用类建模 “用户”，用函数实现 “用户数据的批量导入”（工具逻辑）。

8.2 Python初阶：函数和模块

Python函数（def）以及函数的分类

在 Python 中，函数（用 def 关键字定义）是封装可重用代码的基本单元，它将一系列操作打包成一个独立模块，通过函数名调用。函数不仅能简化代码、提高复用性，还能让程序结构更清晰。

一、函数的基本定义与调用

使用 def 关键字定义函数的基本语法：

def 函数名(参数列表):
    """函数文档字符串（可选，用于描述功能）"""
    # 函数体（缩进代码块）
    执行语句
    return 返回值  # 可选，无return则默认返回None

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

def add(a, b):
    """返回两个数的和"""
    return a + b

# 调用函数
result = add(3, 5)
print(result)  # 输出：8

二、函数的分类

根据函数的定义者、参数形式和功能，可分为以下几类：

1. 按定义者分类

（1）内置函数（Built-in Functions）

Python 解释器自带的函数，无需定义可直接使用，如 print()、len()、max() 等。 示例：

print(len([1, 2, 3]))  # 内置函数 len() 计算列表长度，输出：3

（2）自定义函数（User-defined Functions）

由开发者使用 def 关键字定义的函数，用于实现特定业务逻辑。 示例：

def calculate_area(radius):
    """计算圆的面积"""
    return 3.14 * radius **2

（3）第三方库函数

来自第三方库（如 numpy、pandas）提供的函数，需先安装并导入库才能使用。 示例：

import numpy as np
print(np.mean([1, 2, 3, 4]))  # 第三方库 numpy 的均值函数，输出：2.5

1. 按参数形式分类

（1）无参函数

函数定义时没有参数，调用时也无需传递参数，适用于固定逻辑的操作。 示例：

def say_hello():
    print("Hello, World!")

say_hello()  # 调用时无需传参，输出：Hello, World!

（2）有参函数

函数定义时包含参数，调用时需按要求传递参数，灵活性更高。 示例：

def greet(name):  # 单个参数
    print(f"Hello, {name}!")

greet("Alice")  # 传递参数，输出：Hello, Alice!

（3）默认参数函数

参数在定义时指定默认值，调用时可省略该参数（使用默认值）。 示例：

def power(base, exp=2):  # exp 的默认值为 2
    return base** exp

print(power(3))    # 省略 exp，使用默认值 2 → 3²=9
print(power(3, 3)) # 传递 exp=3 → 3³=27

（4）可变参数函数

通过 *args（接收任意数量的位置参数）和 **kwargs（接收任意数量的关键字参数）实现，适用于参数数量不确定的场景。 示例：

def sum_all(*args, **kwargs):
    """计算所有位置参数的和，忽略关键字参数"""
    return sum(args)

print(sum_all(1, 2, 3))  # 位置参数：1+2+3=6
print(sum_all(10, 20, x=30, y=40))  # 关键字参数 x、y 被忽略，结果：30

3. 按返回值分类

（1）无返回值函数

函数体内没有 return 语句，或 return 后无值，默认返回 None，通常用于执行打印、修改全局变量等操作。 示例：

def log(message):
    print(f"[LOG] {message}")  # 仅打印，无返回值

result = log("操作完成")
print(result)  # 输出：None

（2）有返回值函数

函数通过 return 语句返回一个或多个值（多个值以元组形式返回）。 示例：

def divide(a, b):
    quotient = a // b
    remainder = a % b
    return quotient, remainder  # 返回多个值（元组）

q, r = divide(10, 3)  # 解包返回值
print(f"商：{q}，余数：{r}")  # 输出：商：3，余数：1

1. 特殊类型函数

（1）匿名函数（lambda 函数）

用 lambda 关键字定义的单行函数，无函数名，适用于简单逻辑。 示例：

add = lambda x, y: x + y  # 等价于 def add(x,y): return x+y
print(add(2, 3))  # 输出：5

（2）递归函数

在函数体内调用自身的函数，适用于分治问题（如阶乘、斐波那契数列）。 示例：

def factorial(n):
    if n == 1:  # 基线条件（终止递归）
        return 1
    return n * factorial(n-1)  # 递归调用自身

print(factorial(5))  # 输出：120（5×4×3×2×1）

（3）高阶函数

接受函数作为参数，或返回函数的函数，是函数式编程的核心。 示例：

def apply_func(func, x, y):
    """接受函数作为参数并调用"""
    return func(x, y)

# 传递 lambda 函数作为参数
result = apply_func(lambda a, b: a * b, 3, 4)
print(result)  # 输出：12

（4）生成器函数

使用 yield 关键字返回迭代器的函数，可惰性生成数据（节省内存）。 示例：

def generate_numbers(n):
    for i in range(n):
        yield i  # 每次调用返回一个值，暂停执行

# 迭代生成器
for num in generate_numbers(3):
    print(num)  # 输出：0、1、2

三、函数的核心特性

1.** 封装性 ：将逻辑隐藏在函数内部，外部只需关注输入输出，无需了解实现细节。 2. 复用性 ：定义一次可在多处调用，减少重复代码。 3. 作用域 **：函数内定义的变量为局部变量，仅在函数内有效；函数外的变量为全局变量（需用 global 声明才能在函数内修改）。

global_var = 10  # 全局变量

def modify_var():
    local_var = 20  # 局部变量
    global global_var  # 声明使用全局变量
    global_var = 100

modify_var()
print(global_var)  # 输出：100（已被修改）
# print(local_var)  # 报错：局部变量在函数外不可访问

总结

函数是 Python 编程的基础组件，通过 def 定义的自定义函数可根据参数形式、返回值和功能分为多种类型。合理使用不同类型的函数能显著提升代码的可读性、复用性和可维护性。在实际开发中，应根据场景选择合适的函数类型（如用生成器处理大数据，用递归解决分治问题），并遵循 “单一职责” 原则（一个函数只做一件事）。

Python函数参数分类（必选参数&关键字参数&默认参数&不定长参数）

Python 函数的参数体系灵活且强大，根据传递方式和特性可分为四大类：必选参数、默认参数、关键字参数和不定长参数。掌握这些参数类型的用法，能让函数定义更灵活，调用更清晰。

一、必选参数（Positional Arguments）

定义：必须按顺序传递的参数，函数调用时必须提供对应的值，否则会报错。 特点：

• 定义在参数列表最前面
• 调用时数量和顺序必须与定义一致

示例：

def add(a, b):  # a 和 b 都是必选参数
    return a + b

add(2, 3)  # 正确：传递 2 个参数
add(2)     # 错误：缺少必选参数 b（TypeError: add() missing 1 required positional argument: 'b'）

二、默认参数（Default Arguments）

定义：在函数定义时指定默认值的参数，调用时可省略（使用默认值）。 特点：

• 定义时用 参数名=默认值 形式
• 必须放在必选参数后面（否则语法错误）
• 调用时若提供值，则覆盖默认值；若省略，则使用默认值

示例：

def greet(name, message="Hello"):  # message 是默认参数
    return f"{message}, {name}!"

greet("Alice")          # 省略默认参数，使用默认值 → "Hello, Alice!"
greet("Bob", "Hi")      # 提供值，覆盖默认值 → "Hi, Bob!"
greet(message="Hi", name="Charlie")  # 结合关键字参数，顺序可调整 → "Hi, Charlie!"

注意：默认参数的默认值**只在函数定义时计算一次，若默认值是可变对象（如列表、字典），可能导致意外行为：

def add_item(item, lst=[]):  # 危险：默认值是可变列表
    lst.append(item)
    return lst

print(add_item(1))  # [1]
print(add_item(2))  # [1, 2]（而非预期的 [2]，因为默认列表被复用）

推荐：默认值为可变对象时，用 None 初始化，在函数内创建新对象：

def add_item(item, lst=None):
    if lst is None:
        lst = []  # 每次调用创建新列表
    lst.append(item)
    return lst

三、关键字参数（Keyword Arguments）

定义：调用函数时通过 参数名=值 形式传递的参数，与定义顺序无关。 特点：

• 本质是传递方式的分类（而非定义方式），可用于任何参数类型
• 必须放在位置参数后面（调用时）
• 增强代码可读性，明确参数含义

示例：

def describe_person(name, age, city):
    return f"{name} is {age} years old, from {city}."

# 纯位置参数（顺序必须严格对应）
describe_person("Alice", 30, "Beijing")

# 混合位置参数和关键字参数（关键字参数必须在后）
describe_person("Bob", city="Shanghai", age=25)  # 顺序无关

# 纯关键字参数
describe_person(name="Charlie", age=35, city="Guangzhou")