2：数据结构：列表与元组

目录

[2.1 列表的创建与操作](#2.1 列表的创建与操作)

[2.1.1 列表的创建](#2.1.1 列表的创建)

[2.1.2 列表的常用操作](#2.1.2 列表的常用操作)

[2.1.3 列表切片操作](#2.1.3 列表切片操作)

[2.2 元组的特点与用法](#2.2 元组的特点与用法)

[2.2.1 元组的创建](#2.2.1 元组的创建)

[2.2.2 元组与列表的区别](#2.2.2 元组与列表的区别)

[2.2.3 元组的常用操作](#2.2.3 元组的常用操作)

[2.3 示例代码与练习](#2.3 示例代码与练习)

[2.3.1 示例代码：列表与元组的基本操作](#2.3.1 示例代码：列表与元组的基本操作)

[2.3.2 练习题](#2.3.2 练习题)

[文章 3：数据结构：字典与集合](#文章 3：数据结构：字典与集合)

[3.1 字典的创建与常用操作](#3.1 字典的创建与常用操作)

[3.1.1 字典的创建](#3.1.1 字典的创建)

[3.1.2 字典的常用操作](#3.1.2 字典的常用操作)

[3.1.3 字典的应用场景](#3.1.3 字典的应用场景)

[3.2 集合的基本操作](#3.2 集合的基本操作)

[3.2.1 集合的创建](#3.2.1 集合的创建)

[3.2.2 集合的常用操作](#3.2.2 集合的常用操作)

[3.2.3 集合的应用场景](#3.2.3 集合的应用场景)

[3.3 示例代码与应用场景](#3.3 示例代码与应用场景)

[3.3.1 示例代码：字典与集合的操作](#3.3.1 示例代码：字典与集合的操作)

[3.3.2 练习题](#3.3.2 练习题)

---

2.1 列表的创建与操作

列表（List） 是 Python 中最常用的数据结构之一。它是一个可变的序列，支持任意类型的数据元素，可以动态调整长度。这使得列表非常适合用来存储和操作一组有序数据。

2.1.1 列表的创建

你可以通过以下几种方式创建列表：

1. 直接创建空列表：

   my_list = []

2. 创建包含元素的列表：

   my_list = [1, 2, 3, 4, 5]

3. 通过 list() 函数将其他数据结构转换为列表：

   my_list = list("hello")
   # 结果：['h', 'e', 'l', 'l', 'o']

2.1.2 列表的常用操作

操作类型	操作方法	示例
访问元素	my_list[index]	my_list[0] 返回列表第一个元素
添加元素	my_list.append(element)	my_list.append(6) 将 6 添加到列表末尾
插入元素	my_list.insert(index, element)	my_list.insert(1, 'Python') 在索引1插入
删除元素	my_list.remove(element)	my_list.remove(3) 删除元素3
列表长度	len(my_list)	len(my_list) 返回列表长度
列表排序	my_list.sort()	my_list.sort() 对列表进行升序排序

2.1.3 列表切片操作

列表支持切片操作，可以通过指定起始和结束索引来访问部分元素：

my_list = [10, 20, 30, 40, 50]
sub_list = my_list[1:4]  # 结果：[20, 30, 40]

你还可以通过步长指定跳跃性访问：

my_list = [10, 20, 30, 40, 50, 60]
sub_list = my_list[::2]  # 结果：[10, 30, 50]

2.2 元组的特点与用法

元组（Tuple） 与列表类似，但它是不可变的，这意味着元组一旦创建，不能修改其内容。这种不可变性使得元组在需要确保数据安全或不可变的场景中非常有用。

2.2.1 元组的创建

你可以通过以下几种方式创建元组：

1. 直接创建空元组：

   my_tuple = ()

2. 创建包含元素的元组：

   my_tuple = (1, 2, 3)

3. 通过 tuple() 函数将其他数据结构转换为元组：

   my_tuple = tuple([1, 2, 3])

2.2.2 元组与列表的区别

特性	列表（List）	元组（Tuple）
可变性	可变（可以修改、添加、删除）	不可变（创建后不能修改内容）
创建方式	[] 或 list()	() 或 tuple()
适用场景	需要频繁修改数据的场景	需要保持数据安全不可变的场景

2.2.3 元组的常用操作

尽管元组是不可变的，但仍然支持一些基本操作：

操作类型	操作方法	示例
访问元素	my_tuple[index]	my_tuple[0] 返回元组第一个元素
切片操作	my_tuple[start:end]	my_tuple[1:3] 返回元组部分切片
拼接元组	my_tuple1 + my_tuple2	将两个元组合并为一个新元组
查询元素	element in my_tuple	3 in my_tuple 返回是否存在

2.3 示例代码与练习

2.3.1 示例代码：列表与元组的基本操作

# 列表操作示例
my_list = [1, 2, 3, 4]
my_list.append(5)
print("列表内容：", my_list)

# 元组操作示例
my_tuple = (10, 20, 30)
print("元组内容：", my_tuple)

2.3.2 练习题

1. 创建一个包含 5 个数字的列表，尝试使用 append()、insert() 和 remove() 方法对其进行修改，并打印结果。
2. 创建一个包含 3 个元素的元组，尝试使用切片操作获取其中部分元素，并拼接另一个元组。

---

文章 3：数据结构：字典与集合

3.1 字典的创建与常用操作

字典（Dictionary） 是一种键值对（key-value pair）的数据结构。每个键都是唯一的，可以通过键快速访问对应的值。字典非常适合存储无序的关联数据。

3.1.1 字典的创建

1. 直接创建空字典：

   my_dict = {}

2. 创建带有键值对的字典：

   my_dict = {'name': 'Alice', 'age': 25}

3. 通过 dict() 函数创建字典：

   my_dict = dict([('name', 'Alice'), ('age', 25)])

3.1.2 字典的常用操作

操作类型	操作方法	示例
访问值	my_dict[key]	my_dict['name'] 返回对应的值
添加或更新键值对	my_dict[key] = value	my_dict['age'] = 30 更新键为 'age' 的值
删除键值对	my_dict.pop(key)	my_dict.pop('name') 删除键 'name'
遍历字典	for key, value in my_dict.items()	遍历所有键值对

3.1.3 字典的应用场景

字典非常适合存储无序的关联数据，例如学生成绩、商品价格等。以下是一个简单的字典应用示例：

student_grades = {'Alice': 85, 'Bob': 92, 'Charlie': 78}
for student, grade in student_grades.items():
    print(f"{student} 的成绩是 {grade}")

3.2 集合的基本操作

集合（Set） 是一种无序、不重复的元素集合。它适合用于去重和集合运算，如交集、并集等。

3.2.1 集合的创建

1. 直接创建空集合：

   my_set = set()

2. 创建带有元素的集合：

   my_set = {1, 2, 3, 4}

3.2.2 集合的常用操作

操作类型	操作方法	示例
添加元素	my_set.add(element)	my_set.add(5) 将 5 添加到集合
删除元素	my_set.remove(element)	my_set.remove(3) 删除元素 3
并集操作	my_set1.union(my_set2)	返回两个集合的并集
交集操作	my_set1.intersection(my_set2)	返回两个集合的交集

3.2.3 集合的应用场景

集合可以用来快速去重，或进行集合运算。以下是一个使用集合进行去重的例子：

numbers = [1, 2, 3, 3, 4, 4, 5]
unique_numbers = set(numbers)
print("去重后的结果：", unique_numbers)

3.3 示例代码与应用场景

3.3.1 示例代码：字典与集合的操作

# 字典操作示例
my_dict = {'name': 'Alice', 'age': 25}
my_dict['age'] = 30
print("字典内容：", my_dict)

# 集合操作示例
my_set = {1, 2, 3, 4}
my_set.add(5)
print("集合内容：", my_set)

3.3.2 练习题

1. 创建一个字典，存储 3 个学生的姓名和成绩，尝试使用 items() 方法遍历字典并打印每个学生的成绩。
2. 创建两个集合，分别包含 5 个数字，尝试进行并集和交集操作，并打印结果。