06. Python序列与列表：从入门到精通

# 让我们详细了解序列的基本操作：

# 1. 索引访问
# Python中的索引从0开始，可以使用正索引（从左往右）或负索引（从右往左）
my_list = [1, 2, 3, 4, 5]
print(my_list[0])   # 输出第一个元素：1
print(my_list[-1])  # 输出最后一个元素：5

# 2. 切片操作
# 切片语法：list[start:end:step]
# start：起始索引（包含）
# end：结束索引（不包含）
# step：步长（可选，默认为1）
print(my_list[1:4])    # 输出：[2, 3, 4]  # 从索引1到3的元素
print(my_list[::2])    # 输出：[1, 3, 5]  # 步长为2，取所有偶数位置的元素
print(my_list[::-1])   # 输出：[5, 4, 3, 2, 1]  # 步长为-1，实现列表反转

# 3. 序列相加（拼接操作）
# 可以使用+运算符将两个序列连接在一起，创建一个新的序列
list1 = [1, 2]
list2 = [3, 4]
print(list1 + list2)  # 输出：[1, 2, 3, 4]
# 注意：相加操作会创建一个新的列表，原列表不变

# 4. 序列乘法（重复操作）
# 使用*运算符可以将序列重复指定次数
print(list1 * 2)  # 输出：[1, 2, 1, 2]
# 注意：乘法操作也会创建一个新的列表

# 性能提示：
# 1. 对于大型列表，切片操作可能会占用额外的内存
# 2. 如果只需要遍历，考虑使用迭代器而不是切片
# 3. 频繁的列表相加操作可能影响性能，考虑使用列表的extend()方法或列表推导式

# 让我们详细了解序列的基本操作：

# 1. 索引访问
# Python中的索引从0开始，可以使用正索引（从左往右）或负索引（从右往左）
my_list = [1, 2, 3, 4, 5]
print(my_list[0])   # 输出第一个元素：1
print(my_list[-1])  # 输出最后一个元素：5

# 2. 切片操作
# 切片语法：list[start:end:step]
# start：起始索引（包含）
# end：结束索引（不包含）
# step：步长（可选，默认为1）
print(my_list[1:4])    # 输出：[2, 3, 4]  # 从索引1到3的元素
print(my_list[::2])    # 输出：[1, 3, 5]  # 步长为2，取所有偶数位置的元素
print(my_list[::-1])   # 输出：[5, 4, 3, 2, 1]  # 步长为-1，实现列表反转

# 3. 序列相加（拼接操作）
# 可以使用+运算符将两个序列连接在一起，创建一个新的序列
list1 = [1, 2]
list2 = [3, 4]
print(list1 + list2)  # 输出：[1, 2, 3, 4]
# 注意：相加操作会创建一个新的列表，原列表不变

# 4. 序列乘法（重复操作）
# 使用*运算符可以将序列重复指定次数
print(list1 * 2)  # 输出：[1, 2, 1, 2]
# 注意：乘法操作也会创建一个新的列表

# 性能提示：
# 1. 对于大型列表，切片操作可能会占用额外的内存
# 2. 如果只需要遍历，考虑使用迭代器而不是切片
# 3. 频繁的列表相加操作可能影响性能，考虑使用列表的extend()方法或列表推导式

# 列表的创建方式详解

# 1. 使用方括号 - 最直观的创建方式
# 可以创建空列表或包含初始元素的列表
fruits = ['苹果', '香蕉', '橙子']  # 创建包含元素的列表
empty_list = []  # 创建空列表
mixed_list = [1, '苹果', 3.14, True]  # 列表可以包含不同类型的元素

# 2. 使用list()函数 - 可以将其他可迭代对象转换为列表
# 常用于将range、字符串、元组等转换为列表
numbers = list(range(5))  # 将range对象转换为列表：[0, 1, 2, 3, 4]
char_list = list('Hello')  # 将字符串转换为字符列表：['H', 'e', 'l', 'l', 'o']

# 3. 列表推导式 - 简洁高效的列表创建方式
# 基本语法：[表达式 for 变量 in 可迭代对象 if 条件]
squares = [x**2 for x in range(5)]  # 计算平方：[0, 1, 4, 9, 16]
even_numbers = [x for x in range(10) if x % 2 == 0]  # 筛选偶数：[0, 2, 4, 6, 8]

# 性能提示：
# 1. 列表推导式通常比循环创建列表更快、更简洁
# 2. 对于简单的列表创建，使用方括号是最直观的选择
# 3. 当需要转换其他数据类型时，使用list()函数是最佳选择

# 1. append() - 在列表末尾添加元素
fruits = ['苹果', '香蕉']
fruits.append('橙子')  # ['苹果', '香蕉', '橙子']

# 2. insert() - 在指定位置插入元素
fruits.insert(1, '梨')  # ['苹果', '梨', '香蕉', '橙子']

# 3. extend() - 扩展列表
more_fruits = ['葡萄', '西瓜']
fruits.extend(more_fruits)  # ['苹果', '梨', '香蕉', '橙子', '葡萄', '西瓜']

# 1. remove() - 删除指定元素
fruits = ['苹果', '梨', '香蕉', '橙子']
fruits.remove('梨')  # ['苹果', '香蕉', '橙子']

# 2. pop() - 删除并返回指定位置的元素
removed = fruits.pop(1)  # removed = '香蕉', fruits = ['苹果', '橙子']

# 3. del语句 - 删除指定位置的元素
del fruits[0]  # ['橙子']

# 4. clear() - 清空列表
fruits.clear()  # []

# 1. 直接赋值修改
fruits = ['苹果', '梨', '香蕉']
fruits[1] = '橙子'  # ['苹果', '橙子', '香蕉']

# 2. 切片赋值
fruits[1:3] = ['葡萄', '西瓜']  # ['苹果', '葡萄', '西瓜']

# 3. 列表解析式修改
numbers = [1, 2, 3, 4, 5]
numbers = [x*2 for x in numbers]  # [2, 4, 6, 8, 10]

# 1. index() - 查找元素位置
fruits = ['苹果', '梨', '香蕉', '梨']
print(fruits.index('梨'))  # 输出：1（第一次出现的位置）

# 2. count() - 统计元素出现次数
print(fruits.count('梨'))  # 输出：2

# 3. in运算符 - 检查元素是否存在
print('苹果' in fruits)  # 输出：True

# 1. sort()方法 - 原地排序
fruits = ['香蕉', '苹果', '橙子', '葡萄']
fruits.sort()  # 按字母顺序排序
print(f"排序后的水果列表：{fruits}")

# 自定义排序
students = [
    {'name': '张三', 'score': 85},
    {'name': '李四', 'score': 92},
    {'name': '王五', 'score': 78}
]
students.sort(key=lambda x: x['score'], reverse=True)  # 按分数降序排序

# 2. sorted()函数 - 返回新列表
prices = [42.5, 12.8, 35.9, 8.2]
sorted_prices = sorted(prices)  # 不改变原列表

# 1. 列表推导式 vs 循环
import time

# 使用列表推导式
start = time.time()
squares1 = [x**2 for x in range(10000)]
print(f"列表推导式耗时：{time.time() - start}秒")

# 使用循环
start = time.time()
squares2 = []
for x in range(10000):
    squares2.append(x**2)
print(f"循环耗时：{time.time() - start}秒")

# 2. 适当使用生成器表达式节省内存
numbers_gen = (x for x in range(1000000))  # 生成器表达式

# 3. 列表切片的高效使用
data = list(range(1000000))
# 高效：使用切片
reversed_data = data[::-1]
# 低效：使用循环手动反转

# 1. 创建二维列表
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 2. 矩阵转置
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]

# 3. 深浅拷贝
import copy

original = [[1, 2, 3], [4, 5, 6]]
shallow_copy = original.copy()  # 浅拷贝
deep_copy = copy.deepcopy(original)  # 深拷贝

original[0][0] = 99
print(f"浅拷贝：{shallow_copy}")  # 浅拷贝也会改变
print(f"深拷贝：{deep_copy}")  # 深拷贝不变

# 1. 数据清洗和转换
raw_data = ['12', '15', 'N/A', '18', 'error', '20']

def clean_data(data):
    cleaned = []
    for item in data:
        try:
            cleaned.append(int(item))
        except ValueError:
            continue
    return cleaned

clean_numbers = clean_data(raw_data)
print(f"清洗后的数据：{clean_numbers}")

# 2. 数据分析
prices = [42.5, 38.9, 56.2, 35.8, 42.5, 38.9]

# 计算基本统计量
avg_price = sum(prices) / len(prices)
max_price = max(prices)
min_price = min(prices)
unique_prices = list(set(prices))  # 去重

print(f"平均价格：{avg_price:.2f}")
print(f"价格范围：{min_price} - {max_price}")
print(f"不同价格数量：{len(unique_prices)}")

# 购物车系统实现
# 这是一个基于列表的购物车系统，展示了列表在实际应用中的使用方法
# 系统支持添加商品、删除商品、更新数量、计算总价等功能

class ShoppingCart:
    def __init__(self):
        # 初始化购物车
        # items是一个列表，每个元素是一个字典，包含商品的名称、价格和数量
        self.items = []

    def add_item(self, name, price, quantity=1):
        """添加商品到购物车

        参数说明：
        - name: 商品名称
        - price: 商品单价
        - quantity: 商品数量，默认为1

        如果商品已存在，会增加数量；如果是新商品，会创建新条目
        """
        # 首先检查商品是否已存在
        for item in self.items:
            if item['name'] == name:
                # 如果存在，增加数量
                item['quantity'] += quantity
                return

        # 如果是新商品，添加到购物车
        self.items.append({
            'name': name,
            'price': price,
            'quantity': quantity
        })

    def remove_item(self, name):
        """从购物车中移除指定商品

        使用列表推导式过滤掉要删除的商品
        这比循环删除更高效，因为创建了一个新列表
        """
        self.items = [item for item in self.items if item['name'] != name]

    def update_quantity(self, name, quantity):
        """更新购物车中商品的数量

        如果找到商品，直接更新其数量
        使用break提前结束循环，提高效率
        """
        for item in self.items:
            if item['name'] == name:
                item['quantity'] = quantity
                break

    def get_total(self):
        """计算购物车总价

        使用列表推导式和sum函数计算总价
        这比循环计算更简洁高效
        """
        return sum(item['price'] * item['quantity'] for item in self.items)

    def get_item_count(self):
        """获取购物车中的商品总数量

        使用sum和生成器表达式计算总数
        这种方式比循环累加更优雅
        """
        return sum(item['quantity'] for item in self.items)

    def show_cart(self):
        """显示购物车内容

        格式化输出每个商品的信息和总价
        使用f-string进行字符串格式化，更现代和易读
        """
        print("\n=== 购物车内容 ===")
        for item in self.items:
            total = item['price'] * item['quantity']
            print(f"{item['name']} x {item['quantity']} = ¥{total:.2f}")
        print(f"总计：¥{self.get_total():.2f}")

# 使用示例
# 创建购物车实例
cart = ShoppingCart()

# 添加商品，展示不同的添加方式
cart.add_item('苹果', 5.5, 3)  # 添加3个苹果
cart.add_item('香蕉', 2.8, 2)  # 添加2个香蕉
cart.add_item('苹果', 5.5, 2)  # 给已有商品增加数量

# 显示购物车内容
cart.show_cart()