从基础到高级应用解析Python中的序列类型

# 创建列表的多种方式
fruits = ["apple", "banana", "cherry"]  # 直接创建
numbers = list(range(1, 6))            # 使用list()构造函数
mixed_list = [1, "hello", 3.14, True]  # 混合类型

# 列表操作示例
print(f"原始列表: {fruits}")
print(f"第一个水果: {fruits[0]}")        # 索引访问
print(f"最后两个水果: {fruits[-2:]}")    # 切片操作
print(f"列表长度: {len(fruits)}")        # 获取长度

# 修改列表
fruits.append("orange")                # 添加元素
fruits.insert(1, "blueberry")          # 插入元素
fruits[2] = "strawberry"               # 修改元素
print(f"修改后的列表: {fruits}")

# 创建元组
coordinates = (10, 20)
colors = "red", "green", "blue"  # 括号可省略
single_tuple = (42,)             # 单元素元组必须有逗号

# 元组解包（超实用功能！）
x, y = coordinates
print(f"坐标: x={x}, y={y}")

# 元组作为函数返回值
def get_min_max(numbers):
    return min(numbers), max(numbers)

min_val, max_val = get_min_max([5, 2, 8, 1, 9])
print(f"最小值: {min_val}, 最大值: {max_val}")

text = "Python序列编程指南"

# 字符串操作
print(f"字符串长度: {len(text)}")
print(f"前6个字符: {text[:6]}")
print(f"是否以'Python'开头: {text.startswith('Python')}")
print(f"查找'序列'的位置: {text.find('序列')}")

# 字符串方法链式调用
result = "  Hello, World!  ".strip().upper().replace("WORLD", "Python")
print(f"处理后的字符串: {result}")

class FibonacciSequence:
    """自定义斐波那契数列序列"""
    
    def __init__(self, n):
        self.n = n
        self._sequence = self._generate_fibonacci()
    
    def _generate_fibonacci(self):
        """生成斐波那契数列"""
        if self.n <= 0:
            return []
        elif self.n == 1:
            return [0]
        
        fib = [0, 1]
        for i in range(2, self.n):
            fib.append(fib[-1] + fib[-2])
        return fib
    
    def __len__(self):
        """实现序列协议：返回长度"""
        return len(self._sequence)
    
    def __getitem__(self, index):
        """实现序列协议：索引访问"""
        if isinstance(index, slice):
            # 处理切片
            return self._sequence[index]
        elif 0 <= index < len(self._sequence):
            return self._sequence[index]
        elif -len(self._sequence) <= index < 0:
            return self._sequence[index]
        else:
            raise IndexError("索引超出范围")
    
    def __contains__(self, item):
        """实现序列协议：检查元素是否存在"""
        return item in self._sequence
    
    def __iter__(self):
        """实现序列协议：返回迭代器"""
        return iter(self._sequence)
    
    def __reversed__(self):
        """实现序列协议：返回反向序列"""
        return reversed(self._sequence)
    
    def __str__(self):
        return f"FibonacciSequence(前{self.n}项): {self._sequence}"

# 使用自定义序列
fib_seq = FibonacciSequence(10)
print(fib_seq)
print(f"长度: {len(fib_seq)}")
print(f"第5个元素: {fib_seq[4]}")
print(f"前5个元素: {fib_seq[:5]}")
print(f"是否包含13: {13 in fib_seq}")
print(f"反向遍历: {list(reversed(fib_seq))}")

# 模拟销售数据分析
def analyze_sales_data():
    # 使用列表存储每日销售额
    daily_sales = [1200, 1500, 1800, 900, 2100, 1700, 1900]
    
    # 使用元组存储日期
    days = ("周一", "周二", "周三", "周四", "周五", "周六", "周日")
    
    # 计算统计信息
    total_sales = sum(daily_sales)
    avg_sales = total_sales / len(daily_sales)
    max_sales = max(daily_sales)
    max_day = days[daily_sales.index(max_sales)]
    
    # 使用字符串格式化输出
    report = f"""
    📊 销售数据分析报告
    ====================
    总销售额: ¥{total_sales:,.2f}
    平均日销售额: ¥{avg_sales:,.2f}
    最高销售额: ¥{max_sales:,.2f} ({max_day})
    
    每日销售详情:
    """
    
    # 使用zip组合两个序列
    for day, sales in zip(days, daily_sales):
        report += f"    {day}: ¥{sales:,.2f}\n"
    
    return report

print(analyze_sales_data())

# 使用序列实现简单的LRU缓存
class LRUCache:
    """最近最少使用缓存"""
    
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}  # 存储键值对
        self.order = []  # 使用列表维护访问顺序
    
    def get(self, key):
        """获取缓存值"""
        if key in self.cache:
            # 更新访问顺序：移动到列表末尾
            self.order.remove(key)
            self.order.append(key)
            return self.cache[key]
        return -1
    
    def put(self, key, value):
        """添加缓存项"""
        if key in self.cache:
            # 更新现有键
            self.cache[key] = value
            self.order.remove(key)
            self.order.append(key)
        else:
            # 添加新键
            if len(self.cache) >= self.capacity:
                # 移除最久未使用的键
                lru_key = self.order.pop(0)
                del self.cache[lru_key]
            
            self.cache[key] = value
            self.order.append(key)
    
    def __str__(self):
        return f"LRUCache(容量={self.capacity}, 内容={self.cache}, 顺序={self.order})"

# 测试LRU缓存
cache = LRUCache(3)
cache.put("A", 1)
cache.put("B", 2)
cache.put("C", 3)
print(f"初始状态: {cache}")

cache.get("A")  # 访问A，使其成为最近使用的
cache.put("D", 4)  # 添加D，应该移除B（最久未使用）
print(f"添加D后: {cache}")

# 列表推导式
squares = [x**2 for x in range(10)]
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# 生成器表达式（内存效率更高）
large_squares = (x**2 for x in range(1000000))

# 字典推导式
square_dict = {x: x**2 for x in range(5)}

print(f"平方列表: {squares[:5]}...")
print(f"偶数平方: {even_squares}")
print(f"平方字典: {square_dict}")

# 扩展解包
first, *middle, last = [1, 2, 3, 4, 5]
print(f"第一个: {first}, 中间: {middle}, 最后一个: {last}")

# 嵌套解包
points = [(1, 2), (3, 4), (5, 6)]
for x, y in points:
    print(f"点坐标: ({x}, {y})")

# 交换变量（Pythonic方式！）
a, b = 10, 20
a, b = b, a  # 不需要临时变量！
print(f"交换后: a={a}, b={b}")

# 不好：创建完整副本
new_list = old_list[:]

# 更好：使用切片或list()构造函数
new_list = list(old_list)

# 处理大文件时使用生成器
def read_large_file(file_path):
    with open(file_path, 'r') as file:
        for line in file:
            yield line.strip()