# 創(chuàng)建列表的多種方式
fruits = ["apple", "banana", "cherry"]  # 直接創(chuàng)建
numbers = list(range(1, 6))            # 使用list()構(gòu)造函數(shù)
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}")

# 創(chuàng)建元組
coordinates = (10, 20)
colors = "red", "green", "blue"  # 括號可省略
single_tuple = (42,)             # 單元素元組必須有逗號

# 元組解包（超實用功能！）
x, y = coordinates
print(f"坐標(biāo): x={x}, y={y}")

# 元組作為函數(shù)返回值
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('序列')}")

# 字符串方法鏈?zhǔn)秸{(diào)用
result = "  Hello, World!  ".strip().upper().replace("WORLD", "Python")
print(f"處理后的字符串: {result}")

class FibonacciSequence:
    """自定義斐波那契數(shù)列序列"""
    
    def __init__(self, n):
        self.n = n
        self._sequence = self._generate_fibonacci()
    
    def _generate_fibonacci(self):
        """生成斐波那契數(shù)列"""
        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):
        """實現(xiàn)序列協(xié)議：返回長度"""
        return len(self._sequence)
    
    def __getitem__(self, index):
        """實現(xiàn)序列協(xié)議：索引訪問"""
        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):
        """實現(xiàn)序列協(xié)議：檢查元素是否存在"""
        return item in self._sequence
    
    def __iter__(self):
        """實現(xiàn)序列協(xié)議：返回迭代器"""
        return iter(self._sequence)
    
    def __reversed__(self):
        """實現(xiàn)序列協(xié)議：返回反向序列"""
        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))}")

# 模擬銷售數(shù)據(jù)分析
def analyze_sales_data():
    # 使用列表存儲每日銷售額
    daily_sales = [1200, 1500, 1800, 900, 2100, 1700, 1900]
    
    # 使用元組存儲日期
    days = ("周一", "周二", "周三", "周四", "周五", "周六", "周日")
    
    # 計算統(tǒng)計信息
    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"""
    ?? 銷售數(shù)據(jù)分析報告
    ====================
    總銷售額: ￥{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())

# 使用序列實現(xiàn)簡單的LRU緩存
class LRUCache:
    """最近最少使用緩存"""
    
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}  # 存儲鍵值對
        self.order = []  # 使用列表維護(hù)訪問順序
    
    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:
            # 更新現(xiàn)有鍵
            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}, 內(nèi)容={self.cache}, 順序={self.order})"

# 測試LRU緩存
cache = LRUCache(3)
cache.put("A", 1)
cache.put("B", 2)
cache.put("C", 3)
print(f"初始狀態(tài): {cache}")

cache.get("A")  # 訪問A，使其成為最近使用的
cache.put("D", 4)  # 添加D，應(yīng)該移除B（最久未使用）
print(f"添加D后: {cache}")

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

# 生成器表達(dá)式（內(nèi)存效率更高）
large_squares = (x**2 for x in range(1000000))

# 字典推導(dǎo)式
square_dict = {x: x**2 for x in range(5)}

print(f"平方列表: {squares[:5]}...")
print(f"偶數(shù)平方: {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"點坐標(biāo): ({x}, {y})")

# 交換變量（Pythonic方式！）
a, b = 10, 20
a, b = b, a  # 不需要臨時變量！
print(f"交換后: a={a}, b=")

# 不好：創(chuàng)建完整副本
new_list = old_list[:]

# 更好：使用切片或list()構(gòu)造函數(shù)
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()