Python 数据结构详解：列表、元组、字典和集合

列表（List）

1. 列表的定义与创建

列表是Python中最常用的数据结构之一，它通过中括号[]来表示，内部元素使用逗号分隔。列表具有以下特点：

• 序列类型：列表中的元素有严格的顺序，可以通过索引访问。
• 包容性强：列表可以存储多种类型的元素，如字符串、数字、布尔值、字典、列表、元组等。
• 可变性：列表支持元素的增加、删除和修改。

创建列表的基本方式如下：

• 直接使用中括号和逗号分隔元素：my_list = [1, 'hello', True]
• 使用list()函数将其他可迭代对象（如字符串、元组、集合）转换为列表：my_list = list('人工智能是未来的趋势')

2. 列表的性质

• 长度：使用len()函数获取列表的长度。
• 索引：通过索引访问列表中的元素，索引从0开始，支持正向和反向索引。
• 切片：使用切片操作获取列表的子集，格式为my_list[start:end:step]。

3. 列表的操作

• 增加元素：

  • append()：在列表末尾添加一个元素。
  • insert()：在指定位置插入一个元素。
  • extend()：将另一个列表的所有元素添加到当前列表末尾。

• 删除元素：

  • pop()：删除指定位置的元素，默认删除最后一个元素。
  • remove()：根据元素值删除第一次出现的元素。
  • 使用del关键字删除指定位置的元素或整个列表。

• 查找元素：使用index()方法查找元素的位置。

• 修改元素：通过索引直接赋值修改元素。

• 复制列表：

  • 浅拷贝：new_list = my_list.copy() 或 new_list = my_list[:]
  • 深拷贝：适用于嵌套列表，将在后续章节介绍。

• 排序：

  • sort()：对列表进行永久排序。
  • sorted()：返回排序后的新列表，原列表不变。

• 翻转：

  • 使用切片[::-1]或reverse()方法。

• 遍历：使用for循环遍历列表中的元素。

元组（Tuple）

元组与列表类似，但它是不可变的，即一旦定义后无法修改、增加或删除元素。元组使用圆括号()表示。

1. 元组的定义与创建

• 直接使用圆括号和逗号分隔元素：my_tuple = (1, 'hello', True)
• 使用tuple()函数将其他可迭代对象转换为元组：my_tuple = tuple([1, 2, 3])

2. 元组的操作

元组的操作与列表基本相同，但不支持增加、删除和修改元素。元组常用于函数返回多个值的场景，支持打包和解包操作。

字典（Dictionary）

字典是Python中另一种重要的数据结构，它通过键值对存储数据，使用大括号{}表示。字典的特点如下：

• 键必须是不可变类型（如数字、字符串、元组），且不能重复。
• 值可以是任意类型，包括可变类型。

1. 字典的定义与创建

• 直接使用大括号和键值对：my_dict = {'name': 'Alice', 'age': 25}
• 使用dict()函数创建字典：my_dict = dict(name='Alice', age=25)

2. 字典的操作

• 增加键值对：my_dict['new_key'] = 'new_value'
• 删除键值对：
  • del my_dict['key']
  • pop()：删除指定键值对并返回其值。
  • popitem()：随机删除一个键值对。
• 查找键值对：使用get()方法，若键不存在则返回默认值。
• 修改键值对：通过键直接赋值修改值。
• 遍历字典：
  • 遍历键：for key in my_dict.keys()
  • 遍历值：for value in my_dict.values()
  • 遍历键值对：for key, value in my_dict.items()

集合（Set）

集合是无序且不重复的元素集合，使用大括号{}表示。集合的特点如下：

• 元素唯一，不允许重复。
• 元素无序，不能通过索引访问。

1. 集合的定义与创建

• 直接使用大括号和元素：my_set = {1, 2, 3}
• 使用set()函数创建集合：my_set = set([1, 2, 3])

2. 集合的操作

• 增加元素：add()方法。
• 删除元素：remove()方法。
• 集合运算：
  • 交集：intersection()
  • 并集：union()
  • 差集：difference()
  • 对称差集：symmetric_difference()

---

列表基础

1. 列表的定义和创建

   • 列表是通过什么符号进行存储的？

     中括号，答案：中括号

   • 列表中的元素用什么符号进行分隔？

     逗号，答案：逗号

   • 列表的特点有哪些？（多选）

     A. 序列的数据类型
     B. 元素有严格的位置关系
     C. 可以存储多种类型的元素
     D. 是不可变的
     E. 支持元素的增加、删除和修改
     答案：A, B, C, E

2. 列表的构造方式

   • 如何使用字符串构造列表？

     使用list()函数，例如list("人工智能是未来的趋势")，答案：使用list()函数

   • 如何使用元组构造列表？

     使用list()函数，例如list((1, 2, 3, 4))，答案：使用list()函数

   • 如何使用集合构造列表？

     使用list()函数，例如list({1, 2, 3, 4})，答案：使用list()函数

3. range函数

   • range(6)生成的列表是怎样的？

     [0, 1, 2, 3, 4, 5]，答案：[0, 1, 2, 3, 4, 5]

   • range(1, 11, 2)生成的列表是怎样的？

     [1, 3, 5, 7, 9]，答案：[1, 3, 5, 7, 9]

列表的性质

4. 列表的长度

   • 如何获取列表的长度？

     使用len()函数，例如len([1, 2, 3, 4])，答案：使用len()函数

5. 列表的索引

   • 正向索引和反向索引分别从哪里开始编号？

     正向索引从0开始，反向索引从-1开始，答案：正向索引从0开始，反向索引从-1开始

6. 列表的切片

   • my_list = [0, 1, 2, 3, 4, 5]，my_list[1:4]的结果是什么？

     [1, 2, 3]，答案：[1, 2, 3]

   • my_list = [0, 1, 2, 3, 4, 5]，my_list[::-1]的结果是什么？

     [5, 4, 3, 2, 1, 0]，答案：[5, 4, 3, 2, 1, 0]

列表的操作

7. 列表元素的增加

   • 如何在列表末尾增加一个元素？

     使用append()方法，例如my_list.append(6)，答案：使用append()方法

   • 如何在指定位置插入一个元素？

     使用insert()方法，例如my_list.insert(2, 'new')，答案：使用insert()方法

   • 如何将一个列表的所有元素添加到另一个列表的末尾？

     使用extend()方法，例如my_list.extend([7, 8, 9])，答案：使用extend()方法

8. 列表元素的删除

   • 如何删除指定位置的元素？

     使用pop()方法，例如my_list.pop(2)，答案：使用pop()方法

   • 如何删除指定内容的元素？

     使用remove()方法，例如my_list.remove('new')，答案：使用remove()方法

   • 如何删除所有指定内容的元素？

     使用while循环和remove()方法，例如while 'new' in my_list: my_list.remove('new')，答案：使用while循环和remove()方法

9. 列表元素的查找

   • 如何查找元素的位置？

     使用index()方法，例如my_list.index('new')，答案：使用index()方法

10. 列表元素的修改

    • 如何修改指定位置的元素？

      使用索引赋值，例如my_list[2] = 'modified'，答案：使用索引赋值

11. 列表的复制

    • 如何正确复制列表？

      使用copy()方法或切片，例如new_list = my_list.copy()或new_list = my_list[:]，答案：使用copy()方法或切片

列表的排序和翻转

12. 列表的排序

    • 如何对列表进行永久排序？

      使用sort()方法，例如my_list.sort()，答案：使用sort()方法

    • 如何对列表进行临时排序？

      使用sorted()函数，例如sorted(my_list)，答案：使用sorted()函数

    • 如何对列表进行降序排序？

      使用sort(reverse=True)方法或sorted(my_list, reverse=True)，答案：使用sort(reverse=True)方法或sorted(my_list, reverse=True)

13. 列表的翻转

    • 如何对列表进行翻转？

      使用切片[::-1]或reverse()方法，例如my_list.reverse()，答案：使用切片[::-1]或reverse()方法

元组基础

14. 元组的特点

    • 元组与列表的主要区别是什么？

      元组是不可变的，答案：元组是不可变的

    • 元组的定义符号是什么？

      圆括号，答案：圆括号

15. 元组的打包和解包

    • 如何打包多个返回值？

      使用逗号分隔，例如return x**2, x**3，答案：使用逗号分隔

    • 如何解包返回值？

      使用多个变量接收，例如a, b = f1(x)，答案：使用多个变量接收

字典基础

16. 字典的定义

    • 字典的定义符号是什么？

      花括号，答案：花括号

    • 字典中的元素由什么组成？

      键和值，答案：键和值

17. 字典的键

    • 字典的键有哪些要求？（多选）

      A. 不可重复
      B. 必须是不可变类型
      C. 可以是列表、字典或集合
      D. 可以是数字、字符串或元组
      答案：A, B, D

18. 字典的操作

    • 如何增加键值对？

      使用赋值，例如my_dict['key'] = 'value'，答案：使用赋值

    • 如何删除键值对？

      使用del或pop()方法，例如del my_dict['key']或my_dict.pop('key')，答案：使用del或pop()方法

    • 如何修改键值对的值？

      使用赋值，例如my_dict['key'] = 'new_value'，答案：使用赋值

    • 如何获取键值对的值？

      使用键访问，例如my_dict['key']，答案：使用键访问

19. 字典的遍历

    • 如何遍历字典的键？

      使用keys()方法，例如for key in my_dict.keys()，答案：使用keys()方法

    • 如何遍历字典的值？

      使用values()方法，例如for value in my_dict.values()，答案：使用values()方法

    • 如何遍历字典的键值对？

      使用items()方法，例如for key, value in my_dict.items()，答案：使用items()方法

集合基础

20. 集合的特点

    • 集合中的元素有何特点？

      元素互不相等，答案：元素互不相等

    • 集合的定义符号是什么？

      大括号，答案：大括号

21. 集合的操作

    • 如何增加元素？

      使用add()方法，例如my_set.add('element')，答案：使用add()方法

    • 如何删除元素？

      使用remove()方法，例如my_set.remove('element')，答案：使用remove()方法

    • 如何获取集合的长度？

      使用len()函数，例如len(my_set)，答案：使用len()函数

22. 集合的运算

    • 如何进行交集运算？

      使用&符号，例如set1 & set2，答案：使用&符号

    • 如何进行并集运算？

      使用|符号，例如set1 | set2，答案：使用|符号

    • 如何进行差集运算？

      使用-符号，例如set1 - set2，答案：使用-符号

    • 如何进行对称差集运算？

      使用^符号，例如set1 ^ set2，答案：使用^符号

---

列表操作练习

题目1：创建100以内偶数列表

题目描述：请编写代码，创建一个由100以内（不包括100）所有偶数构成的列表。
答案：定义一个空列表，然后使用for循环遍历0到99，将偶数加入到这个空列表中，最后得到答案。代码如下：
首先定义了一个空的列表，然后做一个100的循环，将偶数加入到这个空列表中，最后能得到我们的答案。

题目2：索引和切片

题目描述：给定列表 ['a', 'b', 'c', 'd', 'e']，完成以下任务：

1. 使用正向索引和反向索引分别获取元素’c’。
2. 使用切片获取元素’b’和’d’。
3. 使用反向切片获取原列表的反向列表。
   答案：
4. 正向索引为2，反向索引为-3。
5. 从b的位置开始，以2为步长的一个切片可以获取BD。
6. 使用反向的一个索引可以得到反向列表。

题目3：列表操作

题目描述：给定列表 ['b', 'y', 'd', 'char', 'BMW']，完成以下任务：

1. 在列表末尾增加一个元素’t’。
2. 在’by’和’d’之间插入一个元素’char’。
3. 在列表末尾增加一个新列表[1, 2, 3]中的所有元素。
4. 删除列表的最后一个元素和第四个元素。
5. 删除元素’char’。
6. 查找’BMW’在列表中的位置索引。
7. 将列表中的’char’改为’QQ’。
8. 使用两种方法对列表进行复制。
9. 对列表进行永久排序和临时排序。
10. 对列表进行翻转。
11. 遍历列表并按照指定格式输出每个元素。
    答案：
12. 使用append('t')函数。
13. 使用insert(1, 'char')函数。
14. 使用extend([1, 2, 3])函数。
15. 使用pop()删除最后一个元素，使用remove()删除第四个元素。
16. 使用remove('char')。
17. 使用index('BMW')。
18. 找到’char’的位置，将其替换为’QQ’。
19. 使用copy()和切片方法[:]。
20. 永久排序使用sort()，临时排序使用sorted()。
21. 使用reverse()进行翻转。
22. 使用for循环和format()函数输出。

元组和字典操作练习

题目4：元组特性

题目描述：解释为什么元组被称为不可变的列表？
答案：元组的操作几乎和列表一样，但元组一旦被确定下来就不能再改变，因此被称为不可变的列表。

题目5：字典定义合法性判断

题目描述：判断以下字典定义是否合法，如果不合法指出原因：

• a: (‘tuple’, ‘string’)
• b: ([1, 2], ‘string’)
• c: (1, ‘string’)
  答案：a合法，b不合法（因为list是可变类型），c合法。

题目6：字典操作

题目描述：给定字典{'Tom': 'apple', 'Bob': 'banana', 'Judy': 'orange'}，完成以下任务：

1. 获取字典中最喜爱水果的长度。
2. 获取字典中Tom最喜爱的水果。
3. 增加键值对{'Sarah': 'watermelon'}。
4. 删除Judy及其最喜爱的水果。
5. 随机删除一个键值对并捕获被删除的值。
6. 修改Sarah最喜爱的水果为’melon’。
7. 遍历字典并按照指定格式输出每个键值对。
   答案：
8. 使用len()函数。
9. 直接访问dict['Tom']。
10. 使用dict.update({'Sarah': 'watermelon'})。
11. 使用del dict['Judy']。
12. 使用popitem()。
13. 直接修改dict['Sarah'] = 'melon'。
14. 使用for key, value in dict.items(): print(f"{key} loves {value}")。

字符串和集合操作练习

题目7：字符频率统计

题目描述：编写代码统计字符串中每个字符出现的次数。
答案：使用字典和get()函数，遍历字符串并将每个字符的出现次数记录在字典中。代码如下：
定义一个空字典d，遍历字符串s，对于每个字符i，在d中取到这个i，让它等于get(i, 0) + 1。

题目8：集合操作

题目描述：给定两个集合vegetables = {'carrot', 'tomato', 'meat', 'potato'}和fruits = {'apple', 'banana', 'orange', 'tomato'}，完成以下任务：

1. 删除vegetables中的’meat’。
2. 向vegetables中添加’eggplant’。
3. 找出既是蔬菜又是水果的元素。
4. 找出所有蔬菜和水果。
5. 找出只属于蔬菜或只属于水果的元素。
6. 找出只属于蔬菜的元素。
   答案：
7. 使用remove('meat')。
8. 使用add('eggplant')。
9. 使用交集运算&。
10. 使用并集运算|。
11. 使用异或运算^。
12. 使用差集运算-。