Python 类

class

基本概念
- 类(Class): 创建对象的蓝图/模板
- 对象(Object): 类的实例化结果
- 方法(Method): 类中定义的函数
- 属性(Attribute): 类或对象存储的数据

类的基本语法

特性	实例方法	类方法	静态方法
装饰器	无	`@classmethod`	`@staticmethod`
第一个参数	`self`(实例引用)	`cls`(类引用)	无
访问实例属性	可以	不可以	不可以
访问类属性	可以	可以	不可以
调用方式	必须通过实例	类或实例均可	类或实例均可

class MyClass:
    # 类属性
    class_attr = "类属性值"
    
    # 初始化方法
    def __init__(self, param):
        # 实例属性
        self.instance_attr = param
    
    # 实例方法
        #- 定义 ：第一个参数是 self ，指向实例对象
        #- 调用 ：需要通过实例调用
        #- 访问 ：可以访问实例属性和类属性
    def instance_method(self):
        return self.instance_attr

    
    # 类方法
    	#- 定义 ：使用 @classmethod 装饰器，第一个参数是 cls ，指向类对象
		#- 调用 ：可以通过类或实例调用
		#- 访问 ：只能访问类属性，不能访问实例属性
    @classmethod
    def class_method(cls):
        return cls.class_attr
    
    
    # 静态方法
    	#- 定义 ：使用 @staticmethod 装饰器，没有默认参数
        #- 调用 ：可以通过类或实例调用
        #- 访问 ：不能访问类属性或实例属性
    @staticmethod
    def static_method():
        return "静态方法"

class MyClass:
    class_attr = "类属性"  # 类属性
    
    def __init__(self, instance_attr):
        self.instance_attr = instance_attr  # 实例属性
    
    # 实例方法
    def instance_method(self):
        print(f"实例方法调用 - 可以访问实例属性: {self.instance_attr}")
        print(f"实例方法调用 - 可以访问类属性: {self.class_attr}")
    
    # 类方法
    @classmethod
    def class_method(cls):
        print(f"类方法调用 - 可以访问类属性: {cls.class_attr}")
        # print(cls.instance_attr)  # 这行会报错，不能访问实例属性
    
    # 静态方法
    @staticmethod
    def static_method():
        print("静态方法调用 - 不能访问类或实例属性")
        # print(self.instance_attr)  # 这行会报错
        # print(MyClass.class_attr)  # 技术上可以，但违背静态方法设计原则

# 测试代码
if __name__ == "__main__":
    # 创建实例
    obj = MyClass("实例属性值")
    
    print("=== 实例方法调用 ===")
    obj.instance_method()  # 必须通过实例调用
    
    print("\n=== 类方法调用 ===")
    obj.class_method()      # 通过实例调用
    MyClass.class_method()  # 通过类调用
    
    print("\n=== 静态方法调用 ===")
    obj.static_method()      # 通过实例调用
    MyClass.static_method()  # 通过类调用
   
"""
=== 实例方法调用 ===
实例方法调用 - 可以访问实例属性: 实例属性值
实例方法调用 - 可以访问类属性: 类属性

=== 类方法调用 ===
类方法调用 - 可以访问类属性: 类属性
类方法调用 - 可以访问类属性: 类属性

=== 静态方法调用 ===
静态方法调用 - 不能访问类或实例属性
静态方法调用 - 不能访问类或实例属性
"""

核心特征

继承

概念：子类自动获得父类的属性和方法，实现代码复用

特点：

支持单继承和多层继承
子类可以重写(override)父类方法
子类可以扩展父类功能

成员类型	可继承性	示例	访问方式说明
公有属性	✅	`self.attr`	直接继承使用
受保护属性	✅	`self._protected`	约定上不建议直接访问
私有属性	❌	`self.__private`	会被名称修饰(_类名__private)
类属性	✅	`Class.class_attr`	子类可直接访问
实例方法	✅	`def method()`	可继承并可重写
类方法	✅	`@classmethod`	通过cls参数访问类属性
静态方法	✅	`@staticmethod`	与类和实例无关
特殊方法	✅	`__str__`	可继承并重写魔术方法
私有方法	❌	`__private_method`	会被名称修饰(_类名__private_method)

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print("动物叫声")

class Dog(Animal):
    def speak(self):  # 方法重写
        print(f"{self.name} 汪汪叫")
    
    def fetch(self):  # 扩展新方法
        print(f"{self.name} 会捡球")

多态

多态维度	技术实现方式	核心价值	典型应用场景
接口统一	父类定义抽象方法	不同子类对象可通过统一接口操作	插件系统、设备驱动
行为定制	子类重写父类方法	相同方法调用产生不同行为结果	GUI事件处理、游戏AI
扩展开放	新增子类无需修改现有代码	符合开闭原则(OCP)	业务规则扩展、支付系统
替换透明	里氏替换原则(LSP)	父类引用可透明替换为任意子类对象	框架设计、测试替身
解耦设计	依赖抽象而非具体实现	降低模块间耦合度	企业级架构、微服务
动态绑定	运行时确定具体调用的方法	增强程序灵活性	策略模式、状态模式

class Cat:
    def speak(self):
        print("喵喵")

class Duck:
    def speak(self):
        print("嘎嘎")

def animal_speak(animal):
    animal.speak()  # 多态调用

# 不同对象调用相同方法
animal_speak(Cat())  # 输出: 喵喵
animal_speak(Duck()) # 输出: 嘎嘎

封装

公有属性/方法: 默认
受保护属性/方法: 单下划线开头 _protected
私有属性/方法: 双下划线开头 __private

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # 私有属性
    
    def deposit(self, amount):  # 公开方法
        self.__balance += amount
    
    def get_balance(self):  # 公开方法
        return self.__balance

特殊方法(魔术方法)

注意：魔术方法通常不应该被直接调用，而是由Python解释器在特定场景自动触发

分类	典型方法	意义说明	触发场景示例
对象生命周期	`__init__`/`__del__`	控制对象创建和销毁过程	构造/析构对象时自动调用
运算符重载	`__add__`/`__eq__`	自定义对象运算符行为	obj1 + obj2 或 obj1 == obj2
容器行为	`__getitem__`/`__len__`	使对象支持容器操作	obj[index] 或 len(obj)
属性访问	`__getattr__`/`__setattr__`	定制属性访问逻辑	obj.attr 或 obj.attr = value
可调用对象	`__call__`	使实例能像函数一样调用	obj()
字符串表示	`__str__`/`__repr__`	提供友好的对象字符串表示	print(obj) 或 repr(obj)
上下文管理	`__enter__`/`__exit__`	实现with语句的资源管理	with obj as x:
迭代协议	`__iter__`/`__next__`	使对象可迭代	for x in obj:

class MyClass:
    def __str__(self):  # 字符串表示
        return "MyClass对象"
    
    def __len__(self):  # 定义len()行为
        return 10
    
    def __add__(self, other):  # 定义+操作
        return self.value + other.value
    
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):  # 重载+运算符
        return Vector(self.x + other.x, self.y + other.y)
    
    def __str__(self):  # 定义打印格式
        return f"Vector({self.x}, {self.y})"

v1 = Vector(1, 2)
v2 = Vector(3, 4)
print(v1 + v2)  # 输出

高级特征
- 抽象基类(ABC)
- 混入类(Mixin)
- 属性装饰器(@property)
- 描述符(Descriptor)
- 元类(Metaclass)

最佳实践

遵循PEP8命名规范PEP 8 – Style Guide for Python Code | peps.python.org

标识符类型	命名规范	示例	特殊情况说明
模块名	小写+下划线	`module_name.py`	避免使用特殊字符
包名	全小写无下划线	`package`	保持简短
类名	大驼峰(CamelCase)	`ClassName`	异常类应后缀Error
函数/方法名	小写+下划线	`function_name()`	私有方法前缀单下划线`_internal()`
变量名	小写+下划线	`variable_name`	常量全大写`CONSTANT_NAME`
常量	全大写+下划线	`MAX_OVERFLOW`	模块级别定义
异常名	大驼峰+Error后缀	`CustomError`	继承自Exception
方法参数	小写+下划线	`self, param_name`	cls作为类方法第一个参数
私有成员	双下划线前缀	`__private_var`	会触发名称修饰(name mangling)
类型变量	大驼峰	`TypeVarT`	通常用单个大写字母`T`

优先使用组合而非继承

维度	组合（Has-a）	继承（Is-a）
关系性质	包含其他对象作为成员	子类继承父类的特性
耦合度	低耦合（通过接口交互）	高耦合（直接依赖父类实现）
灵活性	运行时动态替换组件	编译时确定关系
扩展性	通过新增组件类扩展	需要通过继承树扩展
复用粒度	细粒度复用功能模块	粗粒度复用整个类层次

# 使用组合实现
class Engine:
    def start(self):
        print("引擎启动")

class Car:
    def __init__(self):
        self.engine = Engine()  # 组合Engine对象
    
    def start(self):
        self.engine.start()

# 使用继承实现（不推荐）
class Vehicle:
    def start_engine(self):
        print("引擎启动")

class Car(Vehicle):  # 继承带来不必要的耦合
    pass

合理使用@property
避免过度使用魔术方法
适当使用类型注解

posted @ 2025-08-29 11:16 剪水行舟154 阅读(50) 评论(0) 收藏举报

刷新页面返回顶部

Python 类

class

公告