在 Python 中，class 是面向对象编程（OOP）的核心，用于创建自定义对象类型。以下从 基础结构、高级特性 到 元编程 的深度解析：

一、类的基础结构

1.最简单的类定义

class Person:
    """人类示例"""
    species = 'Homo sapiens'  # 类属性（所有实例共享）

    def __init__(self, name: str, age: int):
        self.name = name  # 实例属性
        self.age = age

    def greet(self) -> str:
        return f"Hello, I'm {self.name}"

2.实例化与属性访问

p = Person("Alice", 30)
print(p.greet())       # 调用方法 → "Hello, I'm Alice"
print(p.species)       # 访问类属性 → "Homo sapiens"
print(p.__dict__)      # 查看实例属性 → {'name': 'Alice', 'age': 30}

二、关键组成部分详解

1.构造方法__init__

• 在实例化时自动调用
• 不要返回非 None 值
• 推荐使用类型注解（Python 3.6+）

2.类属性 vs 实例属性

3.方法类型

示例：

class Calculator:
    @classmethod
    def from_string(cls, expr: str):
        """工厂方法"""
        a, op, b = expr.split()
        return cls(float(a), float(b), op)
    
    @staticmethod
    def validate(x):
        """独立验证逻辑"""
        return isinstance(x, (int, float))

三、继承与多态

1.基础继承

class Student(Person):  # 继承Person
    def __init__(self, name, age, student_id):
        super().__init__(name, age)  # 调用父类构造
        self.student_id = student_id

    def greet(self):  # 方法重写
        return f"Student {self.student_id} says hi!"

2.方法解析顺序（MRO）

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass

print(D.__mro__)  # 输出：(D, B, C, A, object)

3.抽象基类（ABC）

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float: pass

class Circle(Shape):
    def area(self) -> float:
        return 3.14 * self.radius ** 2

四、高级特性

1.属性控制

属性装饰器示例：

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius
    
    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32
    
    @fahrenheit.setter
    def fahrenheit(self, value):
        self._celsius = (value - 32) * 5/9

2.运算符重载

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

五、内存优化

1.__slots__限制属性

class Point:
    __slots__ = ['x', 'y']  # 禁止动态添加属性
    
    def __init__(self, x, y):
        self.x = x
        self.y = y

效果：

• 减少内存占用 30-50%
• 禁用 __dict__ 和 __weakref__（除非显式声明）

2.弱引用支持

import weakref

class Node:
    def __init__(self, value):
        self.value = value
        self._neighbors = weakref.WeakSet()
    
    def add_neighbor(self, node):
        self._neighbors.add(node)

六、元编程相关

1.动态属性管理

class DynamicAttributes:
    def __getattr__(self, name):
        if name.startswith('fake_'):
            return lambda: f"Faked {name[5:]}"
        raise AttributeError(name)

obj = DynamicAttributes()
print(obj.fake_method())  # 输出: "Faked method"

2.类装饰器

def log_creation(cls):
    original_init = cls.__init__
    
    def wrapped_init(self, *args, **kwargs):
        print(f"Creating {cls.__name__} instance")
        original_init(self, *args, **kwargs)
    
    cls.__init__ = wrapped_init
    return cls

@log_creation
class Data:
    pass

七、最佳实践

1. 类型注解（Python 3.6+）

class Account:
    def __init__(self, id: str, balance: float = 0.0):
        self.id = id
        self.balance = balance

2. 组合优于继承

class Engine: pass
class Wheels: pass

class Car:
    def __init__(self):
        self.engine = Engine()
        self.wheels = [Wheels() for _ in range(4)]

SOLID 原则应用：

• 单一职责：每个类只做一件事
• 开放封闭：通过扩展而非修改现有类
• 依赖倒置：依赖抽象而非具体实现

八、调试技巧

1.查看类信息

print(Person.__name__)    # 类名 → "Person"
print(Person.__module__)  # 定义模块 → "__main__"
print(Person.__dict__)    # 查看所有属性和方法

2.实例内存分析

import sys
p = Person("Bob", 25)
print(sys.getsizeof(p))  # 对象内存占用

掌握这些技术后，您可以：

• 设计可扩展的类层次结构
• 实现高效的内存管理
• 构建灵活的接口系统
• 开发领域特定语言(DSL)