Python 类

class Dog:
    # 这是一个类属性，它被所有 Dog 类的实例共享
    species = "Canis familiaris"

    # __init__ 是一个特殊的初始化方法（构造器）
    # 当一个实例被创建时，__init__ 会被自动调用
    def __init__(self, name, age):
        # self 代表实例对象本身，必须作为方法的第一个参数
        # 下面是实例属性，它们属于每个独立的实例
        self.name = name
        self.age = age

    # 这是一个实例方法
    def bark(self):
        return f"{self.name} says Woof!"

d1 = Dog("Buddy", 5)
print(f"{d1.name} is {d1.age} years old.")  # -> Buddy is 5 years old.
print(d1.bark())  # -> Buddy says Woof!

d2 = Dog("Lucy", 3)
print(d1.species) # -> Canis familiaris
print(d2.species) # -> Canis familiaris

# 修改类属性会影响所有实例
Dog.species = "A friendly dog"
print(d1.species)  # -> A friendly dog

class Date:
    def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    @classmethod
    def from_string(cls, date_string):
        """工厂方法：通过 'YYYY-MM-DD' 格式的字符串创建 Date 实例。"""
        year, month, day = map(int, date_string.split('-'))
        return cls(year, month, day) # cls 就是 Date 类本身

    @staticmethod
    def is_valid_date(date_string):
        """静态方法：一个独立的工具函数，用于检查日期字符串的格式。"""
        try:
            year, month, day = map(int, date_string.split('-'))
            return True
        except (ValueError, TypeError):
            return False

# 使用
d1 = Date(2025, 11, 4)
d2 = Date.from_string("2025-12-25") # 使用类方法作为替代构造器，代码更具语义化

print(Date.is_valid_date("2025-02-30")) # True
print(d2.year) # -> 2025

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclass must implement this abstract method")

class Bulldog(Dog): # Bulldog 继承自 Dog
    def __init__(self, name, age, wrinkle_level):
        # super() 返回一个代理对象，让你能调用父类的方法。
        # 这是实现方法扩展的标准做法，能正确处理复杂的多重继承。
        super().__init__(name, age)
        self.wrinkle_level = wrinkle_level

    # 覆盖 (Override) 父类的 bark 方法
    def bark(self):
        return f"{self.name} says Grrr!"

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

# 可以通过 __mro__ 属性或 mro() 方法查看
print(D.__mro__)
# -> (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>)

class Circle:
    def __init__(self, radius):
        self._radius = radius # 使用 _ 前缀约定为内部属性

    @property
    def radius(self):
        """Getter: 返回半径。"""
        return self._radius

    @radius.setter
    def radius(self, value):
        """Setter: 在设置值之前进行验证。"""
        if value <= 0:
            raise ValueError("Radius must be positive")
        self._radius = value

    @property
    def area(self):
        """一个通过计算得出的只读属性。"""
        return 3.14159 * (self._radius ** 2)

c = Circle(10)
print(c.radius)  # 像访问属性一样调用 getter
print(c.area)    # 访问计算属性
c.radius = 12    # 调用 setter，自动进行验证

from dataclasses import dataclass

@dataclass(frozen=True) # frozen=True 使实例创建后不可变
class InventoryItem:
    name: str
    unit_price: float
    quantity_on_hand: int = 0

    def total_cost(self) -> float:
        return self.unit_price * self.quantity_on_hand

item1 = InventoryItem("Pen", 1.5, 100)
item2 = InventoryItem("Pen", 1.5, 100)
print(item1) # 自动生成了友好的 __repr__
print(item1 == item2) # True, 自动生成了 __eq__

class Point:
    __slots__ = ('x', 'y') # 声明实例只有 x 和 y 两个属性
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(1, 2)
# p.z = 3 # -> AttributeError，因为实例不能再动态添加新属性

class MyClass:
    def __init__(self, a, b):
        self.a = a
        self.b = b
        self.c = 0 # 运行时动态添加的属性

obj = MyClass(1, 2)

# obj.__dict__ 内部存储了这些信息:
# {'a': 1, 'b': 2, 'c': 0}

class Point:
    __slots__ = ('x', 'y') # 声明实例只有 x 和 y 两个属性

    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(1, 2)

"""
>>> p.__dict__
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Point' object has no attribute '__dict__'. Did you mean: '__dir__'?
"""

# %%
# 导入所需库
import timeit
import gc
import psutil
import os
import sys

# --- 定义测试用的类 ---

class PointWithDict:
    """使用默认 __dict__ 的类"""
    def __init__(self, x, y):
        self.x = x
        self.y = y

class PointWithSlots:
    """使用 __slots__ 优化内存的类"""
    __slots__ = ("x", "y")
    def __init__(self, x, y):
        self.x = x
        self.y = y

# --- 测试函数定义 ---

def measure_memory(cls_to_test, num_instances):
    """
    测量创建指定数量的实例所导致的进程内存增量。
    返回值为字节数。
    """
    # 在测量前运行垃圾回收，确保一个干净的初始状态
    gc.collect()

    # 获取当前进程对象
    process = psutil.Process(os.getpid())
    
    # 记录创建对象前的内存占用
    mem_before = process.memory_info().rss

    # 创建对象列表
    objects = [cls_to_test(i, i * 2) for i in range(num_instances)]
    
    # 记录创建对象后的内存占用
    mem_after = process.memory_info().rss
    
    # 清理创建的对象，避免影响后续测试
    del objects
    gc.collect()
    
    # 返回内存增量
    return mem_after - mem_before

def measure_performance(cls_to_test, num_instances):
    """
    测量对象的创建、访问和修改性能。
    返回一个包含三个时间值的元组。
    """
    # 1. 测量创建时间
    # timeit 的 setup 参数用于准备环境，stmt 是要重复执行的语句
    creation_stmt = f"[{cls_to_test.__name__}(i, i*2) for i in range({num_instances})]"
    creation_setup = f"from __main__ import {cls_to_test.__name__}"
    # 我们只执行一次创建操作，因为创建大量对象本身就很耗时
    creation_time = timeit.timeit(stmt=creation_stmt, setup=creation_setup, number=1)

    # 准备用于访问和修改测试的对象列表
    objects = [cls_to_test(i, i * 2) for i in range(num_instances)]

    # 2. 测量访问时间
    def access_objects():
        total = 0
        for p in objects:
            total += p.x
            total += p.y
        return total
    
    # number 设置为 100，以获得更稳定的平均时间
    access_time = timeit.timeit(access_objects, number=100)

    # 3. 测量修改时间
    def modify_objects():
        for p in objects:
            p.x += 1
            p.y -= 1
            
    modify_time = timeit.timeit(modify_objects, number=100)
    
    # 清理对象
    del objects
    gc.collect()

    return creation_time, access_time, modify_time

def run_comparison(cls_to_test, num_instances):
    """
    运行并打印指定类的完整内存和性能测试结果。
    """
    print(f"--- 正在测试: {cls_to_test.__name__} ---")
    
    # 内存测试
    mem_used = measure_memory(cls_to_test, num_instances)
    print(f"内存占用增量: {mem_used / 1024**2:.2f} MB ({mem_used:,.0f} 字节)")

    # 性能测试
    creation, access, modification = measure_performance(cls_to_test, num_instances)
    print(f"  - 对象创建时间: {creation:.6f} 秒")
    print(f"  - 属性访问时间 (100次): {access:.6f} 秒")
    print(f"  - 属性修改时间 (100次): {modification:.6f} 秒")
    print("-" * 30 + "\n")

#%%
# 定义测试规模
NUM_INSTANCES = 500_000 # 使用下划线提高可读性

print(f"Python 版本: {sys.version.split()[0]}")
print(f"测试实例数量: {NUM_INSTANCES:,}")
print("=" * 40 + "\n")

# 对两个类分别进行测试
run_comparison(PointWithDict, NUM_INSTANCES)
run_comparison(PointWithSlots, NUM_INSTANCES)
# %%

# - Mac本地（3.11.8）
"""
Python 版本: 3.11.8
测试实例数量: 500,000
========================================

--- 正在测试: PointWithDict ---
内存占用增量: 80.04 MB (83,927,040 字节)
  - 对象创建时间: 0.188822 秒
  - 属性访问时间 (100次): 5.118392 秒
  - 属性修改时间 (100次): 7.855338 秒
------------------------------

--- 正在测试: PointWithSlots ---
内存占用增量: 48.02 MB (50,352,128 字节)
  - 对象创建时间: 0.203976 秒
  - 属性访问时间 (100次): 5.476134 秒
  - 属性修改时间 (100次): 6.850384 秒
------------------------------
"""

# - colab(3.11.13)
"""
Python 版本: 3.11.13
测试实例数量: 500,000
========================================

--- 正在测试: PointWithDict ---
内存占用增量: 82.04 MB (86,024,192 字节)
  - 对象创建时间: 0.293373 秒
  - 属性访问时间 (100次): 4.721711 秒
  - 属性修改时间 (100次): 4.083924 秒
------------------------------

--- 正在测试: PointWithSlots ---
内存占用增量: 48.43 MB (50,782,208 字节)
  - 对象创建时间: 0.162264 秒
  - 属性访问时间 (100次): 5.220282 秒
  - 属性修改时间 (100次): 4.003415 秒
------------------------------
"""

class MyClass:
    def __init__(self):
        self.__super_private = "secret"

obj = MyClass()
# print(obj.__super_private) # -> AttributeError
print(obj._MyClass__super_private) # -> secret，仍可访问

from abc import ABC, abstractmethod

class MediaLoader(ABC):
    @abstractmethod
    def load(self, source):
        """定义一个接口，子类必须实现它。"""
        pass

class ImageLoader(MediaLoader):
    def load(self, source): # 若不实现 load 方法，则在实例化时会报错
        print(f"Loading image from {source}")

# loader = MediaLoader() # -> TypeError: Can't instantiate abstract class...
img_loader = ImageLoader()