搞定Python3列表操作？先刷这100道练习题（附详解）

原创已于 2025-10-12 15:29:06 修改 · 361 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#python #pip #list

于 2025-10-11 12:27:57 首次发布

Python 专栏收录该内容

101 篇文章

订阅专栏

在这里插入图片描述

文章目录

搞定Python3列表操作？先刷这100道练习题（附详解）

搞定Python3列表操作？先刷这100道练习题（附详解）

以下是100个Python3列表练习题的详解与代码示例，涵盖列表创建、访问、修改、切片、排序、推导式、嵌套列表等核心知识点，由浅入深排列，适合入门学习。

一、列表基础（1-10）

1. 题目：创建空列表

需求：创建一个空列表，并打印其类型和内容。

empty_list = []
# 或使用list()函数
# empty_list = list()
print(type(empty_list))  # 输出：<class 'list'>
print(empty_list)        # 输出：[]

解析：用[]或list()可创建空列表，列表是Python中用于存储有序元素的可变序列。

2. 题目：创建包含不同类型元素的列表

需求：创建一个包含整数、字符串、浮点数和布尔值的列表。

mixed_list = [42, "Python", 3.14, True]
print(mixed_list)  # 输出：[42, 'Python', 3.14, True]

解析：Python列表支持存储不同类型的元素，这是其灵活性的体现。

3. 题目：访问列表中的第一个元素

需求：获取列表[10, 20, 30, 40]的第一个元素。

numbers = [10, 20, 30, 40]
print(numbers[0])  # 输出：10

解析：列表元素通过索引访问，索引从0开始（第一个元素索引为0）。

4. 题目：访问列表中的最后一个元素

需求：获取列表["a", "b", "c", "d"]的最后一个元素（不使用具体索引值）。

letters = ["a", "b", "c", "d"]
print(letters[-1])  # 输出：d

解析：负索引表示从末尾开始计数，-1对应最后一个元素，-2对应倒数第二个，以此类推。

5. 题目：修改列表中的元素

需求：将列表[1, 2, 3, 4]中索引为2的元素改为99。

nums = [1, 2, 3, 4]
nums[2] = 99
print(nums)  # 输出：[1, 2, 99, 4]

解析：列表是可变对象，可通过列表[索引] = 新值直接修改指定位置的元素。

6. 题目：获取列表的长度

需求：计算列表[5, 4, 3, 2, 1]中元素的数量。

lst = [5, 4, 3, 2, 1]
print(len(lst))  # 输出：5

解析：len()函数返回列表中元素的个数，是操作列表的基础函数。

7. 题目：判断元素是否在列表中

需求：检查3是否在列表[1, 2, 3, 4, 5]中。

numbers = [1, 2, 3, 4, 5]
print(3 in numbers)  # 输出：True
print(6 in numbers)  # 输出：False

解析：in关键字用于判断元素是否存在于列表中，返回布尔值；not in则判断是否不存在。

8. 题目：列表拼接

需求：将列表[1, 2, 3]和[4, 5, 6]拼接成[1, 2, 3, 4, 5, 6]。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2
print(combined)  # 输出：[1, 2, 3, 4, 5, 6]

解析：+运算符可用于列表拼接，生成新列表（原列表不变）。

9. 题目：列表重复

需求：将列表["a", "b"]重复3次，得到["a", "b", "a", "b", "a", "b"]。

base = ["a", "b"]
repeated = base * 3
print(repeated)  # 输出：['a', 'b', 'a', 'b', 'a', 'b']

解析：*运算符可用于列表重复，列表 * n表示将列表元素重复n次。

10. 题目：列表赋值与引用

需求：创建列表lst = [1, 2, 3]，将其赋值给lst2，修改lst2后观察lst是否变化。

lst = [1, 2, 3]
lst2 = lst  # lst2与lst指向同一个列表对象
lst2[0] = 99
print(lst)   # 输出：[99, 2, 3]（原列表被修改）
print(lst2)  # 输出：[99, 2, 3]

解析：列表赋值是引用传递（不是复制），修改新列表会影响原列表，如需独立副本需使用拷贝。

二、列表元素的添加与删除（11-20）

11. 题目：在列表末尾添加元素

需求：向列表[1, 2, 3]的末尾添加元素4。

numbers = [1, 2, 3]
numbers.append(4)
print(numbers)  # 输出：[1, 2, 3, 4]

解析：append(x)方法在列表末尾添加单个元素x，修改原列表。

12. 题目：在列表指定位置插入元素

需求：在列表[1, 3, 4]的索引1位置插入元素2。

nums = [1, 3, 4]
nums.insert(1, 2)  # 第一个参数是插入位置，第二个是插入元素
print(nums)  # 输出：[1, 2, 3, 4]

解析：insert(index, x)在指定索引处插入元素x，原索引及之后的元素后移。

13. 题目：合并两个列表（扩展列表）

需求：将列表[4, 5, 6]的元素添加到列表[1, 2, 3]的末尾。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list1.extend(list2)  # 扩展list1，添加list2的所有元素
print(list1)  # 输出：[1, 2, 3, 4, 5, 6]

解析：extend(iterable)将可迭代对象（如列表）的所有元素添加到列表末尾，区别于append()（添加整个对象）。

14. 题目：删除列表中指定值的元素

需求：从列表["apple", "banana", "cherry"]中删除"banana"。

fruits = ["apple", "banana", "cherry"]
fruits.remove("banana")  # 移除第一个值为"banana"的元素
print(fruits)  # 输出：['apple', 'cherry']

解析：remove(x)删除列表中第一个值为x的元素，若x不存在会抛ValueError。

15. 题目：删除列表中指定索引的元素

需求：删除列表[10, 20, 30, 40]中索引为1的元素。

nums = [10, 20, 30, 40]
del nums[1]  # 删除索引1的元素
print(nums)  # 输出：[10, 30, 40]

解析：del语句可删除指定索引的元素，也可删除整个列表（如del nums）。

16. 题目：删除并返回列表末尾的元素

需求：从列表[1, 2, 3, 4]中删除最后一个元素，并返回该元素。

lst = [1, 2, 3, 4]
last = lst.pop()  # 无参数时默认删除最后一个元素
print(last)  # 输出：4
print(lst)   # 输出：[1, 2, 3]

解析：pop(index)删除并返回指定索引的元素，默认删除最后一个（index=-1）。

17. 题目：删除并返回列表指定位置的元素

需求：从列表["a", "b", "c", "d"]中删除索引为2的元素，并返回它。

letters = ["a", "b", "c", "d"]
removed = letters.pop(2)
print(removed)  # 输出：c
print(letters)  # 输出：['a', 'b', 'd']

解析：pop()是唯一既能删除元素又能返回该元素的列表方法，常用于栈（后进先出）操作。

18. 题目：清空列表

需求：删除列表[1, 2, 3, 4]中的所有元素，使其变为空列表。

lst = [1, 2, 3, 4]
lst.clear()  # 清空列表
# 等价于 lst[:] = [] 或 del lst[:]
print(lst)  # 输出：[]

解析：clear()方法清空列表所有元素，保留列表对象本身（与del lst删除对象不同）。

19. 题目：批量添加元素到列表

需求：创建一个空列表，依次添加1, 2, 3, 4, 5。

numbers = []
for i in range(1, 6):
    numbers.append(i)
print(numbers)  # 输出：[1, 2, 3, 4, 5]

解析：通过循环结合append()，可批量向列表添加元素，适合动态生成列表。

20. 题目：在列表开头添加元素

需求：在列表[2, 3, 4]的开头添加元素1。

lst = [2, 3, 4]
lst.insert(0, 1)  # 在索引0处插入1
print(lst)  # 输出：[1, 2, 3, 4]

解析：insert(0, x)可在列表开头添加元素，但频繁在开头插入效率较低（需移动所有元素）。

三、列表切片（21-30）

21. 题目：获取列表的前3个元素

需求：从列表[10, 20, 30, 40, 50]中获取前3个元素。

nums = [10, 20, 30, 40, 50]
print(nums[:3])  # 输出：[10, 20, 30]

解析：切片语法列表[start:end]返回从start到end-1的子列表，nums[:3]等价于nums[0:3]。

22. 题目：获取列表的后3个元素

需求：从列表[10, 20, 30, 40, 50]中获取后3个元素。

nums = [10, 20, 30, 40, 50]
print(nums[-3:])  # 输出：[30, 40, 50]

解析：nums[-3:]表示从索引-3（倒数第3个）到末尾的子列表。

23. 题目：获取列表的中间部分元素

需求：从列表[1, 2, 3, 4, 5, 6, 7]中获取索引2到5的元素（包含2，不包含5）。

lst = [1, 2, 3, 4, 5, 6, 7]
print(lst[2:5])  # 输出：[3, 4, 5]

解析：start和end都指定时，切片范围是[start, end)，即包含start，不包含end。

24. 题目：隔一个元素取一个

需求：从列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]中隔一个元素取一个（取偶数索引元素）。

nums = list(range(10))  # [0,1,2,3,4,5,6,7,8,9]
print(nums[::2])  # 输出：[0, 2, 4, 6, 8]

解析：完整切片语法为列表[start:end:step]，step=2表示每隔1个元素取一个（步长为2）。

25. 题目：反向取元素

需求：从列表[1, 2, 3, 4, 5]中从后往前每隔一个元素取一个。

lst = [1, 2, 3, 4, 5]
print(lst[::-2])  # 输出：[5, 3, 1]

解析：step为负数表示反向切片，::-2即从末尾开始，步长为2取元素。

26. 题目：列表反转（用切片）

需求：将列表[1, 2, 3, 4, 5]反转成[5, 4, 3, 2, 1]。

lst = [1, 2, 3, 4, 5]
reversed_lst = lst[::-1]
print(reversed_lst)  # 输出：[5, 4, 3, 2, 1]

解析：[::-1]是反转列表的简洁方法，生成新列表（原列表不变），区别于reverse()方法（修改原列表）。

27. 题目：用切片修改列表部分元素

需求：将列表[1, 2, 3, 4, 5]中索引1到3的元素替换为[9, 9]。

lst = [1, 2, 3, 4, 5]
lst[1:4] = [9, 9]  # 替换索引1-3（原元素2,3,4）为[9,9]
print(lst)  # 输出：[1, 9, 9, 5]

解析：切片赋值可批量替换列表元素，右侧可迭代对象的长度不必与切片长度一致（列表会自动调整长度）。

28. 题目：用切片删除列表部分元素

需求：删除列表[1, 2, 3, 4, 5, 6]中索引2到4的元素。

lst = [1, 2, 3, 4, 5, 6]
lst[2:5] = []  # 将索引2-4的元素替换为空列表（即删除）
# 等价于 del lst[2:5]
print(lst)  # 输出：[1, 2, 6]

解析：将切片赋值为空列表，或用del语句删除切片，均可批量删除列表元素。

29. 题目：复制列表（用切片）

需求：创建列表[1, 2, 3]的副本，修改副本不影响原列表。

original = [1, 2, 3]
copy = original[:]  # 切片复制（浅拷贝）
copy[0] = 99
print(original)  # 输出：[1, 2, 3]（原列表不变）
print(copy)      # 输出：[99, 2, 3]

解析：original[:]创建列表的浅拷贝，与original.copy()效果相同，副本与原列表独立。

30. 题目：获取列表的奇数索引元素

需求：从列表["a", "b", "c", "d", "e", "f"]中获取索引为1,3,5的元素。

letters = ["a", "b", "c", "d", "e", "f"]
print(letters[1::2])  # 输出：['b', 'd', 'f']

解析：start=1，step=2表示从索引1开始，每隔1个元素取一个，即奇数索引元素。

四、列表排序与反转（31-40）

31. 题目：列表升序排序

需求：将列表[3, 1, 4, 1, 5, 9]按升序（从小到大）排列。

nums = [3, 1, 4, 1, 5, 9]
nums.sort()  # 原地排序（修改原列表）
print(nums)  # 输出：[1, 1, 3, 4, 5, 9]

解析：sort()方法对列表进行原地排序（直接修改原列表），默认升序。

32. 题目：列表降序排序

需求：将列表[3, 1, 4, 1, 5, 9]按降序（从大到小）排列。

nums = [3, 1, 4, 1, 5, 9]
nums.sort(reverse=True)  # reverse=True表示降序
print(nums)  # 输出：[9, 5, 4, 3, 1, 1]

解析：sort(reverse=True)按降序排序，同样是原地修改。

33. 题目：获取排序后的列表副本（不修改原列表）

需求：对列表[3, 1, 4]排序，得到新的排序后列表，原列表不变。

original = [3, 1, 4]
sorted_list = sorted(original)  # sorted()返回新列表
print(original)    # 输出：[3, 1, 4]（原列表不变）
print(sorted_list) # 输出：[1, 3, 4]

解析：内置函数sorted()返回排序后的新列表，原列表保持不变，区别于sort()方法。

34. 题目：按元素长度排序

需求：将列表["apple", "banana", "cherry", "date"]按字符串长度升序排列。

fruits = ["apple", "banana", "cherry", "date"]
# 按元素长度排序，key=len表示用元素的长度作为排序依据
fruits.sort(key=len)
print(fruits)  # 输出：['date', 'apple', 'banana', 'cherry']

解析：sort(key=func)可自定义排序依据，key=len表示按元素的长度排序。

35. 题目：按元素的第二个字符排序

需求：将列表["bac", "abc", "cab"]按每个字符串的第二个字符升序排列。

words = ["bac", "abc", "cab"]
# 按第二个字符排序（索引1）
words.sort(key=lambda x: x[1])
print(words)  # 输出：['abc', 'cab', 'bac']（第二个字符分别为'b','a','a' → 排序后为a,a,b）

解析：key=lambda x: x[1]指定用元素的第二个字符（索引1）作为排序依据。

36. 题目：列表反转（用方法）

需求：将列表[1, 2, 3, 4, 5]反转，修改原列表。

lst = [1, 2, 3, 4, 5]
lst.reverse()  # 原地反转（修改原列表）
print(lst)  # 输出：[5, 4, 3, 2, 1]

解析：reverse()方法原地反转列表（修改原列表），区别于[::-1]（生成新列表）。

37. 题目：获取反转后的列表副本

需求：反转列表[1, 2, 3]，得到新列表，原列表不变。

original = [1, 2, 3]
reversed_copy = list(reversed(original))  # reversed()返回迭代器，需转为列表
print(original)       # 输出：[1, 2, 3]
print(reversed_copy)  # 输出：[3, 2, 1]

解析：内置函数reversed()返回一个反转的迭代器，需用list()转为列表，原列表不变。

38. 题目：对包含元组的列表排序

需求：将列表[(3, "c"), (1, "a"), (2, "b")]按元组的第一个元素升序排列。

tuples = [(3, "c"), (1, "a"), (2, "b")]
tuples.sort()  # 默认按元组第一个元素排序
print(tuples)  # 输出：[(1, 'a'), (2, 'b'), (3, 'c')]

解析：元组比较时会按元素顺序依次比较，因此包含元组的列表可直接排序。

39. 题目：按多个条件排序

需求：将学生列表[("张三", 85), ("李四", 90), ("王五", 85)]先按成绩降序，成绩相同则按姓名升序。

students = [("张三", 85), ("李四", 90), ("王五", 85)]
# 先按成绩降序（-x[1]），再按姓名升序（x[0]）
students.sort(key=lambda x: (-x[1], x[0]))
print(students)  # 输出：[('李四', 90), ('王五', 85), ('张三', 85)]

解析：key可返回元组，实现多条件排序，元组中前面的条件优先级更高。

40. 题目：忽略大小写排序字符串列表

需求：将列表["Banana", "apple", "Cherry"]按字母顺序排序，忽略大小写。

fruits = ["Banana", "apple", "Cherry"]
# 按小写形式排序（忽略大小写）
fruits.sort(key=lambda x: x.lower())
print(fruits)  # 输出：['apple', 'Banana', 'Cherry']

解析：key=lambda x: x.lower()将元素转为小写后排序，实现忽略大小写的字母序排序。

五、列表统计与查找（41-50）

41. 题目：统计元素出现的次数

需求：统计列表[1, 2, 2, 3, 3, 3]中3出现的次数。

lst = [1, 2, 2, 3, 3, 3]
print(lst.count(3))  # 输出：3

解析：count(x)方法返回元素x在列表中出现的次数。

42. 题目：查找元素首次出现的索引

需求：查找列表["a", "b", "a", "c"]中"a"首次出现的索引。

letters = ["a", "b", "a", "c"]
print(letters.index("a"))  # 输出：0

解析：index(x)返回元素x在列表中首次出现的索引，若x不存在会抛ValueError。

43. 题目：查找元素最后出现的索引

需求：查找列表["a", "b", "a", "c"]中"a"最后出现的索引。

letters = ["a", "b", "a", "c"]
# 从末尾开始查找
last_index = len(letters) - 1 - letters[::-1].index("a")
print(last_index)  # 输出：2

解析：列表无直接获取最后索引的方法，可通过反转列表后计算（反转后首次出现的索引对应原列表最后出现的索引）。

44. 题目：计算列表元素的和

需求：计算列表[1, 2, 3, 4, 5]中所有元素的和。

nums = [1, 2, 3, 4, 5]
print(sum(nums))  # 输出：15

解析：内置函数sum()返回列表中所有数值元素的和，列表元素需为可相加的类型（如整数、浮点数）。

45. 题目：获取列表中的最大值

需求：找出列表[5, 2, 9, 1, 6]中的最大值。

nums = [5, 2, 9, 1, 6]
print(max(nums))  # 输出：9

解析：内置函数max()返回列表中的最大元素，元素需支持比较运算。

46. 题目：获取列表中的最小值

需求：找出列表[5, 2, 9, 1, 6]中的最小值。

nums = [5, 2, 9, 1, 6]
print(min(nums))  # 输出：1

解析：内置函数min()返回列表中的最小元素。

47. 题目：计算列表元素的平均值

需求：计算列表[1, 2, 3, 4, 5]中元素的平均值。

nums = [1, 2, 3, 4, 5]
average = sum(nums) / len(nums)
print(average)  # 输出：3.0

解析：平均值 = 总和 / 元素个数，需注意避免列表为空（否则会抛ZeroDivisionError）。

48. 题目：检查列表是否为空

需求：判断列表[]和[1]是否为空。

empty_lst = []
non_empty_lst = [1]
print(len(empty_lst) == 0)      # 输出：True
print(not empty_lst)            # 输出：True（更简洁的方式）
print(len(non_empty_lst) == 0)  # 输出：False

解析：not 列表是判断列表是否为空的简洁方式（空列表为False，非空为True）。

49. 题目：查找列表中最大值的索引

需求：找出列表[5, 2, 9, 1, 6]中最大值所在的索引。

nums = [5, 2, 9, 1, 6]
max_value = max(nums)
max_index = nums.index(max_value)
print(max_index)  # 输出：2

解析：先通过max()找到最大值，再用index()获取其索引（若有多个最大值，返回第一个的索引）。

50. 题目：统计列表中偶数的个数

需求：统计列表[1, 2, 3, 4, 5, 6, 7, 8, 9]中偶数的数量。

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]
even_count = sum(1 for num in nums if num % 2 == 0)
print(even_count)  # 输出：4

解析：通过生成器表达式筛选偶数，并用sum()统计个数（1 for ...表示每个偶数贡献1）。

六、列表推导式（51-65）

51. 题目：用列表推导式创建1-10的列表

需求：生成包含1到10的整数列表[1, 2, ..., 10]。

numbers = [i for i in range(1, 11)]
print(numbers)  # 输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

解析：列表推导式[表达式 for 变量 in 可迭代对象]是创建列表的简洁方式，等价于循环+append()。

52. 题目：用列表推导式创建平方列表

需求：生成1-5的平方列表[1, 4, 9, 16, 25]。

squares = [i** 2 for i in range(1, 6)]
print(squares)  # 输出：[1, 4, 9, 16, 25]

解析：推导式中的表达式可以是任意运算，这里用i **2计算平方。

53. 题目：带条件的列表推导式（筛选偶数）

需求：从1-10中筛选出偶数，生成[2, 4, 6, 8, 10]。

evens = [i for i in range(1, 11) if i % 2 == 0]
print(evens)  # 输出：[2, 4, 6, 8, 10]

解析：[表达式 for 变量 in 可迭代对象 if 条件]可筛选满足条件的元素。

54. 题目：带条件的列表推导式（替换元素）

需求：将1-10中的偶数保留，奇数替换为0，生成[0, 2, 0, 4, ..., 10]。

result = [i if i % 2 == 0 else 0 for i in range(1, 11)]
print(result)  # 输出：[0, 2, 0, 4, 0, 6, 0, 8, 0, 10]

解析：表达式中可用三目运算符a if 条件 else b，根据条件生成不同元素。

55. 题目：嵌套循环的列表推导式

需求：生成[(x, y) for x in 1-2 for y in 3-4]的元组列表。

pairs = [(x, y) for x in range(1, 3) for y in range(3, 5)]
print(pairs)  # 输出：[(1, 3), (1, 4), (2, 3), (2, 4)]

解析：列表推导式支持多层循环，等价于嵌套for循环，外层循环变量在前，内层在后。

56. 题目：用列表推导式处理字符串列表

需求：将列表["hello", "world", "python"]中的每个字符串转为大写。

words = ["hello", "world", "python"]
upper_words = [word.upper() for word in words]
print(upper_words)  # 输出：['HELLO', 'WORLD', 'PYTHON']

解析：推导式中可调用元素的方法（如字符串的upper()），批量处理元素。

57. 题目：用列表推导式过滤空字符串

需求：从列表["a", "", "b", "", "c"]中过滤掉空字符串。

strings = ["a", "", "b", "", "c"]
non_empty = [s for s in strings if s]
print(non_empty)  # 输出：['a', 'b', 'c']

解析：if s判断字符串非空（空字符串""为False），等价于if len(s) > 0。

58. 题目：用列表推导式扁平化嵌套列表

需求：将嵌套列表[[1, 2], [3, 4], [5, 6]]扁平化为[1, 2, 3, 4, 5, 6]。

nested = [[1, 2], [3, 4], [5, 6]]
flattened = [num for sublist in nested for num in sublist]
print(flattened)  # 输出：[1, 2, 3, 4, 5, 6]

解析：通过两层循环，外层遍历子列表，内层遍历子列表中的元素，实现扁平化。

59. 题目：用列表推导式生成随机数列表

需求：生成包含5个1-100随机整数的列表。

import random
random_nums = [random.randint(1, 100) for _ in range(5)]
print(random_nums)  # 输出：如[42, 15, 89, 3, 76]（随机结果）

解析：结合random.randint()和列表推导式，可快速生成随机数列表。

60. 题目：用列表推导式计算矩阵的转置

需求：将2x3矩阵[[1, 2, 3], [4, 5, 6]]转置为3x2矩阵[[1, 4], [2, 5], [3, 6]]。

matrix = [[1, 2, 3], [4, 5, 6]]
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
print(transposed)  # 输出：[[1, 4], [2, 5], [3, 6]]

解析：外层推导式遍历列索引，内层推导式按列索引取每行元素，实现矩阵转置。

61. 题目：用列表推导式筛选出长度大于3的字符串

需求：从["apple", "cat", "banana", "dog"]中筛选出长度大于3的字符串。

words = ["apple", "cat", "banana", "dog"]
long_words = [word for word in words if len(word) > 3]
print(long_words)  # 输出：['apple', 'banana']

解析：通过len(word) > 3筛选出长度符合条件的字符串。

62. 题目：用列表推导式处理字典

需求：从字典{"a": 1, "b": 2, "c": 3}中提取值大于1的键，生成列表。

my_dict = {"a": 1, "b": 2, "c": 3}
filtered_keys = [key for key, value in my_dict.items() if value > 1]
print(filtered_keys)  # 输出：['b', 'c']

解析：推导式可遍历字典的items()，结合条件筛选键或值。

63. 题目：用列表推导式去重

需求：去除列表[1, 2, 2, 3, 3, 3]中的重复元素。

lst = [1, 2, 2, 3, 3, 3]
unique_lst = list({x: None for x in lst}.keys())  # 方法1：利用字典键唯一
# 或 unique_lst = list(set(lst))  # 方法2：利用集合去重（但会打乱顺序）
print(unique_lst)  # 输出：[1, 2, 3]（方法1保留顺序，方法2顺序可能不同）

解析：方法1用字典推导式保留元素首次出现的顺序，方法2用集合去重但顺序可能改变（Python 3.7+字典保留插入顺序）。

64. 题目：用列表推导式生成斐波那契数列

需求：生成前10个斐波那契数（1, 1, 2, 3, 5, …）。

# 斐波那契数列：前两项为1，每项等于前两项之和
fib = [1, 1]
[fib.append(fib[-1] + fib[-2]) for _ in range(8)]  # 再生成8项，共10项
print(fib)  # 输出：[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

解析：推导式也可用于执行操作（如append()），此处用推导式简化循环生成斐波那契数列。

65. 题目：嵌套列表推导式处理二维列表

需求：将二维列表[[1, 2], [3, 4], [5, 6]]中的每个元素乘以2。

matrix = [[1, 2], [3, 4], [5, 6]]
doubled = [[num * 2 for num in row] for row in matrix]
print(doubled)  # 输出：[[2, 4], [6, 8], [10, 12]]

解析：嵌套列表推导式，外层处理每行，内层处理每行中的元素。

七、嵌套列表（66-80）

66. 题目：创建二维列表

需求：创建一个3x3的二维列表[[1, 2, 3], [4, 5, 6], [7, 8, 9]]。

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print(matrix)  # 输出：[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

解析：二维列表是列表的列表，可用于表示矩阵、表格等结构化数据。

67. 题目：访问嵌套列表中的元素

需求：获取二维列表[[1, 2], [3, 4], [5, 6]]中第2行第1列的元素（值为4）。

matrix = [[1, 2], [3, 4], [5, 6]]
# 第2行（索引1）的第1列（索引1）
print(matrix[1][1])  # 输出：4

解析：matrix[i][j]表示访问第i行第j列的元素（行和列索引均从0开始）。

68. 题目：修改嵌套列表中的元素

需求：将二维列表[[1, 2], [3, 4]]中第0行第1列的元素改为9。

matrix = [[1, 2], [3, 4]]
matrix[0][1] = 9
print(matrix)  # 输出：[[1, 9], [3, 4]]

解析：通过matrix[i][j] = 新值可修改二维列表中的指定元素。

69. 题目：遍历二维列表

需求：打印二维列表[[1, 2], [3, 4], [5, 6]]中的所有元素。

matrix = [[1, 2], [3, 4], [5, 6]]
for row in matrix:
    for num in row:
        print(num, end=" ")
    print()  # 换行
# 输出：
# 1 2 
# 3 4 
# 5 6

解析：通过嵌套循环遍历二维列表，外层循环遍历行，内层循环遍历行中的元素。

70. 题目：计算二维列表所有元素的和

需求：计算[[1, 2], [3, 4], [5, 6]]中所有元素的总和。

matrix = [[1, 2], [3, 4], [5, 6]]
total = sum(sum(row) for row in matrix)
print(total)  # 输出：21

解析：sum(row) for row in matrix计算每行的和，再用sum()计算所有行和的总和。

71. 题目：获取二维列表中的最大值

需求：找出[[5, 2], [9, 1], [6, 8]]中的最大值。

matrix = [[5, 2], [9, 1], [6, 8]]
max_value = max(max(row) for row in matrix)
print(max_value)  # 输出：9

解析：max(row) for row in matrix获取每行的最大值，再用max()获取这些最大值中的最大值。

72. 题目：向二维列表添加一行

需求：向[[1, 2], [3, 4]]中添加一行[5, 6]。

matrix = [[1, 2], [3, 4]]
matrix.append([5, 6])
print(matrix)  # 输出：[[1, 2], [3, 4], [5, 6]]

解析：append()方法可向二维列表添加新行（子列表）。

73. 题目：向二维列表的指定行添加元素

需求：向[[1, 2], [3], [4, 5]]的第1行（索引1）添加元素4。

matrix = [[1, 2], [3], [4, 5]]
matrix[1].append(4)
print(matrix)  # 输出：[[1, 2], [3, 4], [4, 5]]

解析：先通过matrix[1]获取指定行，再用append()向该行添加元素。

74. 题目：删除二维列表中的一行

需求：删除[[1, 2], [3, 4], [5, 6]]中的第1行（索引1）。

matrix = [[1, 2], [3, 4], [5, 6]]
del matrix[1]
print(matrix)  # 输出：[[1, 2], [5, 6]]

解析：用del语句可删除二维列表中的指定行。

75. 题目：创建包含10个空列表的列表

需求：生成[[], [], ..., []]（共10个空列表）。

empty_lists = [[] for _ in range(10)]
print(empty_lists)  # 输出：[[], [], [], [], [], [], [], [], [], []]

解析：[[] for _ in range(10)]生成10个独立的空列表，区别于[[]] * 10（10个引用同一空列表）。

76. 题目：统计二维列表中的元素总数

需求：计算[[1, 2], [3], [4, 5, 6]]中元素的总个数。

matrix = [[1, 2], [3], [4, 5, 6]]
total_elements = sum(len(row) for row in matrix)
print(total_elements)  # 输出：6

解析：len(row) for row in matrix计算每行的元素个数，再求和得到总数。

77. 题目：将二维列表转换为一维列表

需求：将[[1, 2], [3, 4], [5, 6]]转换为[1, 2, 3, 4, 5, 6]。

matrix = [[1, 2], [3, 4], [5, 6]]
flattened = []
for row in matrix:
    flattened.extend(row)  # 用extend添加每行元素
print(flattened)  # 输出：[1, 2, 3, 4, 5, 6]

解析：通过循环遍历每行，用extend()将行元素添加到一维列表中，实现扁平化。

78. 题目：按列求和

需求：计算[[1, 2, 3], [4, 5, 6], [7, 8, 9]]每列的和（结果[12, 15, 18]）。

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 假设所有行长度相同，列数=第一行长度
column_sums = [sum(row[i] for row in matrix) for i in range(len(matrix[0]))]
print(column_sums)  # 输出：[12, 15, 18]

解析：遍历列索引，对每个索引计算所有行中该索引元素的和，得到列和列表。

79. 题目：查找二维列表中元素的位置

需求：在[[1, 2], [3, 4], [5, 6]]中查找元素4的位置（行索引和列索引）。

matrix = [[1, 2], [3, 4], [5, 6]]
target = 4
for i, row in enumerate(matrix):
    if target in row:
        j = row.index(target)
        print(f"位置：行{i}，列{j}")  # 输出：位置：行1，列1
        break
else:
    print(f"{target}不在列表中")

解析：用enumerate()获取行索引，检查元素是否在该行，若在则用index()获取列索引。

80. 题目：创建3x3的零矩阵

需求：生成[[0, 0, 0], [0, 0, 0], [0, 0, 0]]。

rows, cols = 3, 3
zero_matrix = [[0 for _ in range(cols)] for _ in range(rows)]
print(zero_matrix)  # 输出：[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

解析：嵌套列表推导式，外层生成rows行，内层每行生成cols个0。

八、列表与其他数据结构转换（81-90）

81. 题目：将元组转换为列表

需求：将元组(1, 2, 3, 4)转换为列表[1, 2, 3, 4]。

tpl = (1, 2, 3, 4)
lst = list(tpl)
print(lst)  # 输出：[1, 2, 3, 4]

解析：list()函数可将元组（或其他可迭代对象）转换为列表。

82. 题目：将列表转换为元组

需求：将列表[1, 2, 3, 4]转换为元组(1, 2, 3, 4)。

lst = [1, 2, 3, 4]
tpl = tuple(lst)
print(tpl)  # 输出：(1, 2, 3, 4)

解析：tuple()函数可将列表转换为元组（元组是不可变的，转换后不能修改元素）。

83. 题目：将字符串转换为列表

需求：将字符串"hello"转换为字符列表['h', 'e', 'l', 'l', 'o']。

s = "hello"
char_list = list(s)
print(char_list)  # 输出：['h', 'e', 'l', 'l', 'o']

解析：list()函数将字符串转换为包含每个字符的列表。

84. 题目：将列表转换为字符串

需求：将字符列表['h', 'e', 'l', 'l', 'o']转换为字符串"hello"。

chars = ['h', 'e', 'l', 'l', 'o']
s = ''.join(chars)  # 用空字符串连接列表元素
print(s)  # 输出：hello

解析：str.join(列表)用字符串str连接列表中的元素，此处用空字符串''连接字符列表。

85. 题目：将集合转换为列表

需求：将集合{1, 2, 3}转换为列表[1, 2, 3]（顺序可能不同）。

s = {1, 2, 3}
lst = list(s)
print(lst)  # 输出：[1, 2, 3]（集合无序，顺序可能不同）

解析：list()函数可将集合转换为列表，但集合无序，转换后列表元素顺序不确定。

86. 题目：将列表转换为集合（去重）

需求：将列表[1, 2, 2, 3, 3, 3]转换为集合{1, 2, 3}。

lst = [1, 2, 2, 3, 3, 3]
s = set(lst)
print(s)  # 输出：{1, 2, 3}

解析：集合元素唯一，将列表转换为集合可实现去重，但会丢失原顺序。

87. 题目：将字典的键转换为列表

需求：将字典{"a": 1, "b": 2, "c": 3}的键转换为列表['a', 'b', 'c']。

my_dict = {"a": 1, "b": 2, "c": 3}
keys = list(my_dict.keys())  # 获取键视图并转换为列表
print(keys)  # 输出：['a', 'b', 'c']（Python 3.7+保留插入顺序）

解析：dict.keys()返回字典的键视图，用list()可转换为包含键的列表。

88. 题目：将字典的值转换为列表

需求：将字典{"a": 1, "b": 2, "c": 3}的值转换为列表[1, 2, 3]。

my_dict = {"a": 1, "b": 2, "c": 3}
values = list(my_dict.values())  # 获取值视图并转换为列表
print(values)  # 输出：[1, 2, 3]

解析：dict.values()返回字典的值视图，转换为列表后包含所有值。

89. 题目：将字典的键值对转换为列表

需求：将字典{"a": 1, "b": 2}转换为包含元组的列表[('a', 1), ('b', 2)]。

my_dict = {"a": 1, "b": 2}
items = list(my_dict.items())  # 获取键值对视图并转换为列表
print(items)  # 输出：[('a', 1), ('b', 2)]

解析：dict.items()返回包含键值对元组的视图，转换为列表后便于遍历。

90. 题目：将列表转换为字典（以索引为键）

需求：将列表["a", "b", "c"]转换为{0: "a", 1: "b", 2: "c"}。

lst = ["a", "b", "c"]
# 用enumerate获取索引和值，再转换为字典
my_dict = {index: value for index, value in enumerate(lst)}
print(my_dict)  # 输出：{0: 'a', 1: 'b', 2: 'c'}

解析：enumerate(lst)返回(索引, 值)元组，通过字典推导式转换为字典。

九、列表综合应用（91-100）

91. 题目：筛选列表中的质数

需求：从1-20中筛选出所有质数，生成[2, 3, 5, 7, 11, 13, 17, 19]。

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 = [num for num in range(1, 21) if is_prime(num)]
print(primes)  # 输出：[2, 3, 5, 7, 11, 13, 17, 19]

解析：先定义判断质数的函数，再用列表推导式筛选1-20中的质数。

92. 题目：计算列表中元素的出现频率

需求：统计[1, 2, 2, 3, 3, 3]中每个元素出现的次数，生成字典{1:1, 2:2, 3:3}。

lst = [1, 2, 2, 3, 3, 3]
frequency = {}
for num in lst:
    frequency[num] = frequency.get(num, 0) + 1
print(frequency)  # 输出：{1: 1, 2: 2, 3: 3}

解析：通过字典记录每个元素的出现次数，get(num, 0)确保初始值为0，每次出现则+1。

93. 题目：合并两个列表并去重

需求：将[1, 2, 3]和[3, 4, 5]合并为[1, 2, 3, 4, 5]（去重）。

list1 = [1, 2, 3]
list2 = [3, 4, 5]
merged = list(set(list1 + list2))  # 合并后转集合去重，再转列表
# 如需保留顺序（Python 3.7+）：
# merged = list(dict.fromkeys(list1 + list2))
print(merged)  # 输出：[1, 2, 3, 4, 5]（顺序可能不同）

解析：方法1用集合去重（简单但可能打乱顺序），方法2用字典键唯一特性保留顺序。

94. 题目：找出两个列表的交集

需求：找出[1, 2, 3, 4]和[3, 4, 5, 6]的交集[3, 4]。

list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]
intersection = [x for x in list1 if x in list2]
# 或用集合：list(set(list1) & set(list2))
print(intersection)  # 输出：[3, 4]

解析：列表推导式筛选出同时存在于两个列表中的元素，或用集合的&运算符求交集。

95. 题目：找出两个列表的差集

需求：找出[1, 2, 3, 4]中有而[3, 4, 5, 6]中没有的元素[1, 2]。

list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]
difference = [x for x in list1 if x not in list2]
# 或用集合：list(set(list1) - set(list2))
print(difference)  # 输出：[1, 2]

解析：筛选出仅存在于第一个列表中的元素，或用集合的-运算符求差集。

96. 题目：移动列表中的零到末尾

需求：将[0, 1, 0, 3, 12]中的所有0移到末尾，保持非零元素顺序不变[1, 3, 12, 0, 0]。

nums = [0, 1, 0, 3, 12]
non_zero = [x for x in nums if x != 0]  # 筛选非零元素
zeros = [0] * (len(nums) - len(non_zero))  # 生成对应数量的0
result = non_zero + zeros
print(result)  # 输出：[1, 3, 12, 0, 0]

解析：先筛选非零元素，计算需要补充的0的数量，再拼接两个列表。

97. 题目：旋转列表

需求：将列表[1, 2, 3, 4, 5]向右旋转2位，得到[4, 5, 1, 2, 3]。

def rotate(nums, k):
    k = k % len(nums)  # 处理k大于列表长度的情况
    return nums[-k:] + nums[:-k]

lst = [1, 2, 3, 4, 5]
print(rotate(lst, 2))  # 输出：[4, 5, 1, 2, 3]

解析：向右旋转k位等价于取后k个元素+前len(nums)-k个元素，k % len(nums)避免索引越界。

98. 题目：移除列表中重复的元素（保留顺序）

需求：从[1, 2, 2, 3, 3, 3]中移除重复元素，保留首次出现的顺序[1, 2, 3]。

lst = [1, 2, 2, 3, 3, 3]
seen = set()
unique = []
for num in lst:
    if num not in seen:
        seen.add(num)
        unique.append(num)
print(unique)  # 输出：[1, 2, 3]

解析：用集合记录已出现的元素，遍历列表时只添加未出现过的元素，确保顺序不变。

99. 题目：找出列表中出现次数最多的元素

需求：在[1, 2, 2, 3, 3, 3]中找出出现次数最多的元素3。

lst = [1, 2, 2, 3, 3, 3]
frequency = {}
for num in lst:
    frequency[num] = frequency.get(num, 0) + 1
# 按值排序，取最后一个（最大值）的键
most_frequent = max(frequency, key=frequency.get)
print(most_frequent)  # 输出：3

解析：先统计频率，再用max()结合key=frequency.get找出频率最高的元素。

100. 题目：实现两数之和（返回索引）

需求：在列表[2, 7, 11, 15]中找出和为9的两个元素的索引[0, 1]。

def two_sum(nums, target):
    num_indices = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in num_indices:
            return [num_indices[complement], i]
        num_indices[num] = i
    return []  # 无结果时返回空列表

print(two_sum([2, 7, 11, 15], 9))  # 输出：[0, 1]