五、 组合数据类型

1. 组合数据类型的基本概念。

        谈到Python的组合数据类型时，通常指的是列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set）这四种类型。

• 列表（List）是Python中最常用的组合数据类型之一。它是一个有序的数据序列，可以包含任意多个元素，每个元素可以是不同的数据类型。列表用方括号 [] 表示，元素之间用逗号分隔。例如：

my_list = [1, 2, 'hello', True]

        列表是可变（Mutable）的，即可以通过索引修改和删除其中的元素。可以使用索引和切片操作来访问列表中的元素。

• 元组（Tuple）也是一个有序的数据序列，与列表类似。但是，元组是不可变（Immutable）的，即创建后不能修改。元组用圆括号 () 表示，元素之间用逗号分隔。例如：

my_tuple = (1, 2, 'hello', True)

        元组一旦创建，其中的元素不能被修改、添加或删除。可以使用索引和切片操作来访问元组中的元素。

• 字典（Dictionary）是一种无序的键值对（Key-Value）集合。它通过键来索引值，而不是通过索引位置。字典用花括号 {} 表示，键值对之间用冒号 : 分隔，键值对之间用逗号分隔。例如：

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

        字典中的键必须是唯一的且不可变的（通常为字符串），而值可以是任意数据类型。可以使用键来访问字典中的值，也可以通过键来修改、添加或删除对应的值。

• 集合（Set）是一种无序的、不重复的数据集合。它是通过哈希表实现的，因此访问和操作的速度非常快。集合用花括号 {} 表示，元素之间用逗号分隔。例如：

my_set = {1, 2, 3, 4, 5}

        集合中的元素不能重复，如果重复添加相同的元素，只会保留一个。可以使用集合来进行集合运算，如并集、交集、差集等。

---

2. 列表类型:定义、索引、切片。

        Python中的列表（List）是一种有序的、可变的数据类型，用于存储多个元素。以下是关于列表的定义、索引和切片的详细说明：

• 定义列表： 列表可以使用方括号 [] 来定义，元素之间用逗号分隔。例如：

my_list = [1, 2, 'hello', True]

• 索引列表： 列表中的元素可以通过索引来访问，索引从0开始。例如，要访问列表中的第一个元素，可以使用索引0：

print(my_list[0])  # 输出：1

        可以使用负数索引来从列表末尾开始访问元素。例如，要访问列表中的最后一个元素，可以使用索引-1：

print(my_list[-1])  # 输出：True

• 切片列表： 切片（Slice）可以用来访问列表中的一部分元素。使用切片时，可以指定起始索引和结束索引（不包括结束索引的元素）。例如，要访问列表中的前三个元素，可以使用切片 [:3]：

print(my_list[:3])  # 输出：[1, 2, 'hello']

        切片还可以指定步长（默认为1）。例如，要访问列表中的所有偶数索引位置的元素，可以使用切片 [::2]：

print(my_list[::2])  # 输出：[1, 'hello']

        切片还可以用于复制整个列表。例如，可以使用切片 [:] 来复制列表：

new_list = my_list[:]

• 列表是有序的、可变的数据类型。
• 列表使用方括号 [] 定义，元素之间用逗号分隔。
• 列表的元素可以通过索引访问，索引从0开始，可以使用负数索引从末尾开始访问。
• 列表可以使用切片访问其中的一部分元素，可以指定起始索引、结束索引和步长。
• 切片还可用于复制整个列表。

---

3. 列表类型的操作:列表的操作函数、列表的操作方法。

        1. 列表的操作函数：

• len(list): 返回列表中元素的个数。
• max(list): 返回列表中的最大值（如果列表包含不可比较的元素类型，会引发TypeError）。
• min(list): 返回列表中的最小值（如果列表包含不可比较的元素类型，会引发TypeError）。
• sum(list): 返回列表中所有元素的和（如果列表包含不可加的元素类型，会引发TypeError）。
• sorted(list): 返回一个新的已排序的列表，不会修改原列表。
• reversed(list): 返回一个反转顺序的迭代器，可以使用list()函数将其转换为列表。

my_list = [3, 1, 4, 2, 5]
print(len(my_list))  # 输出：5
print(max(my_list))  # 输出：5
print(min(my_list))  # 输出：1
print(sum(my_list))  # 输出：15
sorted_list = sorted(my_list)
print(sorted_list)  # 输出：[1, 2, 3, 4, 5]
print(my_list)  # 输出：[3, 1, 4, 2, 5]，原列表不变
reversed_list = list(reversed(my_list))
print(reversed_list)  # 输出：[5, 2, 4, 1, 3]

        2. 列表的操作方法： 

• list.append(item): 在列表末尾添加一个元素。
• list.insert(index, item): 在指定的索引位置插入一个元素。
• list.extend(iterable): 将可迭代对象的元素添加到列表末尾。
• list.remove(item): 删除列表中第一个与指定元素相等的元素。
• list.pop([index]): 删除并返回指定索引位置的元素，默认为最后一个元素。
• list.index(item): 返回列表中第一个与指定元素相等的元素的索引。
• list.count(item): 返回指定元素在列表中出现的次数。
• list.sort(): 对列表进行排序（会修改原列表）。
• list.reverse(): 反转列表中的元素顺序（会修改原列表）。
• list.copy(): 返回列表的浅拷贝副本。 需要注意的是，除非特别说明，列表的操作方法通常会修改原列表，而不会返回一个新的列表。 这些操作函数和方法可以根据需要来对列表进行增删改查等操作，提供了丰富的功能来处理和处理列表数据。

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出：[1, 2, 3, 4]
my_list.insert(0, 0)
print(my_list)  # 输出：[0, 1, 2, 3, 4]
my_list.extend([5, 6])
print(my_list)  # 输出：[0, 1, 2, 3, 4, 5, 6]
my_list.remove(3)
print(my_list)  # 输出：[0, 1, 2, 4, 5, 6]
item = my_list.pop(2)
print(item)  # 输出：2
print(my_list)  # 输出：[0, 1, 4, 5, 6]
index = my_list.index(5)
print(index)  # 输出：3
count = my_list.count(1)
print(count)  # 输出：1
my_list.sort()
print(my_list)  # 输出：[0, 1, 4, 5, 6]
my_list.reverse()
print(my_list)  # 输出：[6, 5, 4, 1, 0]
new_list = my_list.copy()
print(new_list)  # 输出：[6, 5, 4, 1, 0]

---

 4. 字典类型:定义、索引。

        Python中的字典（Dictionary）是一种可变的、无序的键值对集合。字典中的每个元素由一个键（key）和一个值（value）组成，键和值之间用冒号（:）分隔，每对键值对之间用逗号（,）分隔，整个字典用花括号（{}）括起来。字典中的键必须是唯一的，但值可以重复。

         下面是一个字典的定义示例：

my_dict = {"name": "Alice", "age": 25, "city": "New York"}

        可以通过索引来访问字典中的值，使用方括号（[]）来指定键。

        例如：

name = my_dict["name"]
print(name)  # 输出：Alice
age = my_dict["age"]
print(age)  # 输出：25

        需要注意的是，如果使用不存在的键来索引字典，会引发KeyError异常。为了避免这种情况，可以使用get()方法来获取值，如果键不存在，可以指定一个默认值作为返回值。

        例如：

name = my_dict.get("name", "Unknown")
print(name)  # 输出：Alice
gender = my_dict.get("gender", "Unknown")
print(gender)  # 输出：Unknown

        字典的键可以是不可变的类型（如字符串、数字、元组等），但不能是可变的类型（如列表、字典等），因为字典的键需要是可哈希的。字典的值可以是任意类型的对象。

        通过keys()方法获取字典中所有的键，通过values()方法获取字典中所有的值，通过items()方法获取字典中所有的键值对。这些方法返回的结果是可迭代的对象，可以使用list()函数将其转换为列表。

5. 字典类型的操作:字典的操作函数、字典的操作方法。

         Python中字典（Dictionary）提供了一些操作函数和方法，用于对字典进行增删改查等操作。下面是一些常用的字典操作函数和方法的示例：

        字典的操作函数：

• len(dict): 返回字典中键值对的数量。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
print(len(my_dict))  # 输出：3

• sorted(dict): 返回一个按键排序的新列表。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
sorted_keys = sorted(my_dict)
print(sorted_keys)  # 输出：['age', 'city', 'name']

• str(dict): 将字典转换为可打印的字符串格式。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
dict_str = str(my_dict)
print(dict_str)  # 输出：{'name': 'Alice', 'age': 25, 'city': 'New York'}

        字典的操作方法：

• dict[key] = value: 向字典中添加或修改键值对。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
my_dict["name"] = "Bob"  # 修改键"name"的值
my_dict["gender"] = "Male"  # 添加新的键值对
print(my_dict)  # 输出：{'name': 'Bob', 'age': 25, 'city': 'New York', 'gender': 'Male'}

• dict.pop(key): 删除指定键的键值对，并返回对应的值。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
age = my_dict.pop("age")
print(age)  # 输出：25
print(my_dict)  # 输出：{'name': 'Alice', 'city': 'New York'}

• dict.keys(): 返回一个包含字典所有键的可迭代对象。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
keys = my_dict.keys()
print(keys)  # 输出：dict_keys(['name', 'age', 'city'])

• dict.values(): 返回一个包含字典所有值的可迭代对象。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
values = my_dict.values()
print(values)  # 输出：dict_values(['Alice', 25, 'New York'])

• dict.items(): 返回一个包含字典所有键值对的可迭代对象。

my_dict = {"name": "Alice", "age": 25, "city": "New York"}
items = my_dict.items()
print(items)  # 输出：dict_items([('name', 'Alice'), ('age', 25), ('city', 'New York')])