6_Python的元组、字典和集合：创建和常见操作 - 文章频道 - 我的数字空间

Python中的元组、字典和集合是三种常用的数据类型，它们在编程中都有着广泛的应用。本文将对这三种数据类型进行详细介绍，并给出相应的代码示例。

一、元组

元组是一种不可变的序列类型，即一旦创建了元组，就无法修改其中的元素。元组的元素可以是任意类型，包括数字、字符串、列表等。元组的表示方法是使用圆括号将元素括起来，元素之间用逗号分隔。

元组的特点

不可变性：一旦创建了元组，就无法修改其中的元素。
有序性：元组中的元素按照插入顺序排列。
支持索引：可以使用索引访问元组中的元素。

元组在以下情况下非常有用：

保证数据的不可变性：当你有一些数据，在程序的运行过程中不需要修改时，可以使用元组来保存这些数据，确保其不被意外修改。
函数返回多个值：当一个函数需要返回多个值时，可以使用元组来将这些值打包返回。

（一）元组的创建

使用小括号 () 快捷创建元组：

1. 使用小括号 () 快捷创建元组

tup = (1, 2, 3, 4, 5)

2. 使用 tuple() 函数创建元组

tup = tuple([1, 2, 3, 4, 5])    # 使用列表创建元组
tup = tuple("abcde")             # 使用字符串创建元组

3. 定义只有一个数据的元组

需要注意的是，当元组中只有一个元素时，要在元素后面添加逗号，以区分元组和其他数据类型：

tup = (50,)    # 包含一个元素的元组

（二）元组的常见操作

元组是一种不可变的数据类型，因此不能像列表一样进行增删改操作。但是，元组可以进行以下操作：

1. 访问元素

元组中的元素是通过下标索引访问的，下标从0开始。例如：

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

2. 切片

元组可以使用切片操作获取一部分元素。切片操作返回一个新的元组，包含原元组中指定范围内的元素。例如：

tup = (1, 2, 3, 4, 5)
print(tup[:2])   # 输出：(1, 2)
# 获取前两个元素
print(tup[2:])   # 输出：(3, 4, 5)，获取从第三个元素到最后一个元素

3. 拼接

元组可以使用加号操作符拼接两个元组。例如：

tup1 = (1, 2, 3)
tup2 = (4, 5, 6)
result = tup1 + tup2
print(result)      # 输出：(1, 2, 3, 4, 5, 6)

4. 比较大小

元组可以使用比较运算符进行大小比较。例如：

tup1 = (1, 2, 3)
tup2 = (1, 2, 3)
print(tup1 > tup2)  # 输出：False

5. 迭代

元组可以使用 for 循环进行迭代。例如：

tup = (1, 2, 3, 4, 5)
for i in tup:
    print(i，end=' ')    # 输出：1 2 3 4 5

需要注意的是，虽然元组不能直接对元组进行增删改操作，但当元组中的元素是可变类型时（如列表），可以对可变类型的元素进行增删改操作。但这样的操作会改变元组中的可变元素，而不是元组本身。

二、字典

字典是Python中的一种可变键值对类型，即可以添加、删除和修改字典中的键值对。字典中的键必须是唯一的，而值可以是任意类型的对象。字典使用花括号 {} 表示，每个键值对之间使用冒号 : 分隔。

字典的特点：

可变性：可以添加、删除和修改字典中的键值对。
无序性：字典中的键值对没有固定的顺序。
支持索引：可以使用键来访问字典中的值。支持遍历：可以使用for循环遍历字典中的键值对。

字典在以下情况下非常有用：

存储和访问键值对：当你需要存储和访问具有关联性的数据时，字典非常有用。例如，你可以使用字典来存储学生的姓名、年龄和成绩。
快速查找和更新数据：由于字典使用键进行索引，因此可以快速查找和更新数据，而不需要遍历整个数据结构。

（一）字典创建

Python中创建字典的方法有很多种，以下是一些常见的方法：

1. 通过直接赋值方式创建：使用大括号{}或者dict()函数。

# 使用大括号{}创建空字典和指定内容的字典
empty_dict = {}
fruits = {'apple': 1, 'banana': 2, 'orange': 3}

# 使用dict()函数创建字典
fruits_dict = dict(apple=1, banana=2, orange=3)

2. 使用for循环遍历可迭代对象创建字典。

这种方法适用于需要根据已有的数据结构(如列表、元组等)来创建字典的情况。具体来说，我们可以使用zip()函数将两个可迭代对象打包成一个元组序列，然后使用dict()函数将这个元组序列转换为字典。

# 使用for循环遍历字符串列表创建字典
fruit_list = ['apple', 'banana', 'orange']
fruit_dict = dict(zip(fruit_list, range(1, len(fruit_list) + 1)))
print(fruit_dict)  # 输出：{'apple': 1, 'banana': 2, 'orange': 3}

（二）字典添加

1. 使用dict[key] = value的方式添加元素。如果键已经存在，则会更新对应的值。

fruits = {'apple': 1, 'banana': 2}
fruits['orange'] = 3
print(fruits)  # 输出：{'apple': 1, 'banana': 2, 'orange': 3}

2. 使用update()方法，可以一次性添加多个键值对。

book_dict = {'owner': 'Tom', 'price': 500}
book_dict.update({'owner': 'Jerry', 'weight': 250})
print(book_dict)  # 输出：{'owner': 'Jerry', 'price': 500, 'weight': 250}

（三）字典删除

在Python中，可以使用以下方法从字典中删除一个或多个键值对：

1. 使用del关键字，通过指定要删除的键来删除键值对。

book_dict = {'owner': 'Tom', 'price': 500}
del book_dict['owner']
print(book_dict)  # 输出：{'price': 500}

2. 使用pop()方法，通过指定要删除的键来删除键值对，并返回被删除的值。如果不指定键，则默认删除最后一个键值对。

book_dict = {'owner': 'Tom', 'price': 500}
book_dict.pop('owner')
print(book_dict)  # 输出：{'price': 500}

3. 使用clear()方法，可以清空整个字典。

book_dict = {'owner': 'Tom', 'price': 500}
book_dict.clear()
print(book_dict)  # 输出：{}

（四）字典修改

在Python中，字典是一种可变的数据结构，可以通过修改键对应的值来更新字典。字典的键是唯一的，因此无法直接修改键本身，但可以修改键对应的值。下面介绍几种常见的字典修改方法。

1. 直接通过键来修改值

book_dict = {'owner': 'Tom', 'price': 500}
book_dict['owner'] = 'Jerry'
print(book_dict)  # 输出：{'owner': 'Jerry', 'price': 500}

2. 使用update()方法，可以一次性修改多个键值对。

book_dict = {'owner': 'Tom', 'price': 500}
book_dict.update({'owner': 'Jerry', 'weight': 250})
print(book_dict)  # 输出：{'owner': 'Jerry', 'price': 500, 'weight': 250}

3. 使用setdefault()方法修改键值对

setdefault() 是Python中字典(Dictionary)的一个内置方法。setdefault()方法会返回指定键的值，如果该键不存在，则会添加一个新的键值对并返回默认值。

book_dict = {'owner': 'Tom', 'price': 500}

# 获取'owner'键对应的值，如果不存在则添加新的键值对
owner = book_dict.setdefault('owner', 'Jerry')
print(owner)  # 输出：Tom

# 修改'owner'键对应的值
book_dict['owner'] = 'Jerry'
print(book_dict)  # 输出：{'owner': 'Jerry', 'price': 500}

在上面的代码中，首先使用setdefault()方法获取了’owner’键对应的值，如果该键不存在，则会添加一个新的键值对并返回默认值’Jerry’。然后将’owner’键对应的值修改为’Jerry’。

（五）字典访问

在Python中，可以使用键来访问字典中的值。字典是一种无序的键值对集合，每个键都唯一，通过键可以快速查找对应的值。下面介绍几种常见的字典访问方法。

1. 使用键名直接访问，如果该键不存在则会抛出KeyError异常。

book_dict = {'owner': 'Tom', 'price': 500}
print(book_dict['owner'])  # 输出：Tom

2. 使用get()方法访问，如果该键不存在则返回默认值。

book_dict = {'owner': 'Tom', 'price': 500}
print(book_dict.get('owner'))  # 输出：Tom
print(book_dict.get('weight'))  # 输出：None

3. 使用in关键字判断是否存在指定的键。

book_dict = {'owner': 'Tom', 'price': 500}
if 'owner' in book_dict:
    print("The key 'owner' exists in the dictionary.")
else:
    print("The key 'owner' does not exist in the dictionary.")

4. 使用items()方法遍历字典中的键值对

items()方法返回一个包含所有键值对的列表，每个元素都是一个元组，其中第一个元素是键，第二个元素是对应的值。

book_dict = {'owner': 'Tom', 'price': 500, 'weight': 250}

# 使用items()方法遍历字典中的键值对
for key, value in book_dict.items():
    print(key, value)

在上面的代码中，首先定义了一个包含三个键值对的字典book_dict。然后使用for循环和items()方法遍历字典中的键值对，并将每个键值对打印出来。输出结果如下：

owner Tom
price 500
weight 250

5. 使用keys()方法遍历字典中的键

keys()方法返回一个包含所有键的视图对象，可以用于for循环中遍历所有的键。

book_dict = {'owner': 'Tom', 'price': 500, 'weight': 250}

# 使用keys()方法遍历字典中的键
for key in book_dict.keys():
    print(key)

在上面的代码中，首先定义了一个包含三个键值对的字典book_dict。然后使用for循环和keys()方法遍历字典中的所有键，并将每个键打印出来。输出结果如下：

owner
price
weight

6. 使用values()方法遍历字典中的值

values()方法返回一个包含所有值的视图对象，可以用于for循环中遍历所有的值。

book_dict = {'owner': 'Tom', 'price': 500, 'weight': 250}

# 使用values()方法遍历字典中的值
for value in book_dict.values():
    print(value)

在上面的代码中，首先定义了一个包含三个键值对的字典book_dict。然后使用for循环和values()方法遍历字典中的所有值，并将每个值打印出来。输出结果如下：

Tom
500
250

三、集合

集合是一种无序且不重复的数据结构，用于存储多个不同的元素。集合使用大括号 {} 表示，每个元素之间使用逗号分隔。

集合的特点：

无序性：集合中的元素没有固定的顺序。
不重复性：集合中的元素都是唯一的。
支持交集、并集等操作。
支持判断元素是否存在于集合中。

集合在以下情况下非常有用：

去重：由于集合不允许重复的元素，因此可以使用集合来去重。
判断元素是否存在：由于集合不允许重复的元素，因此可以使用集合来判断一个元素是否存在。

（一）集合创建

在Python中，集合（Set）是一种无序且不重复的元素集合，可以使用花括号{}或者set()函数来创建集合。下面介绍几种常见的集合创建方法。

1. 使用花括号{}创建集合

# 创建一个集合
my_set = {1, 2, 3, 4}
print(my_set)  # 输出 {1, 2, 3, 4}

2. 使用set()函数创建集合

set()方法可以接受一个可迭代的对象作为参数，并返回一个新的集合。

# 创建一个空集合
my_set = set([1, 2, 3, 4])
print(my_set)  # 输出 {1, 2, 3, 4}

（二）集合元素添加

1. 使用add()方法向集合中添加新的元素。

# 创建一个空集合
my_set = set()

# 向集合中添加元素
my_set.add(1)
my_set.add(2)
my_set.add(3)

# 输出集合中的元素
print(my_set)  # 输出：{1, 2, 3}

需要注意的是，集合中的元素是无序且不重复的，即相同的元素只会在集合中出现一次。如果尝试向集合中添加已经存在的元素，那么该操作会被忽略。

# 创建一个空集合
my_set = set()

# 向集合中添加元素
my_set.add(1)
my_set.add(2)
my_set.add(3)

# 尝试向集合中添加已经存在的元素
my_set.add(2)

# 输出集合中的元素
print(my_set)  # 输出：{1, 2, 3}

在上面的示例中，添加元素2时，由于集合中已经存在该元素，所以该操作被忽略，集合中的元素仍然是1、2和3。

2. 使用update()方法向集合中添加多个元素

使用update()方法向集合中添加多个元素，可以传入一个可迭代的对象作为参数，如列表、元组等。

# 创建一个空集合
my_set = set()

# 向集合中添加多个元素
my_set.update([1, 2, 3])

# 输出集合中的元素
print(my_set)  # 输出：{1, 2, 3}

在上面的示例中，使用update()方法向集合中添加了元素1、2和3。需要注意的是，update()方法会修改原始集合，而不是返回一个新的集合。

（三）集合元素删除

1. 使用remove()方法删除集合中的元素

# 创建一个集合
my_set = {1, 2, 3}

# 删除集合中的元素
my_set.remove(2)

# 输出集合中的元素
print(my_set)  # 输出：{1, 3}

在上面的示例中，使用remove()方法删除了集合中的元素2。如果要删除的元素不存在于集合中，remove()方法会抛出KeyError异常。

2. 使用pop()方法删除集合中的元素

# 创建一个集合
my_set = {1, 2, 3}

# 删除集合中的一个随机元素
my_set.pop()

# 输出集合中的元素
print(my_set)  # 输出：{2, 3}

在上面的示例中，使用pop()方法删除了集合中的一个随机元素。需要注意的是，由于集合是无序的，所以pop()方法删除的元素是随机选择的。

3. 使用discard()方法删除集合中的元素

# 创建一个集合
my_set = {1, 2, 3}

# 删除集合中的元素
my_set.discard(2)

# 输出集合中的元素
print(my_set)  # 输出：{1, 3}

在上面的示例中，使用discard()方法删除了集合中的元素2。与remove()方法不同的是，如果要删除的元素不存在于集合中，discard()方法不会抛出异常，而是什么也不做。

（四）判断集合中是否包含某个值

1. 使用in关键字判断集合中是否包含某个值

# 创建一个集合
my_set = {1, 2, 3}

# 判断集合中是否包含某个值
if 2 in my_set:
    print("集合中包含值2")
else:
    print("集合中不包含值2")

2. 使用issubset()方法判断

使用issubset()方法判断一个集合是否是另一个集合的子集，可以间接实现判断集合中是否包含某个值的功能。

# 创建一个集合
my_set = {1, 2, 3}

# 判断集合中是否包含某个值
if {2}.issubset(my_set):
    print("集合中包含值2")
else:
    print("集合中不包含值2")

（五）集合常见逻辑运算

在Python中，集合支持常用的逻辑运算，包括交集、并集、差集和对称差集四种操作。

1. 交集

交集操作可以获取两个集合中共同存在的元素，可以使用intersection()方法或者&运算符来进行操作。

# 创建两个集合
set1 = {1, 2, 3}
set2 = {2, 3, 4}

# 计算交集
intersection_set = set1.intersection(set2)
# 或者使用运算符：intersection_set = set1 & set2

# 输出交集结果
print(intersection_set)  # 输出：{2, 3}

2. 并集

并集操作可以获取两个集合中所有的元素，去除重复项，可以使用union()方法或者|运算符来进行操作。

# 创建两个集合
set1 = {1, 2, 3}
set2 = {2, 3, 4}

# 计算并集
union_set = set1.union(set2)
# 或者使用运算符：union_set = set1 | set2

# 输出并集结果
print(union_set)  # 输出：{1, 2, 3, 4}

3. 差集

差集操作可以获取第一个集合中存在，而第二个集合中不存在的元素，可以使用difference()方法或者-运算符来进行操作。

# 创建两个集合
set1 = {1, 2, 3}
set2 = {2, 3, 4}

# 计算差集
difference_set = set1.difference(set2)
# 或者使用运算符：difference_set = set1 - set2

# 输出差集结果
print(difference_set)  # 输出：{1}

4. 对称差集

对称差集操作可以获取第一个集合中存在，而第二个集合中不存在的元素，可以使用symmetric_difference()方法或者^运算符来进行操作。

# 创建两个集合
set1 = {1, 2, 3}
set2 = {2, 3, 4}

# 计算对称差集
symmetric_difference_set = set1.symmetric_difference(set2)
# 或者使用运算符：symmetric_difference_set = set1 ^ set2

# 输出对称差集结果
print(symmetric_difference_set)  # 输出：{4}

注意：集合的交集、并集、差集和对称差集操作都是基于集合元素的，而不是集合本身。如果需要对集合进行比较操作，可以使用集合对象的内置方法，如issubset()、issuperset()、==等。