目录
频道首页
6_Python的元组、字典和集合:创建和常见操作
收藏
0
ProgramLight 最近修改于 2024-04-15 11:34:23

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()、==等。

内容大纲
批注笔记
6_Python的元组、字典和集合:创建和常见操作
ArticleBot
z
z
z
z
主页
会议室
Git管理
文章
云文档
看板