深度探索Python列表切片的高级应用与最佳实践

# 基础切片示例
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 获取第2到第5个元素（索引1到4）
slice1 = numbers[1:5]  # [1, 2, 3, 4]

# 从头开始到第5个元素
slice2 = numbers[:5]   # [0, 1, 2, 3, 4]

# 从第5个元素到末尾
slice3 = numbers[5:]   # [5, 6, 7, 8, 9]

# 获取所有偶数索引的元素
slice4 = numbers[::2]  # [0, 2, 4, 6, 8]

# 反转列表
slice5 = numbers[::-1] # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# 负索引示例
data = ['A', 'B', 'C', 'D', 'E', 'F']

# 获取最后三个元素
last_three = data[-3:]  # ['D', 'E', 'F']

# 排除首尾元素
middle = data[1:-1]     # ['B', 'C', 'D', 'E']

# 从倒数第4个到倒数第2个
partial = data[-4:-1]   # ['C', 'D', 'E']

def process_data_in_chunks(data, chunk_size):
    """将大数据集分块处理"""
    results = []
    
    for i in range(0, len(data), chunk_size):
        chunk = data[i:i + chunk_size]
        # 处理每个数据块
        processed_chunk = [x * 2 for x in chunk]
        results.extend(processed_chunk)
    
    return results

# 使用示例
large_dataset = list(range(1000))
processed = process_data_in_chunks(large_dataset, 100)
print(f"处理了 {len(processed)} 个数据点")

def moving_average(data, window_size):
    """计算移动平均值"""
    if window_size > len(data):
        return []
    
    averages = []
    for i in range(len(data) - window_size + 1):
        window = data[i:i + window_size]
        avg = sum(window) / window_size
        averages.append(avg)
    
    return averages

# 股票价格分析示例
stock_prices = [100, 102, 101, 105, 107, 106, 108, 110, 109, 112]
ma_5 = moving_average(stock_prices, 5)
print(f"5日移动平均线: {ma_5}")

# 查看切片对象的内部结构
s = slice(1, 5, 2)
print(f"起始: {s.start}")    # 1
print(f"结束: {s.stop}")     # 5
print(f"步长: {s.step}")     # 2
print(f"切片表示: {s}")      # slice(1, 5, 2)

class SliceableList:
    """一个简单的可切片列表实现"""
    
    def __init__(self, *items):
        self._data = list(items)
    
    def __getitem__(self, key):
        # 处理整数索引
        if isinstance(key, int):
            if key < 0:
                key = len(self._data) + key
            if key < 0 or key >= len(self._data):
                raise IndexError("索引超出范围")
            return self._data[key]
        
        # 处理切片对象
        elif isinstance(key, slice):
            # 获取切片参数，处理None值
            start, stop, step = key.start, key.stop, key.step
            
            # 设置默认值
            if start is None:
                start = 0
            elif start < 0:
                start = len(self._data) + start
            
            if stop is None:
                stop = len(self._data)
            elif stop < 0:
                stop = len(self._data) + stop
            
            if step is None:
                step = 1
            
            # 处理步长为负的情况
            if step < 0:
                if start < 0:
                    start = len(self._data) + start
                if stop < 0:
                    stop = len(self._data) + stop
                
                # 调整起始和结束位置
                if start < stop:
                    return []
                
                result = []
                current = start
                while current > stop:
                    result.append(self._data[current])
                    current += step
                return result
            
            # 正常切片
            result = []
            current = start
            while current < stop:
                result.append(self._data[current])
                current += step
            return result
        
        else:
            raise TypeError("索引必须是整数或切片")
    
    def __len__(self):
        return len(self._data)
    
    def __repr__(self):
        return f"SliceableList({self._data})"

# 测试我们的可切片对象
my_list = SliceableList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
print(f"完整列表: {my_list}")
print(f"切片[2:7]: {my_list[2:7]}")
print(f"切片[::2]: {my_list[::2]}")
print(f"切片[::-1]: {my_list[::-1]}")
print(f"负索引[-3:]: {my_list[-3:]}")

class CircularBuffer:
    """一个支持切片的环形缓冲区实现"""
    
    def __init__(self, capacity):
        self.capacity = capacity
        self.buffer = [None] * capacity
        self.start = 0
        self.size = 0
    
    def append(self, item):
        """添加元素到缓冲区"""
        index = (self.start + self.size) % self.capacity
        self.buffer[index] = item
        
        if self.size < self.capacity:
            self.size += 1
        else:
            self.start = (self.start + 1) % self.capacity
    
    def __getitem__(self, key):
        if isinstance(key, int):
            # 处理负索引
            if key < 0:
                key = self.size + key
            
            if key < 0 or key >= self.size:
                raise IndexError("索引超出范围")
            
            index = (self.start + key) % self.capacity
            return self.buffer[index]
        
        elif isinstance(key, slice):
            start, stop, step = key.start, key.stop, key.step
            
            # 处理默认值
            if start is None:
                start = 0
            if stop is None:
                stop = self.size
            if step is None:
                step = 1
            
            # 处理负索引
            if start < 0:
                start = self.size + start
            if stop < 0:
                stop = self.size + stop
            
            # 边界检查
            start = max(0, min(start, self.size))
            stop = max(0, min(stop, self.size))
            
            # 生成切片结果
            result = []
            if step > 0:
                for i in range(start, stop, step):
                    result.append(self[i])
            else:
                for i in range(start, stop, step):
                    result.append(self[i])
            
            return result
        
        else:
            raise TypeError("索引必须是整数或切片")
    
    def __len__(self):
        return self.size
    
    def __repr__(self):
        items = [self[i] for i in range(self.size)]
        return f"CircularBuffer({items})"

# 环形缓冲区使用示例
print("\n=== 环形缓冲区示例 ===")
buffer = CircularBuffer(5)

# 添加数据
for i in range(10):
    buffer.append(f"数据{i}")
    print(f"添加后: {buffer}")

# 切片操作
print(f"\n最后3个元素: {buffer[-3:]}")
print(f"每隔一个元素: {buffer[::2]}")

import time
from collections.abc import Sequence

class OptimizedSliceable(Sequence):
    """优化版的可切片对象，继承Sequence抽象基类"""
    
    def __init__(self, data):
        self._data = list(data)
    
    def __getitem__(self, key):
        # 直接委托给列表的切片机制
        return self._data[key]
    
    def __len__(self):
        return len(self._data)
    
    def __repr__(self):
        return f"OptimizedSliceable({self._data})"

# 性能对比
def performance_test():
    """切片性能测试"""
    import random
    
    # 创建测试数据
    data = list(range(1000000))
    custom_obj = OptimizedSliceable(data)
    
    # 测试内置列表切片
    start = time.time()
    for _ in range(100):
        _ = data[1000:9000:3]
    list_time = time.time() - start
    
    # 测试自定义对象切片
    start = time.time()
    for _ in range(100):
        _ = custom_obj[1000:9000:3]
    custom_time = time.time() - start
    
    print(f"内置列表切片时间: {list_time:.4f}秒")
    print(f"自定义对象切片时间: {custom_time:.4f}秒")
    print(f"性能差异: {(custom_time/list_time - 1)*100:.2f}%")

# 运行性能测试
performance_test()

class DataSeries:
    """时间序列数据切片实现"""
    
    def __init__(self, dates, values):
        self.dates = dates
        self.values = values
    
    def __getitem__(self, key):
        if isinstance(key, slice):
            return DataSeries(
                self.dates[key],
                self.values[key]
            )
        elif isinstance(key, int):
            return (self.dates[key], self.values[key])
        else:
            raise TypeError("不支持的索引类型")
    
    def filter_by_date_range(self, start_date, end_date):
        """按日期范围过滤"""
        indices = [
            i for i, date in enumerate(self.dates)
            if start_date <= date <= end_date
        ]
        return DataSeries(
            [self.dates[i] for i in indices],
            [self.values[i] for i in indices]
        )
    
    def __repr__(self):
        return f"DataSeries(长度={len(self.dates)})"

# 使用示例
import datetime

# 创建时间序列
dates = [
    datetime.date(2024, 1, i) for i in range(1, 31)
]
values = [i * 10 + 5 for i in range(30)]

series = DataSeries(dates, values)

# 切片操作
first_week = series[:7]
print(f"第一周数据: {first_week}")

# 每隔一天的数据
alternate_days = series[::2]
print(f"隔天数据: {alternate_days}")

class SlicableIterator:
    """支持切片操作的迭代器包装器"""
    
    def __init__(self, iterable):
        self.data = list(iterable)
        self.index = 0
    
    def __iter__(self):
        return self
    
    def __next__(self):
        if self.index >= len(self.data):
            raise StopIteration
        value = self.data[self.index]
        self.index += 1
        return value
    
    def __getitem__(self, key):
        # 创建新的迭代器实例进行切片
        if isinstance(key, slice):
            return SlicableIterator(self.data[key])
        else:
            return self.data[key]
    
    def reset(self):
        """重置迭代器"""
        self.index = 0
    
    def __repr__(self):
        return f"SlicableIterator({self.data})"

# 使用示例
print("\n=== 可切片迭代器示例 ===")
iterator = SlicableIterator(range(10))

# 正常迭代
print("前3个元素:")
for i, value in enumerate(iterator):
    if i >= 3:
        break
    print(value)

# 切片操作
iterator.reset()
sliced = iterator[3:7]
print(f"\n切片[3:7]: {list(sliced)}")

# 注意：切片创建的是浅拷贝！
original = [[1, 2], [3, 4]]
sliced = original[:]

# 修改切片中的子列表会影响原列表
sliced[0][0] = 99
print(f"原列表: {original}")  # [[99, 2], [3, 4]]
print(f"切片: {sliced}")      # [[99, 2], [3, 4]]

# 解决方案：使用深拷贝
import copy
original = [[1, 2], [3, 4]]
sliced = copy.deepcopy(original[:])
sliced[0][0] = 99
print(f"深拷贝后原列表: {original}")  # [[1, 2], [3, 4]]