Python魔术方法：__getitem__与__len__的容器协议实践

1. Python魔术方法基础：容器行为的秘密武器

在Python的世界里，魔术方法（Magic Methods）是让自定义类具备特殊行为的核心机制。这些以双下划线开头和结尾的方法，为Python对象赋予了与内置类型一致的操作接口。其中，__getitem__和__len__这对组合，是实现容器类行为的基石。

1.1 魔术方法的工作原理

当我们在Python中执行len(obj)或obj[key]这样的操作时，解释器实际上是在背后调用了这些魔术方法。这种设计模式被称为"协议"（Protocol），它不同于其他语言的显式接口实现，而是通过约定俗成的方法名来实现多态。

这种设计带来几个显著优势：

• 代码更加直观：len(obj)比obj.length()更符合Python的哲学
• 与内置类型操作一致：自定义类可以无缝融入Python生态系统
• 灵活性高：只需实现必要的方法，不需要继承特定基类

1.2 容器协议的核心方法

完整的容器协议包含更多方法，但__getitem__和__len__是最基础的两个：

python复制class ContainerProtocol:
    def __getitem__(self, key):
        """支持obj[key]操作"""
        pass
    
    def __len__(self):
        """支持len(obj)操作"""
        pass
    
    def __iter__(self):
        """支持迭代操作"""
        pass
    
    def __contains__(self, item):
        """支持in操作符"""
        pass

在实际开发中，我们通常根据需求选择实现其中的部分方法。__getitem__和__len__的组合已经能满足大多数容器类场景的需求。

2. __getitem__深度解析：不只是索引访问

2.1 基本实现模式

__getitem__方法的标准签名是__getitem__(self, key)，其中key参数可以是多种类型：

python复制class SmartArray:
    def __init__(self, data):
        self.data = list(data)
    
    def __getitem__(self, key):
        print(f"Key type: {type(key)}")
        return self.data[key]

这个简单的实现已经可以处理多种访问方式：

python复制arr = SmartArray(range(10))

# 整数索引
print(arr[3])  # 输出: Key type: <class 'int'> \n 3

# 切片对象
print(arr[2:5])  # 输出: Key type: <class 'slice'> \n [2,3,4]

# 甚至可以是元组
print(arr[(2,5)])  # 如果data支持这种索引方式

2.2 支持高级索引技巧

在实际项目中，我们可以扩展__getitem__来实现更复杂的访问逻辑：

python复制class ConfigManager:
    def __init__(self):
        self._data = {
            'database': {
                'host': 'localhost',
                'port': 5432
            },
            'logging': {
                'level': 'DEBUG',
                'file': 'app.log'
            }
        }
    
    def __getitem__(self, key):
        if isinstance(key, str):
            keys = key.split('.')
        elif isinstance(key, tuple):
            keys = key
        else:
            raise TypeError("Key must be str or tuple")
        
        result = self._data
        for k in keys:
            result = result[k]
        return result

这样我们就可以使用点分路径来访问嵌套配置：

python复制config = ConfigManager()
print(config['database.host'])  # 输出: localhost
print(config[('logging', 'level')])  # 输出: DEBUG

2.3 实现惰性求值

__getitem__还可以用于实现延迟加载模式，这在处理大型数据集时特别有用：

python复制class LazyDataLoader:
    def __init__(self, data_paths):
        self.data_paths = data_paths
        self._cache = {}
    
    def __getitem__(self, idx):
        if idx not in self._cache:
            print(f"Loading data {idx}")
            with open(self.data_paths[idx], 'r') as f:
                self._cache[idx] = f.read()
        return self._cache[idx]

这种模式在深度学习中非常常见，可以显著减少内存使用。

3. __len__的妙用：不只是返回长度

3.1 基本实现方式

__len__方法应该返回一个非负整数，表示容器中元素的数量：

python复制class Playlist:
    def __init__(self, songs):
        self.songs = list(songs)
    
    def __len__(self):
        return len(self.songs)

3.2 动态计算长度

__len__的返回值不一定需要基于某个具体的存储结构，它可以动态计算：

python复制class PrimeNumbers:
    def __init__(self, max_num):
        self.max_num = max_num
    
    def __len__(self):
        count = 0
        for num in range(2, self.max_num + 1):
            if all(num % i != 0 for i in range(2, int(num**0.5) + 1)):
                count += 1
        return count

这个例子展示了即使没有实际存储所有质数，我们也能提供长度信息。

3.3 长度缓存优化

对于计算成本高的长度操作，可以考虑缓存结果：

python复制class BigDataView:
    def __init__(self, data_source):
        self.data_source = data_source
        self._length = None
    
    def __len__(self):
        if self._length is None:
            print("Calculating length...")
            self._length = sum(1 for _ in self.data_source)
        return self._length

4. 组合使用场景：构建专业级数据容器

4.1 自定义序列类型

结合这两个方法，我们可以创建行为类似内置序列的自定义类：

python复制class CircularBuffer:
    def __init__(self, capacity):
        self.capacity = capacity
        self.buffer = [None] * capacity
        self.head = 0
        self.size = 0
    
    def __len__(self):
        return self.size
    
    def __getitem__(self, idx):
        if not -self.size <= idx < self.size:
            raise IndexError("Index out of range")
        if idx < 0:
            idx += self.size
        return self.buffer[(self.head + idx) % self.capacity]

这个环形缓冲区实现支持负数索引和自动环绕，行为与Python列表非常相似。

4.2 数据分块处理

在处理大型数据集时，分块是常见策略：

python复制class ChunkedDataset:
    def __init__(self, data, chunk_size):
        self.data = data
        self.chunk_size = chunk_size
    
    def __len__(self):
        return (len(self.data) + self.chunk_size - 1) // self.chunk_size
    
    def __getitem__(self, chunk_idx):
        start = chunk_idx * self.chunk_size
        end = start + self.chunk_size
        return self.data[start:end]

4.3 虚拟视图模式

我们可以创建不实际存储数据的虚拟视图：

python复制class DataView:
    def __init__(self, source, transform=None):
        self.source = source
        self.transform = transform or (lambda x: x)
    
    def __len__(self):
        return len(self.source)
    
    def __getitem__(self, idx):
        return self.transform(self.source[idx])

这种模式在数据预处理流水线中非常有用。

5. 实际应用案例：构建深度学习数据集

5.1 基础数据集实现

PyTorch的Dataset就是一个典型的__getitem__和__len__组合应用：

python复制from torch.utils.data import Dataset
import numpy as np

class CustomDataset(Dataset):
    def __init__(self, data, labels):
        self.data = data
        self.labels = labels
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        sample = {
            'data': self.data[idx],
            'label': self.labels[idx]
        }
        return sample

5.2 图像数据集增强

我们可以扩展基础数据集类来支持数据增强：

python复制from PIL import Image
import random

class AugmentedImageDataset:
    def __init__(self, image_paths, transform=None):
        self.image_paths = image_paths
        self.transform = transform
    
    def __len__(self):
        return len(self.image_paths)
    
    def __getitem__(self, idx):
        img = Image.open(self.image_paths[idx])
        if self.transform:
            img = self.transform(img)
        return img

5.3 多模态数据集

对于包含多种数据类型的复杂数据集：

python复制class MultiModalDataset:
    def __init__(self, images, texts, labels):
        self.images = images
        self.texts = texts
        self.labels = labels
    
    def __len__(self):
        return len(self.labels)
    
    def __getitem__(self, idx):
        return {
            'image': self.images[idx],
            'text': self.texts[idx],
            'label': self.labels[idx]
        }

6. 性能优化与注意事项

6.1 索引访问的性能考量

当实现__getitem__时，要注意访问时间复杂度：

python复制class SlowSequence:
    def __init__(self, data):
        self.data = data
    
    def __getitem__(self, idx):
        # 每次访问都重新计算，性能差
        return self.data[idx % len(self.data)]
    
class FastSequence:
    def __init__(self, data):
        self.data = data * 2  # 预处理
    
    def __getitem__(self, idx):
        # 直接访问，性能好
        return self.data[idx]

6.2 切片操作的优化处理

对于频繁的切片操作，可以特殊处理：

python复制class OptimizedSlice:
    def __init__(self, data):
        self.data = data
    
    def __getitem__(self, key):
        if isinstance(key, slice):
            # 对切片进行优化处理
            start, stop, step = key.indices(len(self))
            return [self[i] for i in range(start, stop, step)]
        return self.data[key]

6.3 边界条件处理

完善的边界检查很重要：

python复制class SafeArray:
    def __init__(self, data):
        self.data = data
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        if not isinstance(idx, (int, slice)):
            raise TypeError("Index must be integer or slice")
        if isinstance(idx, int) and (idx >= len(self) or idx < -len(self)):
            raise IndexError("Index out of range")
        return self.data[idx]

7. 进阶技巧与模式

7.1 虚拟属性访问

结合__getitem__和__getattr__可以实现灵活的属性访问：

python复制class FlexibleAccess:
    def __init__(self):
        self._data = {}
    
    def __getitem__(self, key):
        return self._data[key]
    
    def __getattr__(self, name):
        if name in self._data:
            return self._data[name]
        raise AttributeError(f"No attribute {name}")

7.2 链式操作支持

通过返回特定对象支持链式操作：

python复制class QueryBuilder:
    def __init__(self, collection):
        self.collection = collection
        self._filters = []
    
    def __getitem__(self, key):
        return self.collection[key]
    
    def filter(self, condition):
        self._filters.append(condition)
        return self
    
    def execute(self):
        return [item for item in self.collection 
                if all(f(item) for f in self._filters)]

7.3 动态代理模式

使用__getitem__实现代理模式：

python复制class DataProxy:
    def __init__(self, real_subject):
        self._real = real_subject
    
    def __len__(self):
        return len(self._real)
    
    def __getitem__(self, key):
        print(f"Accessing {key}")
        return self._real[key]

在实际项目中，__getitem__和__len__的组合应用远不止这些。它们为Python提供了灵活而强大的容器抽象能力，是构建高级数据结构和框架的基础。掌握这些魔术方法的正确使用方式，可以显著提升代码的表达力和可维护性。