Python学习 -元组和集合

本文详细介绍了Python中的元组和集合。元组是不可变序列,适用于数据不需变动的情况,而集合则只能存储不可变对象,提供无序且不重复的数据存储。文章讲解了元组的创建、解包、可变对象概念以及集合的创建、添加、修改、删除等操作,还涵盖了集合的交集、并集、差集和异或集运算。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Python学习 - 语法入门:https://blog.youkuaiyun.com/wanzijy/article/details/125287855
Python学习 - 数据类型:https://blog.youkuaiyun.com/wanzijy/article/details/125341568
Python学习 - 流程控制:https://blog.youkuaiyun.com/wanzijy/article/details/125400906
Python学习 - 运算符(操作符):https://blog.youkuaiyun.com/wanzijy/article/details/125387919
Python学习 - 列表:https://blog.youkuaiyun.com/wanzijy/article/details/125457990
Python学习 - 字典:https://blog.youkuaiyun.com/wanzijy/article/details/125567225
Python学习 -元组和集合:https://blog.youkuaiyun.com/wanzijy/article/details/125577609
Python学习 - 函数(1):https://blog.youkuaiyun.com/wanzijy/article/details/125669084
Python学习 - 函数(2):https://blog.youkuaiyun.com/wanzijy/article/details/125739981
Python学习 - 类与对象:https://blog.youkuaiyun.com/wanzijy/article/details/125826952
Python学习 - 面向对象之封装:https://blog.youkuaiyun.com/wanzijy/article/details/125902925
Python学习 - 面向对象之继承:https://blog.youkuaiyun.com/wanzijy/article/details/125963829
Python学习 - 面向对象之多态:https://blog.youkuaiyun.com/wanzijy/article/details/127140632
Python - 文件操作(1):https://blog.youkuaiyun.com/wanzijy/article/details/127099071
Python - 文件操作(2):https://blog.youkuaiyun.com/wanzijy/article/details/127150189
Python学习 - 垃圾回收、特殊方法和模块:https://blog.youkuaiyun.com/wanzijy/article/details/126202999
Python学习 - 异常处理:https://blog.youkuaiyun.com/wanzijy/article/details/126803672

1. 元组(tuple)

1.1 简介

不可变的序列
操作方式基本上和列表是一致的
一般当希望数据不改变时,就使用元组,其余情况都使用列表

1.2 创建

使用()来创建元组

my_tuple = ()

当元组不是空元组时,括号可以省略
如果不是空元组,它里边至少要有一个“,”

my_tuple1 = 1, 2, 3, 4, 5

my_tuple2 = 1,   #  后面的逗号不能省略,不然会被当成是整型

1.3 解包(解构)

将元组当中的每一个元素都赋值给一个变量

在解包时,变量的数量必须和元组中元素的数量一致。也可以在变量前添加一个 *,这样变量将会获取元组中所有剩余的元素
不能同时出现两个或两个以上的 *

my_tuple4 = 10, 20, 30, 40
a, b, c, d = my_tuple4
print(a, b, c, d)  #  10 20 30 40

g, h, *i = my_tuple4
print(g, h, i)   #  10 20 [30, 40]

j, *k, l = my_tuple4
print(j, k, l)   #  10 [20, 30] 40

*m, n, o = my_tuple4
print(m, n, o)   #  [10, 20] 30 40

p, q, *r = [1, 2, 3, 4, 5, 6, 7]
print(p, q, r)   #  1 2 [3, 4, 5, 6, 7]

列表也能进行解包

p, q, *r = 'hello world'
print(p, q, r)   #  h e ['l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

常用于交换两个数的值

e = 100
f = 300
e, f = f, e  #  交换两个数的值

1.4 可变对象

列表是一个可变对象
注意 id值(在内存中的地址) 的变化,再结合代码中的文字注释进行理解

a = [1, 2, 3]
print(a, id(a))  #  [1, 2, 3] 2129651323400

a[0] = 10  #  通过变量去修改对象中的值,不会改变变量所指向的对象
print(a, id(a))  #  [10, 2, 3] 2129651323400

a = [4, 5, 6]  #  这种操作会改变变量所指向的对象
print(a, id(a))  #  [4, 5, 6] 2129651323912

当我们去修改对象时,如果有其他对象也指向该对象,则修改也会在其他变量中体现

a = [1, 2, 3]
b = a
a[0] = 11
print(a)  #  [11, 2, 3]
print(b)  #  [11, 2, 3]

一般只有在为变量赋值时才是修改变量,其余的都是修改对象

拓展:

  • == 和 != 比较的是对象的值是否相等
  • is 和 is not 比较的是对象的id(内存地址)是否相等(比较两个对象是否是同一个对象)

2. 集合(set)

2.1 简介

只能存储不可变对象
存储的对象是无序的(不是按照元素的插入顺序保存)
不能出现重复的元素。如果有重复的,只会保存一个,其余的将自动剔除
集合中的元素不能通过索引去操作。如果想用索引来操作的话,要先用 list() 函数转换成列表,然后再通过索引进行操作

2.2 操作

2.2.1 创建

  • { } 直接创建,但是无法创建空集合
  • set()
    • 可以创建一个空集合
    • 可以通过 set() 来将序列和字典转换为集合
    • 使用 set() 将字典转换为集合时,只会包含字典中的键
s = {}  #  创建出来的不是空集合
print(s)  #  {}

s = {11, 2, 33, 4}
print(s, type(s))  #  {33, 2, 11, 4} <class 'set'>

s = {1, 1, 1, 2, 3, 7, 4}
print(s)  #  {1, 2, 3, 4, 7}

s = set()
print(s)  #  set()

s = set([1, 2, 3, 4])
print(s)  #  {1, 2, 3, 4}

s = set('hello')
print(s)  #  {'h', 'o', 'e', 'l'}

s = set({'a': 1, 'b': 2})
print(s)  #  {'a', 'b'}

2.2.2 添加

add()

  • 向集合里添加元素
  • 语法: 集合.add(元素)
s = {1, 2, 3, 'a', 'b'}
s.add(None)
print(s)  #  {1, 2, 3, None, 'a', 'b'}

2.2.3 修改

update()

  • 将一个集合中的元素添加到当前集合中
  • 语法: 集合.update(序列/字典)
  • 如果是字典的话,只会将字典中的键添加进集合里
s = {1, 2, 3, 'a', 'b'}
s1 = {4, 6, 7, 8, 9}

s.update(s1)
print(s)  #  {1, 2, 3, None, 4, 6, 7, 8, 9, 'a', 'b'}

s.update((10, 20, 30, 40))
print(s)  #  {1, 2, 3, None, 4, 6, 7, 8, 9, 10, 40, 20, 'a', 'b', 30}

s.update({10: 'ab', 20: 'cd', 30: 'ef'})
print(s)  #  {1, 2, 3, None, 4, 6, 7, 8, 9, 10, 40, 100, 200, 300, 'b', 'a', 20, 30}

2.2.4 删除

pop()

  • 随机删除一个集合中的元素
  • 会返回删除后的值
  • 语法: 集合.pop()
s = {1, 2, 3, None, 4, 6, 7, 8, 9, 10, 40, 100, 200, 300, 'b', 'a', 20, 30}
print(s.pop())  #  1
print(s)  #  {2, 3, None, 4, 6, 7, 8, 9, 10, 40, 100, 200, 300, 'b', 'a', 20, 30}

remove()

  • 删除集合中的指定元素
  • 语法: 集合.remove(元素)
s = {2, 3, None, 4, 6, 7, 8, 9, 10, 'b', 40, 100, 200, 300, 'a', 20, 30}
s.remove(2)
print(s)  #  {3, None, 4, 6, 7, 8, 9, 10, 'b', 40, 100, 200, 300, 'a', 20, 30}

clear()

  • 清空集合中所有的元素
  • 语法: 集合.clear()
s = {2, 3, None, 4, 6, 7, 8, 9, 10, 'b', 40, 100, 200, 300, 'a', 20, 30}
s.clear()
print(s)  #  set()

2.2.5 其他

len()

  • 获取集合中元素的个数
  • 语法: len(集合)
s = {'a', 'b', 1, 2, 3}
print(len(s))  #  5

in 和 not in

  • in 检查集合中是否包含指定的元素,存在返回 True,反之
  • not in 检查集合中是否不包含指定的元素,不存在返回 True, 反之
s = {'a', 'b', 1, 2, 3}
print('a' in s)  #  True
print('a' not in s)  #  False

copy()

  • 对集合进行浅复制
  • 语法: 集合.copy()
s = {None, 3, 4, 6, 7, 8, 9, 10, 200, 'b', 20, 30, 100, 40, 300, 'a'}
a = s.copy()
print(a)  #  {None, 3, 4, 6, 7, 8, 9, 10, 200, 'b', 20, 30, 100, 40, 300, 'a'}

2.3 运算

做运算时,不会影响原来的集合。而是将运算结果返回

如果a集合中的元素全部都在b集合中出现,那么a集合就是b集合的子集,b集合就是a集合的超集
如果超集b中含有子集a中所有元素,并且b中还有a中没有的元素,则b就是a的真超集,a是b的真子集


  • & 交集运算
  • | 并集运算
  • - 差集运算
  • ^ 异或集运算,只在一个集合中出现的元素
s = {1, 2, 3, 4, 5}
s2 = {3, 4, 5, 6, 7}

print(s & s2)  #  {3, 4, 5}
print(s | s2)  #  {1, 2, 3, 4, 5, 6, 7}
print(s - s2)  #  {1, 2}
print(s ^ s2)  #  {1, 2, 6, 7}

  • <= 检查一个集合是否是另一个集合的子集
  • < 检查一个集合是否是另一个集合的超子集
  • >= 检查一个集合是否是另一个集合的超集
  • > 检查一个集合是否是另一个的真超集
a = {1, 2, 3}
b = {1, 2, 3, 4, 5}
c = {1, 2, 3}

print(a <= b)  #  True
print(a <= c)  #  True
print(a < c)  #  False
print(a < b)  #  True
### Python 实验七:元组集合的使用指南 #### 一、实验目标 本实验旨在深入理解并熟练掌握 Python 中两种重要的数据结构——元组(Tuple)集合(Set)。通过实际操作,学习如何创建、访问、修改以及应用这两种数据结构。 --- #### 二、基础知识回顾 ##### (1)元组(Tuple) - **定义**: 元组是一种有序且不可变的数据结构[^3]。 - **特点**: - 创建后无法更改其内部元素。 - 支持索引访问切片操作。 - 如果元组内的某个元素本身是可变类型,则该元素的内容可以被修改[^4]。 ##### (2)集合(Set) - **定义**: 集合是一种无序且不允许重复元素的数据结构[^3]。 - **特点**: - 自动去重。 - 提供高效的交集、并集、差集运算- 不支持索引访问。 --- #### 三、实验内容 ##### (1)元组的基本操作 ```python # 创建元组 last_names = ('赵', '钱', '孙', '李', '周', '吴') # 访问元组元素 print(f"第二个姓氏: {last_names[1]}") # 输出: 第二个姓氏: 钱 # 切片操作 sub_last_names = last_names[:3] print(f"前三个姓氏: {sub_last_names}") # 输出: 前三个姓氏: ('赵', '钱', '孙') # 元组倒序 reversed_last_names = last_names[::-1] print(f"倒序后的姓氏: {reversed_last_names}") # 输出: 倒序后的姓氏: ('吴', '周', '李', '孙', '钱', '赵') ``` ##### (2)元组的遍历 ```python # 使用 for 循环遍历 for name in last_names: print(name) # 使用 while 循环遍历 i = 0 while i < len(last_names): print(last_names[i]) i += 1 ``` ##### (3)元组的不可变特性测试 ```python number_tuple = (1, [2, 3], 4) try: number_tuple[0] = 99 # 错误示范,尝试直接修改元组中的元素 except TypeError as e: print(e) # 输出: 'tuple' object does not support item assignment # 修改嵌套的可变对象 number_tuple[1][0] = 0 print(number_tuple) # 输出: (1, [0, 3], 4) ``` ##### (4)集合的基本操作 ```python # 创建集合 unique_numbers = set([1, 2, 3, 4, 5]) # 添加元素 unique_numbers.add(6) print(unique_numbers) # 输出可能为: {1, 2, 3, 4, 5, 6} # 删除元素 unique_numbers.discard(3) print(unique_numbers) # 输出可能为: {1, 2, 4, 5, 6} ``` ##### (5)集合的高级操作 ```python set_a = {1, 2, 3, 4} set_b = {3, 4, 5, 6} # 并集 union_set = set_a.union(set_b) print(f"并集: {union_set}") # 输出: 并集: {1, 2, 3, 4, 5, 6} # 交集 intersection_set = set_a.intersection(set_b) print(f"交集: {intersection_set}") # 输出: 交集: {3, 4} # 差集 difference_set = set_a.difference(set_b) print(f"差集(A-B): {difference_set}") # 输出: 差集(A-B): {1, 2} ``` --- #### 四、注意事项 - 元组因其不可变性,在某些场景下更适合用作键值存储或函数返回多个值的情况[^3]。 - 集合由于自动去重的特点,非常适合用来过滤掉列表或其他容器中的重复项。 --- #### 五、总结 通过对元组集合学习实践,能够更好地理解运用这两类数据结构解决实际编程问题。元组适用于固定不变的小规模数据组合;而集合则适合处理动态变化的大规模唯一数据集合---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Lt0_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值