Pythonstudy——week3

Python 高级特性
1.装饰器基础 — 理解 “功能增强”

语法结构：

def 装饰器函数(原函数):
    def 新函数(*args, **kwargs):
        新增功能（比如计时开始）
        result = 原函数(*args, **kwargs)
        新增功能（比如计时结束）
        return result
    return 新函数

·*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 wrapper
    return 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 = 属性2

    def 方法名(self,参数):
    # 类的方法，必须带self
        方法逻辑

示例：定义 “学生类”

class Student:
# 初始化方法：创建对象时给属性赋值
    def __init__(self, name, age):
        self.name = name
        self.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 = name
        self.age = age
    def 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 = major
    def 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")
# 输出：小李（计算机专业）正在学习 Python

stu3.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 0
        return 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 + b

class 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）