课程 11：列表（List）

核心概念

1.2 列表的定义与访问

# 定义列表
nums = [1, 2, 3, 4, 5]
words = ["apple", "banana", "cherry"]
mixed = [1, "hello", True, 3.14, [1, 2, 3]]

# 访问元素（索引从0开始）
print(nums[0])      # 1
print(words[2])     # cherry
print(mixed[-1])    # [1, 2, 3] (最后一个元素)

# 切片访问
print(nums[1:4])    # [2, 3, 4]
print(nums[::2])    # [1, 3, 5] (步长为2)
    

技术实现

# 列表操作示例
fruits = ["apple", "banana"]
print(f"原始列表: {fruits}")

# 添加元素
fruits.append("cherry")
fruits.insert(1, "orange")
fruits.extend(["grape", "mango"])
print(f"添加后: {fruits}")

# 删除元素
removed = fruits.pop()      # 删除并返回最后一个元素
fruits.remove("orange")     # 删除指定元素
print(f"删除后: {fruits}")
print(f"被删除的元素: {removed}")

# 获取信息
print(f"列表长度: {len(fruits)}")
print(f"是否包含'banana': {'banana' in fruits}")
    

2.2 切片与遍历

列表切片和遍历是处理数据的重要技巧：

# 切片操作详解
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 基本切片
print(numbers[2:5])    # [2, 3, 4] (索引2到4)
print(numbers[:3])     # [0, 1, 2] (从开始到索引2)
print(numbers[7:])     # [7, 8, 9] (从索引7到结束)

# 步长切片
print(numbers[::2])    # [0, 2, 4, 6, 8] (偶数索引)
print(numbers[1::2])   # [1, 3, 5, 7, 9] (奇数索引)
print(numbers[::-1])   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] (反转)

# 负索引切片
print(numbers[-3:])    # [7, 8, 9] (最后3个元素)
print(numbers[:-2])    # [0, 1, 2, 3, 4, 5, 6, 7] (除了最后2个)

# 遍历方式
print("方式1：直接遍历元素")
for num in numbers:
    print(num, end=" ")
print()

print("方式2：遍历索引和元素")
for i, num in enumerate(numbers):
    print(f"索引{i}: {num}")

print("方式3：遍历索引")
for i in range(len(numbers)):
    print(f"位置{i}: {numbers[i]}")
    

2.3 列表推导式

列表推导式是Python的优雅特性，可以用简洁的语法快速生成列表：

# 列表推导式示例

# 基础推导式：生成1-10的平方
squares = [x**2 for x in range(1, 11)]
print(f"平方数: {squares}")

# 条件推导式：筛选偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = [x for x in numbers if x % 2 == 0]
print(f"偶数: {evens}")

# 复杂推导式：字符串处理
words = ["hello", "world", "python", "programming"]
upper_words = [word.upper() for word in words if len(word) > 5]
print(f"长单词转大写: {upper_words}")

# 嵌套推导式：二维列表转一维
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(f"展平矩阵: {flattened}")

# 条件表达式推导式
result = [x if x > 0 else -x for x in [-1, 2, -3, 4, -5]]
print(f"绝对值: {result}")

# 字典推导式（扩展知识）
word_lengths = {word: len(word) for word in words}
print(f"单词长度字典: {word_lengths}")
    

2.4 嵌套列表与多维结构

列表可以嵌套，形成二维、三维甚至更高维的数据结构：

# 嵌套列表示例

# 二维列表（矩阵）
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print("矩阵:")
for row in matrix:
    print(row)

print(f"元素[1][2]: {matrix[1][2]}")  # 6

# 创建3x3单位矩阵
def create_identity_matrix(n):
    return [[1 if i == j else 0 for j in range(n)] for i in range(n)]

identity = create_identity_matrix(3)
print("单位矩阵:")
for row in identity:
    print(row)

# 三维列表（立方体）
cube = [
    [[1, 2], [3, 4]],
    [[5, 6], [7, 8]]
]

print(f"立方体[0][1][0]: {cube[0][1][0]}")  # 3

# 不规则嵌套列表
irregular = [
    [1, 2, 3],
    [4, 5],
    [6, 7, 8, 9],
    [10]
]

print("不规则列表:")
for i, row in enumerate(irregular):
    print(f"行{i}: {row} (长度: {len(row)})")
    

2.5 内置函数与高级操作

Python提供了许多内置函数来简化列表操作：

# 内置函数示例

# 数值计算
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
print(f"原始列表: {numbers}")
print(f"总和: {sum(numbers)}")
print(f"最大值: {max(numbers)}")
print(f"最小值: {min(numbers)}")
print(f"平均值: {sum(numbers) / len(numbers):.2f}")

# 排序和反转
print(f"升序排序: {sorted(numbers)}")
print(f"降序排序: {sorted(numbers, reverse=True)}")
print(f"反转: {list(reversed(numbers))}")

# 条件检查
print(f"是否所有数都大于0: {all(x > 0 for x in numbers)}")
print(f"是否有数大于8: {any(x > 8 for x in numbers)}")

# 高级排序
students = [
    {"name": "Alice", "age": 20, "grade": 85},
    {"name": "Bob", "age": 19, "grade": 92},
    {"name": "Charlie", "age": 21, "grade": 78}
]

# 按成绩排序
by_grade = sorted(students, key=lambda x: x["grade"], reverse=True)
print("按成绩排序:")
for student in by_grade:
    print(f"{student['name']}: {student['grade']}")

# 按年龄排序
by_age = sorted(students, key=lambda x: x["age"])
print("按年龄排序:")
for student in by_age:
    print(f"{student['name']}: {student['age']}岁")
    

关键知识点详解

3.1 列表基础特性

理解列表的核心特性对于正确使用Python列表至关重要：

# 基础特性示例
lst = [1, "hello", True, [2, 3]]
print(f"原始列表: {lst}")
print(f"列表类型: {type(lst)}")
print(f"列表长度: {len(lst)}")

# 可变性演示
print("\n=== 可变性演示 ===")
original_id = id(lst)
lst[0] = 100
lst.append("new_item")
print(f"修改后: {lst}")
print(f"内存地址变化: {id(lst) == original_id}")  # True

# 有序性演示
print("\n=== 有序性演示 ===")
print(f"第一个元素: {lst[0]}")
print(f"最后一个元素: {lst[-1]}")
print(f"切片[1:3]: {lst[1:3]}")
print(f"步长切片[::2]: {lst[::2]}")

# 元素多样性演示
print("\n=== 元素多样性演示 ===")
for i, item in enumerate(lst):
    print(f"索引{i}: {item} (类型: {type(item)})")
    

3.2 列表元素的增删改

列表的增删改操作是日常编程中最常用的功能：

# 增加元素示例
fruits = ["apple"]
print(f"初始列表: {fruits}")

# 添加单个元素
fruits.append("banana")
print(f"append后: {fruits}")

# 插入元素
fruits.insert(1, "orange")
print(f"insert后: {fruits}")

# 扩展列表
fruits.extend(["cherry", "date", "elderberry"])
print(f"extend后: {fruits}")

# 使用+=操作符
fruits += ["fig", "grape"]
print(f"+=操作后: {fruits}")

# 在指定位置插入多个元素
fruits[2:2] = ["kiwi", "lemon"]
print(f"切片插入后: {fruits}")
    

# 删除元素示例
numbers = [1, 2, 3, 2, 4, 5, 2, 6]
print(f"原始列表: {numbers}")

# 删除指定值
numbers.remove(2)  # 只删除第一个2
print(f"remove(2)后: {numbers}")

# 弹出元素
popped = numbers.pop()      # 删除并返回最后一个元素
print(f"pop()后: {numbers}")
print(f"被弹出的元素: {popped}")

popped_index = numbers.pop(1)  # 删除索引1的元素
print(f"pop(1)后: {numbers}")
print(f"被弹出的元素: {popped_index}")

# 删除指定索引
del numbers[0]
print(f"del numbers[0]后: {numbers}")

# 删除切片
del numbers[1:3]
print(f"del numbers[1:3]后: {numbers}")

# 清空列表
numbers.clear()
print(f"clear()后: {numbers}")
    

# 修改元素示例
lst = [1, 2, 3, 4, 5]
print(f"原始列表: {lst}")

# 修改单个元素
lst[2] = 30
print(f"修改索引2后: {lst}")

# 通过切片修改
lst[1:4] = [20, 30, 40]
print(f"切片修改[1:4]后: {lst}")

# 切片长度可不同
lst[1:3] = [200]
print(f"切片修改[1:3]后: {lst}")

# 条件修改
for i in range(len(lst)):
    if lst[i] % 2 == 0:
        lst[i] *= 10
print(f"偶数乘10后: {lst}")

# 列表推导式修改
lst = [x * 2 if x % 2 == 0 else x for x in lst]
print(f"推导式修改后: {lst}")
    

3.3 列表查询与排序

列表的查询和排序操作是数据处理中的核心功能：

# 查询操作示例
lst = [1, 2, 3, 2, 4, 2, 5]
print(f"原始列表: {lst}")

# 查找元素索引
print(f"元素2首次出现位置: {lst.index(2)}")      # 1
print(f"从索引2开始查找2: {lst.index(2, 2)}")   # 3
print(f"元素2出现次数: {lst.count(2)}")         # 3

# 检查元素存在性
print(f"元素3是否存在: {3 in lst}")             # True
print(f"元素6是否存在: {6 in lst}")             # False

# 查找所有匹配元素的索引
def find_all_indices(lst, target):
    """查找所有匹配元素的索引"""
    return [i for i, x in enumerate(lst) if x == target]

print(f"元素2的所有位置: {find_all_indices(lst, 2)}")  # [1, 3, 5]
    

# 排序与反转示例
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
print(f"原始列表: {numbers}")

# 基本排序
numbers.sort()  # 原地排序
print(f"升序排序: {numbers}")  # [1, 1, 2, 3, 4, 5, 6, 9]

numbers.sort(reverse=True)  # 降序排序
print(f"降序排序: {numbers}")  # [9, 6, 5, 4, 3, 2, 1, 1]

# 自定义排序
words = ["cat", "dog", "elephant", "ant", "zebra"]
words.sort(key=len)  # 按长度排序
print(f"按长度排序: {words}")  # ['ant', 'cat', 'dog', 'zebra', 'elephant']

words.sort(key=str.lower)  # 忽略大小写排序
print(f"忽略大小写排序: {words}")  # ['ant', 'cat', 'dog', 'elephant', 'zebra']

# 复杂对象排序
students = [
    {"name": "Alice", "age": 20, "grade": 85},
    {"name": "Bob", "age": 19, "grade": 92},
    {"name": "Charlie", "age": 21, "grade": 78}
]

# 按成绩排序
by_grade = sorted(students, key=lambda x: x["grade"], reverse=True)
print("按成绩排序:")
for student in by_grade:
    print(f"  {student['name']}: {student['grade']}")

# 按年龄排序
by_age = sorted(students, key=lambda x: x["age"])
print("按年龄排序:")
for student in by_age:
    print(f"  {student['name']}: {student['age']}岁")

# 多条件排序
by_grade_age = sorted(students, key=lambda x: (x["grade"], x["age"]), reverse=True)
print("按成绩和年龄排序:")
for student in by_grade_age:
    print(f"  {student['name']}: 成绩{student['grade']}, 年龄{student['age']}")

# 反转操作
numbers.reverse()
print(f"反转后: {numbers}")  # [1, 1, 2, 3, 4, 5, 6, 9]

# 使用reversed()函数
rev_iter = reversed(numbers)
rev_list = list(rev_iter)
print(f"reversed()结果: {rev_list}")  # [9, 6, 5, 4, 3, 2, 1, 1]
    

3.4 列表切片与拷贝

列表切片是Python的强大特性，而拷贝操作需要注意深浅拷贝的区别：

# 切片操作详解
lst = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(f"原始列表: {lst}")

# 基本切片
print(f"lst[2:6]: {lst[2:6]}")      # [2, 3, 4, 5]
print(f"lst[:5]: {lst[:5]}")         # [0, 1, 2, 3, 4]
print(f"lst[5:]: {lst[5:]}")         # [5, 6, 7, 8, 9]
print(f"lst[-3:]: {lst[-3:]}")       # [7, 8, 9] (最后3个元素)

# 步长切片
print(f"lst[::2]: {lst[::2]}")       # [0, 2, 4, 6, 8] (偶数索引)
print(f"lst[1::2]: {lst[1::2]}")     # [1, 3, 5, 7, 9] (奇数索引)
print(f"lst[::3]: {lst[::3]}")       # [0, 3, 6, 9] (步长为3)

# 负步长（反向）
print(f"lst[::-1]: {lst[::-1]}")     # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] (反转)
print(f"lst[::-2]: {lst[::-2]}")     # [9, 7, 5, 3, 1] (反向步长为2)

# 负索引切片
print(f"lst[-5:-2]: {lst[-5:-2]}")   # [5, 6, 7]
print(f"lst[-2:-5:-1]: {lst[-2:-5:-1]}")  # [8, 7, 6] (反向切片)

# 切片赋值
lst_copy = lst.copy()
lst_copy[2:5] = [20, 30, 40]
print(f"切片赋值后: {lst_copy}")

# 切片删除
lst_copy[1:4] = []
print(f"切片删除后: {lst_copy}")
    

# 拷贝操作详解
import copy

# 原始列表（包含嵌套结构）
original = [1, [2, 3], {"a": 4, "b": 5}]
print(f"原始列表: {original}")

# 1. 引用赋值（不是拷贝）
reference = original
print(f"引用赋值后: {reference}")
print(f"内存地址相同: {id(original) == id(reference)}")  # True

# 修改引用会影响原列表
reference[0] = 100
print(f"修改引用后原列表: {original}")  # [100, [2, 3], {"a": 4, "b": 5}]

# 2. 浅拷贝
shallow = original.copy()  # 等同于 original[:]
print(f"浅拷贝后: {shallow}")
print(f"内存地址不同: {id(original) != id(shallow)}")  # True

# 修改浅拷贝的第一层元素不会影响原列表
shallow[0] = 200
print(f"修改浅拷贝第一层后原列表: {original}")  # [100, [2, 3], {"a": 4, "b": 5}]

# 但修改嵌套对象会影响原列表（因为共享同一对象）
shallow[1][0] = 20
print(f"修改浅拷贝嵌套层后原列表: {original}")  # [100, [20, 3], {"a": 4, "b": 5}]

# 3. 深拷贝
deep = copy.deepcopy(original)
print(f"深拷贝后: {deep}")
print(f"内存地址不同: {id(original) != id(deep)}")  # True

# 修改深拷贝的任何层都不会影响原列表
deep[1][1] = 30
deep[2]["a"] = 40
print(f"修改深拷贝后原列表: {original}")  # [100, [20, 3], {"a": 4, "b": 5}]
print(f"深拷贝: {deep}")  # [100, [20, 30], {"a": 40, "b": 5}]

# 性能对比
import time

def test_copy_performance():
    large_list = [[i] for i in range(10000)]
    
    # 测试浅拷贝
    start = time.time()
    shallow_copy = large_list.copy()
    shallow_time = time.time() - start
    
    # 测试深拷贝
    start = time.time()
    deep_copy = copy.deepcopy(large_list)
    deep_time = time.time() - start
    
    print(f"浅拷贝时间: {shallow_time:.4f}秒")
    print(f"深拷贝时间: {deep_time:.4f}秒")
    print(f"深拷贝比浅拷贝慢 {deep_time/shallow_time:.1f}倍")

test_copy_performance()
    

3.5 列表推导式

列表推导式是Python的优雅特性，可以用简洁的语法快速生成列表：

# 列表推导式详解

# 1. 基础推导式
print("=== 基础推导式 ===")
squares = [x**2 for x in range(1, 11)]
print(f"1-10的平方: {squares}")

cubes = [x**3 for x in range(1, 6)]
print(f"1-5的立方: {cubes}")

# 2. 条件筛选推导式
print("\n=== 条件筛选推导式 ===")
numbers = list(range(1, 21))
evens = [x for x in numbers if x % 2 == 0]
odds = [x for x in numbers if x % 2 == 1]
print(f"偶数: {evens}")
print(f"奇数: {odds}")

# 筛选质数
def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

primes = [x for x in range(2, 50) if is_prime(x)]
print(f"质数: {primes}")

# 3. 字符串处理推导式
print("\n=== 字符串处理推导式 ===")
words = ["hello", "world", "python", "programming", "computer"]
long_words = [word.upper() for word in words if len(word) > 5]
print(f"长单词转大写: {long_words}")

# 字符统计
sentence = "hello world python programming"
char_count = {char: sentence.count(char) for char in set(sentence) if char != ' '}
print(f"字符统计: {char_count}")

# 4. 嵌套推导式
print("\n=== 嵌套推导式 ===")
# 二维列表转一维
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(f"展平矩阵: {flattened}")

# 生成乘法表
multiplication_table = [[i*j for j in range(1, 6)] for i in range(1, 6)]
print("乘法表:")
for row in multiplication_table:
    print(f"  {row}")

# 5. 条件表达式推导式
print("\n=== 条件表达式推导式 ===")
# 绝对值
numbers_with_signs = [-1, 2, -3, 4, -5, 6, -7, 8]
abs_values = [x if x > 0 else -x for x in numbers_with_signs]
print(f"绝对值: {abs_values}")

# 奇偶分类
classified = ["偶数" if x % 2 == 0 else "奇数" for x in range(1, 11)]
print(f"奇偶分类: {classified}")

# 6. 字典推导式（扩展）
print("\n=== 字典推导式 ===")
word_lengths = {word: len(word) for word in words}
print(f"单词长度字典: {word_lengths}")

# 7. 集合推导式（扩展）
print("\n=== 集合推导式 ===")
unique_lengths = {len(word) for word in words}
print(f"单词长度集合: {unique_lengths}")

# 8. 性能对比
print("\n=== 性能对比 ===")
import time

def traditional_way(n):
    result = []
    for i in range(n):
        if i % 2 == 0:
            result.append(i**2)
    return result

def comprehension_way(n):
    return [i**2 for i in range(n) if i % 2 == 0]

n = 1000000
start = time.time()
traditional_way(n)
traditional_time = time.time() - start

start = time.time()
comprehension_way(n)
comprehension_time = time.time() - start

print(f"传统方式时间: {traditional_time:.4f}秒")
print(f"推导式时间: {comprehension_time:.4f}秒")
print(f"推导式比传统方式快 {traditional_time/comprehension_time:.1f}倍")
    

3.6 列表与其他数据结构转换

Python中不同数据结构之间可以相互转换，掌握这些转换方法很有用：

# 数据结构转换详解

# 1. 列表与字符串转换
print("=== 列表与字符串转换 ===")

# 列表转字符串
chars = ['H', 'e', 'l', 'l', 'o']
word = ''.join(chars)
print(f"字符列表: {chars}")
print(f"转字符串: {word}")

# 带分隔符的转换
fruits = ['apple', 'banana', 'cherry']
fruits_str = ', '.join(fruits)
print(f"水果列表: {fruits}")
print(f"转字符串: {fruits_str}")

# 字符串转列表
sentence = "Hello World Python Programming"
char_list = list(sentence)
word_list = sentence.split()
print(f"句子: {sentence}")
print(f"转字符列表: {char_list}")
print(f"转单词列表: {word_list}")

# 按特定分隔符分割
csv_line = "张三,25,北京,工程师"
csv_list = csv_line.split(',')
print(f"CSV行: {csv_line}")
print(f"分割后: {csv_list}")

# 2. 列表与元组转换
print("\n=== 列表与元组转换 ===")
numbers_list = [1, 2, 3, 4, 5]
numbers_tuple = tuple(numbers_list)
print(f"列表: {numbers_list}")
print(f"转元组: {numbers_tuple}")

# 元组转列表
coordinates = (10, 20, 30)
coordinates_list = list(coordinates)
print(f"坐标元组: {coordinates}")
print(f"转列表: {coordinates_list}")

# 3. 列表与集合转换
print("\n=== 列表与集合转换 ===")
duplicate_numbers = [1, 2, 2, 3, 3, 4, 5, 5]
unique_numbers = list(set(duplicate_numbers))
print(f"有重复的列表: {duplicate_numbers}")
print(f"去重后: {unique_numbers}")

# 注意：集合无序，转换后顺序可能改变
original_order = [3, 1, 4, 1, 5, 9, 2, 6]
set_conversion = list(set(original_order))
print(f"原始顺序: {original_order}")
print(f"集合转换后: {set_conversion}")

# 4. 列表与字典转换
print("\n=== 列表与字典转换 ===")
student_info = {"name": "张三", "age": 20, "grade": "A"}
keys_list = list(student_info.keys())
values_list = list(student_info.values())
items_list = list(student_info.items())
print(f"学生信息: {student_info}")
print(f"键列表: {keys_list}")
print(f"值列表: {values_list}")
print(f"键值对列表: {items_list}")

# 列表转字典（需要特定格式）
pairs = [("a", 1), ("b", 2), ("c", 3)]
dict_from_pairs = dict(pairs)
print(f"键值对列表: {pairs}")
print(f"转字典: {dict_from_pairs}")

# 5. 高级转换技巧
print("\n=== 高级转换技巧 ===")

# 嵌套结构转换
nested_data = [
    ["name", "age", "city"],
    ["张三", 25, "北京"],
    ["李四", 30, "上海"],
    ["王五", 28, "广州"]
]

# 转换为字典列表
headers = nested_data[0]
data_dicts = []
for row in nested_data[1:]:
    data_dicts.append(dict(zip(headers, row)))

print("嵌套数据:")
for row in nested_data:
    print(f"  {row}")

print("转换为字典列表:")
for data_dict in data_dicts:
    print(f"  {data_dict}")

# 6. 实际应用示例
print("\n=== 实际应用示例 ===")

# CSV数据处理
csv_data = [
    "姓名,年龄,职业,城市",
    "张三,25,工程师,北京",
    "李四,30,设计师,上海",
    "王五,28,教师,广州"
]

def parse_csv(csv_lines):
    """解析CSV数据"""
    if not csv_lines:
        return []
    
    headers = csv_lines[0].split(',')
    data = []
    
    for line in csv_lines[1:]:
        values = line.split(',')
        row_dict = dict(zip(headers, values))
        data.append(row_dict)
    
    return data

parsed_data = parse_csv(csv_data)
print("解析后的CSV数据:")
for item in parsed_data:
    print(f"  {item}")

# 7. 性能考虑
print("\n=== 性能考虑 ===")
import time

def test_conversion_performance():
    large_list = list(range(100000))
    
    # 测试列表转元组
    start = time.time()
    tuple_result = tuple(large_list)
    tuple_time = time.time() - start
    
    # 测试列表转集合
    start = time.time()
    set_result = set(large_list)
    set_time = time.time() - start
    
    print(f"列表转元组时间: {tuple_time:.4f}秒")
    print(f"列表转集合时间: {set_time:.4f}秒")

test_conversion_performance()