Python 高级特性
1.装饰器基础 — 理解 “功能增强”
语法结构：
def 装饰器函数(原函数):def 新函数(*args, **kwargs):新增功能（比如计时开始）result = 原函数(*args, **kwargs)新增功能（比如计时结束）return resultreturn 新函数
·*args, **kwargs 是万能参数，适配任何带参 / 无参函数
示例：
import time
# 导入Python内置的time模块，用于获取时间和实现延时功能
def timer(func): # 定义装饰器函数timer，参数func是被装饰的目标函数def wrapper(*args, **kwargs): # 定义内部包装函数wrapper，是装饰器的核心start = time.time() # 新增功能，记录函数执行前的时间（秒）result = func(*args, **kwargs) # 调用原函数，并接收原函数的返回值end = time.time() # 新增功能，记录函数执行后的时间print(f"函数{func.__name__}执行耗时: {end - start:.2f}秒") # 打印执行耗时return result # 返回原函数的执行结果return wrapper # 装饰器函数返回包装函数wrapper
·用装饰器装饰函数的两种写法
1: @语法（推荐）
@timer
def add(a, b):time.sleep(1)return a + b
2:手动装饰（了解即可）2.装饰器进阶 — 带参数的装饰器
示例：定义带参数装饰器（3 层函数：最外层收装饰器参数，中间层收原函数，内层加功能 ）
```python
def set_tips(tips_text): # 最外层：接收装饰器的参数（自定义提示语）def add_tips(func): # 中间层：接收原函数def wrapper(): # 内层：加功能 + 调原函数print(tips_text) # 使用装饰器传入的参数func()return wrapperreturn add_tips
·用装饰器，传入自定义提示语（括号里是装饰器的参数）
@set_tips("===启动问候功能===") # 加专属提示给say_hello
def say_hello():print("Hello, Python")
·调用测试
say_hello()
核心总结：
1.本质：装饰器是 “函数套函数” 的工具，核心是 [不改原代码、不换调用方式，增强函数功能]
2.基础结构：2 层函数（外层收原函数，内层加功能 + 调原函数，返回内层）
3.关键语法：@装饰器名 语法糖简化调用；
*args, **kwargs 适配带参函数；
3 层函数实现装饰器自传参
面向对象（OOP）基础 — 类与对象
·类（class）：是 “一类事物的模板”，比如 “学生类” 定义了学生都有 “姓名、年龄” 这些属性，有 “学习” 这个方法
·对象（Object）：是类的 “具体实例”，比如 “小明” 是 “学生类” 的一个对象
·语法结构：
class 类名:def __init__(self,属性1,属性2):# 初始化方法，创建对象时自动执行self.属性1 = 属性1 # self代表“当前对象”self.属性2 = 属性2def 方法名(self,参数):# 类的方法，必须带self方法逻辑
示例：定义 “学生类”
class Student:
# 初始化方法：创建对象时给属性赋值def __init__(self, name, age):self.name = nameself.age = age# 定义“学习”方法def study(self, course):print(f"{self.name}({self.age}岁) 正在学习{course}")
# 创建对象（实例化）
stu1 = Student("小明", 20) # 调用__init__，传入name和age
stu2 = Student("小红", 19)
# 访问对象的属性
print(stu1.name) # 输出：小明
# 调用对象的方法
stu1.study("Python") # 输出：小明(20岁)正在学习Python
stu2.study("数学") # 输出：小红(19岁)正在学习数学
面向对象进阶 — 继承与多态
·继承：子类继承父类的属性和方法，还能新增 / 重写方法（比如 “大学生类” 继承 “学生类”）
·多态：不同子类对同一方法的 “重写”，调用时自动匹配对应子类的实现
1.继承是多态的前提，无继承则无多态
2.多态是继承的核心价值，让代码更灵活通用
示例：
# 父类：Student
class Student:def __init__(self, name, age):self.name = nameself.age = agedef study(self, course):print(f"{self.name}学习{course}")# 子类：CollegeStudent（继承Student）
class CollegeStudent(Student):def __init__(self, name, age, major): # 新增属性：专业super().__init__(name, age) # 调用父类的__init__，复用属性赋值逻辑self.major = majordef study(self, course): # 重写父类的study方法print(f"{self.name}（{self.major}专业）正在学习 {course}")
# 新增方法：写论文def write_paper(self, topic):print(f"{self.name}正在写论文：《{topic}》")
# 多态示例：不同子类的study方法
class MiddleStudent(Student):def study(self, course):print(f"{self.name}（中学生）正在做 {course}作业")# 测试
stu3 = CollegeStudent("小李", 22, "计算机")
stu3.study("Python")
# 输出：小李（计算机专业）正在学习 Pythonstu3.write_paper("Python装饰器研究")
# 输出：小李正在写论文：《Python装饰器研究》stu4 = MiddleStudent("小张", 15)
stu4.study("语文")
# 输出：小张（中学生）正在做语文作业
面向对象进阶 — 封装与属性
1.封装：用 “下划线” 标记私有属性 / 方法（_属性或__属性），外部尽量不直接访问
2.属性装饰器（@property）：把方法伪装成属性，既能控制读取，又能避免直接改内部数据
示例：
class Person:def __init__(self, name, age):self.name = name # 公开属性self.__age = age # 私有属性（双下划线开头，外部不能直接访问）@property # 用@property装饰器，把方法变成“只读属性”def age(self):if self.__age < 0: # 可以在这里加逻辑（比如年龄不能小于0）return 0return self.__age
@age.setter # 用@age.setter装饰器，允许修改属性（可选）
def age(self, new_age):
if new_age < 0:
raise ValueError("年龄不能为负数")
self.__age = new_age
#测试
p1 = Person("小王", 25)
print(p1.name) # 可以直接访问公开属性 → 小王
# print(p1.__age) → 报错！私有属性不能直接访问
print(p1.age) # 访问@property装饰的age → 25
p1.age = 26 # 通过@age.setter修改
print(p1.age) # 输出：26
# p1.age = -5 # 触发ValueError: 年龄不能为负数
类的专有方法：
·init : 构造函数，在生成对象时调用
·del : 析构函数，释放对象时使用
·repr : 打印，转换
·setitem : 按照索引赋值
·getitem: 按照索引获取值
·len: 获得长度
·cmp: 比较运算
·call: 函数调用
·add: 加运算
·sub: 减运算
·mul: 乘运算
·truediv: 除运算
·mod: 求余运算
·pow: 乘方
模块与包管理
1.模块（Module）：一个 .py 文件就是一个模块，比如 math.py 是数学模块
2.包（Package）：多个模块组成的文件夹（必须有 init.py 文件）
3.导入方式：
·import 模块名
·from 模块名 import 函数/类
·from 包名 import 模块名
实操代码：
步骤 1：创建模块文件 my_module.py
# my_module.py
def add(a, b):return a + bclass MyClass:def hello(self):print("我是MyClass里的hello方法")
步骤 2：在另一个文件中导入模块
# main.py
# 方式1：导入整个模块
import my_module
print(my_module.add(3,5)) # 输出：8
obj = my_module.MyClass()
obj.hello() # 输出：我是MyClass里的hello方法# 方式2：导入模块中的指定内容
from my_module import add, MyClass
print(add(4,6)) # 输出：10
obj2 = MyClass()
obj2.hello() # 输出：我是MyClass里的hello方法
步骤 3：创建包（示例）
新建文件夹 my_package
在文件夹里创建 init.py（可以为空）和 module1.py（内容同上面的 my_module.py）
导入包中的模块：
from my_package import module1
print(module1.add(1,2)) # 输出：3
·标准模块
| 模块名 | 功能描述 |
|---|---|
| math | 数学运算（如平方根、三角函数等） |
| os | 操作系统相关功能（如文件、目录操作） |
| sys | 系统相关的参数和函数 |
| random | 生成随机数 |
| datetime | 处理日期和时间 |
| json | 处理 JSON 数据 |
| re | 正则表达式操作 |
| collections | 提供额外的数据结构（如 defaultdict、deque） |
| itertools | 提供迭代器工具 |
| functools | 高阶函数工具（如 reduce、lru_cache） |