【Python核心数据结构探秘】:元组与字典的完美协奏曲

简介: 【Python核心数据结构探秘】:元组与字典的完美协奏曲

🚀一、元组

  • 元组:tuple
  • 元组符号:()
  • 元组属于不可变类型(不可变序列)
  • 元组是序列类型(容器序列)
  • 元组不提供方法修改,但是可以转类型进行操作
⭐1. 元组查询的相关方法
  • index 查询指定元素第一次出现的下标
tuple1 = (1, 'hah', '帅')
print(tuple1.index('帅'))  # 2

注意:

  • 如果元组中不存在你要查找的值,index() 方法会抛出一个 ValueError 异常。
  • 由于元组是不可变的,找到索引通常是为了了解结构,而不是为了修改元组内容(因为无法修改)。
  • index() 方法只返回第一个匹配项的索引,即使该值在元组中出现了多次。
  • count 查询指定元素出现的次数

count() 方法,用于统计元组中某个元素出现的次数。

tuple.count(element)
  • tuple:你想要在其内部计数的元组。
  • element:你想要统计其出现次数的元素。
tuple2 = ('帅', 1, '帅', 'hah', '帅')
print(tuple2.count('帅'))  # 3


❤️2. 坑点

在Python中,元组是一种不可变的序列类型。当定义一个只包含一个元素的元组时,确实会出现一些特殊情况。如果你直接写作(元素),Python不会把它解析为一个元组,而是将其视为一个单纯的括号包围的表达式。为了明确表示这是一个只有一个元素的元组,你应该在元素后面加上一个逗号,即(元素,)。

  • 不加逗号:single_item = (42),这在Python中实际上被视为一个整数42,而不是一个元组。
  • 加逗号:single_tuple = (42,),这样就明确地定义了一个只包含一个元素42的元组。

这是因为括号()在Python中还用于表示运算优先级,以及在函数调用时包围参数列表。为了消除歧义,当创建一个只有一个元素的元组时,添加逗号是必要的。

tuple3 = (1)
print(type(tuple3))  # <class 'int'>

tuple4 = (1,)
print(type(tuple4))  # <class 'tuple'>

# 当()中只存在一个元素时, 其后没有 , 号, 那么其类型保持元素原类型
#                        有 , 号 ---- 为元组类型

🎬3. 修改元组
# 通过转类型的方式进行修改

tuple1 = (1, 'qwe', 'hahah')

# 结构相似的数据类型--- list
# 通过list方法直接将其强转为列表
list1 = list(tuple1)
# print(list1)  # [1, 'qwe', 'hahah']

# 操作数据
list1.append('快乐')
# print(list1)  # [1, 'qwe', 'hahah', '快乐']

# 转回列表 --- 通过tuple方法
tuple2 = tuple(list1)
print(tuple2)  # (1, 'qwe', 'hahah', '快乐')


🌈二、集合

  • 集合:set
  • 集合符号:{数据1,数据2…}
  • 集合属于可变类型
  • 集合数据是无序的(无序性)
  • 集合每一个元素是唯一的(唯一性)
  • 集合不属于序列
集合(set)是一种无序、不重复元素的集合,它具有判定成员资格、消除重复元素等特点。集合的元素必须是不可变的类型,例如整数、浮点数、字符串、元组等,但不能包含可变类型的对象,例如列表、字典等。集合也不是序列类型,因为它们不支持索引、切片等序列操作。
⭐1. 集合踩坑

空集合问题

set1 = {}
print(type(set1))  # &lt;class 'dict'&gt;

# 原因:集合(set)与字典(dict)符号一样,但内部数据结构不同,当为{}时,它是被识别为字典

# 因此 空集合 的创建是用 set()

set2 = set()
print(type(set2))  # <class 'set'>

❤️2. 集合特点
💥无序性
set1 = {'hah', 1, '快'}
print(set1)
# 多执行几次,发现数据出来顺序是乱的
# {1, 'hah', '快'}
# {'hah', 1, '快'}

💥唯一性
set2 = {'hah', 1, '快', 1, 1, 1}
print(set2)  # {1, '快', 'hah'}

☔3. 集合(交,并,补)

set_a = {1, 2, 'a'}
set_b = {1, 3, 'b'}

# 交集  &
set_jiao = set_a & set_b
print(set_jiao)  # {1}

# 并集  |
set_bing = set_a | set_b
print(set_bing)  # {'b', 1, 2, 3, 'a'}

# 补集  -
set_bu_b = set_a - set_b  # set_b的补集
print(set_bu_b)  # {'a', 2}
set_bu_a = set_b - set_a  # set_a的补集
print(set_bu_a)  # {'b', 3}

🎬4. 集合操作方法
💥💥增
  • add: 是把要传入的元素做为一个整个添加到集合中
  • 集合(set)是一个无序的、不重复元素的序列。add() 方法是集合的一个内置方法,用于向集合中添加一个元素。如果添加的元素已经在集合中存在,则该方法不会有任何效果,因为集合的特性决定了它不能包含重复的元素。
set.add(element)


  • set:你要向其添加元素的集合。
  • element:你想要添加到集合中的元素。
set3 = {1, 'ahah', '数据'}
set3.add('shu')
print(set3) # {'ahah', 1, 'shu', '数据'}


💥💥删
  • pop: 删除并且返回 set “集合”中的一个不确定的元素, 如果集合为空则引发 KeyError

集合(set)的 pop() 方法用于随机移除集合中的一个元素并返回该元素。因为集合是无序的,所以无法预测哪个元素会被移除。如果集合为空,调用 pop() 方法会引发 KeyError 异常。

element = set.pop()
  • set:你要从中移除并返回一个随机元素的集合。
  • element:被移除的元素。
# 随机删
set4 = {1, 'ahah', '数据'}
set4.pop()
print(set4)  # {'ahah', '数据'}

  • remove:从 set “集合”中删除指定元素 , 如果不存在则引发 KeyError

集合(set)的 remove() 方法用于移除集合中指定的元素。如果元素存在于集合中,该方法会移除这个元素,并且不返回任何值。如果尝试移除一个不存在于集合中的元素,remove() 方法会引发 KeyError 异常。

语法:

set.remove(element)
  • set:你想要从中移除元素的集合。
  • element:你想要从集合中移除的指定元素。
set:你想要从中移除元素的集合。
element:你想要从集合中移除的指定元素。
set5 = {1, 'ahah', '数据'}


  • discard: 如果在 set “集合”中存在元素 x, 则删除 ,不存在不报错
set5 = {1, 'ahah', '数据'}
set5.discard('ahah')
print(set5)  # {1, '数据'}

set7 = {1, 'ahah', '数据'}
set7.discard('kuail')
print(set7)  # {1, 'ahah', '数据'}

  • clear: 清空集合里面的所有元素
set8 = {1, 'ahah', '数据'}
set8.clear()
print(set8)  # set()   --空集合


💥💥(增)
  • update:可以在集合里面添加多项
set9 = {1, 'ahah', '数据'}
set9.update([1, '2', 3, '4'])
print(set9)  # {1, 3, '4', 'ahah', '2', '数据'}

set10 = {1, 'ahah', '数据'}
set10.update('你快乐吗?')
print(set10)  # {1, '吗', '数据', 'ahah', '你', '乐', '?', '快'}

💥💥查
  • isdisjoint: 是否无交集(无交集:True 有交集:False)
set11 = {1, 2, 'a'}
set12 = {1, 3, 'b'}
print(set11.isdisjoint(set12))  # False
  • issubset: 判断指定集合是否为该方法参数集合的子集。 是True, 不是False
# a.issubset(b) :  集合a是否为集合b的子集   判断集合b 是否包含 集合a

set13 = {1, 2, 'a'}
set14 = {1, 3, 'b'}
set15 = {1}
print(set13.issubset(set14))  # False
print(set15.issubset(set14))  # True
  • issuperset : 判断该方法的参数集合是否为指定集合的子集
# a.issuperset(b) :  集合b是否为集合a的子集   判断集合a 是否包含 集合b

set13 = {1, 2, 'a'}
set14 = {1, 3, 'b'}
set15 = {1}
print(set13.issuperset(set14))  # False
print(set15.issuperset(set14))  # False
print(set14.issuperset(set15))  # True

  • intersection: 返回集合的交集
set16 = {1, 2, 'a'}
set17 = {1, 3, 'b'}
print(set16.intersection(set17))  # {1}
  • intersection_update: 移除 指定集合 中不存在于 方法中的接收集合 中的元素(修改当前集合,使其只包含与另一个指定集合相同的元素。)
set16 = {1, 2, 'a'}
set17 = {1, 3, 'b'}
# 移除 set16 中不存在于 set17 中的元素
set16.intersection_update(set17)
print(set16)  # {1}
print(set17)  # {1, 3, 'b'}

# 使用 intersection_update() 方法同时获取多个集合的交集,并修改 set1
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7}
set3 = {3, 4, 5}
set4 = {1, 3, 5}
set1.intersection_update(set2, set3, set4)
print(set1)      # 输出结果为 {5}
  • symmetric_difference: 返回两个集合中不重复的元素集合。
set18 = {1, 2, 'a'}
set19 = {1, 3, 'b'}

print(set18.symmetric_difference(set19))  # {2, 3, 'b', 'a'}

  • symmetric_difference_update: 用于修改当前集合,使其只包含存在于当前集合或另一个指定集合中的元素,但不包含同时存在于两个集合中的元素。
set18 = {1, 2, 'a'}
set19 = {1, 3, 'b'}

set18.symmetric_difference_update(set19)
print(set18)  # {2, 3, 'a', 'b'}
print(set19)  # {'b', 1, 3}

  • union: 返回两个集合的并集两个集合的并集
set20 = {1, 2, 'a'}
set21 = {1, 3, 'b'}

print(set20.union(set21))  # {'a', 1, 2, 3, 'b'}

84b5f34121ed8e2bd9bee9a063a0bad7_137df1d3b62841d5aab9574de79e8952.png

相关文章
|
13小时前
|
算法 程序员 图形学
脑洞大开!Python并查集:用最简单的方式,解决最复杂的数据结构问题!
【7月更文挑战第17天】并查集,数据结构明星,处理不相交集合合并与查询。Python实现核心操作:查找与合并。路径压缩优化查找,按秩合并保持平衡。实战应用如图连通性判断,算法竞赛利器。掌握并查集,解锁复杂问题简单解法,照亮编程之旅!
16 10
|
1天前
|
存储 缓存 安全
Python元组不可变序列的奥秘与应用方式
Python 中的元组(Tuple)是一种有序的、不可变的数据结构,它是序列的一种特殊形式,就像一个固定大小的盒子,一旦放入物品就无法更换或移除。 元组可以包含任何类型的数据,如数字、字符串甚至是其他元组。 相比列表,元组在很多场景下提供了更高效、安全的选择。
|
1天前
|
算法 计算机视觉 开发者
燃爆全场!Python并查集:数据结构界的网红,让你的代码炫酷无比!
【7月更文挑战第16天】并查集,Python中的效率明星,处理不相交集合合并与查询。用于社交网络分析、图像处理、图论算法等领域。优雅实现结合路径压缩和按秩合并
7 1
|
1天前
|
算法 程序员 计算机视觉
Python并查集:数据结构界的肌肉男,让你在编程路上无所畏惧!
【7月更文挑战第16天】并查集,一种处理不相交集合合并与查询的数据结构,被誉为编程的“肌肉男”。它提供Find(找根节点)和Union(合并集合)操作,常用于好友关系判断、图像处理、集合合并等。Python实现中,路径压缩和按秩合并优化效率。并查集的高效性能使其成为解决问题的强大工具,助力程序员应对复杂挑战。
10 0
|
4天前
|
存储 数据可视化 数据处理
`geopandas`是一个开源项目,它为Python提供了地理空间数据处理的能力。它基于`pandas`库,并扩展了其对地理空间数据(如点、线、多边形等)的支持。`GeoDataFrame`是`geopandas`中的核心数据结构,它类似于`pandas`的`DataFrame`,但包含了一个额外的地理列(通常是`geometry`列),用于存储地理空间数据。
`geopandas`是一个开源项目,它为Python提供了地理空间数据处理的能力。它基于`pandas`库,并扩展了其对地理空间数据(如点、线、多边形等)的支持。`GeoDataFrame`是`geopandas`中的核心数据结构,它类似于`pandas`的`DataFrame`,但包含了一个额外的地理列(通常是`geometry`列),用于存储地理空间数据。
6 0
|
4天前
|
存储 算法 Python
“解锁Python高级数据结构新姿势:图的表示与遍历,让你的算法思维跃升新高度
【7月更文挑战第13天】Python中的图数据结构用于表示复杂关系,通过节点和边连接。常见的表示方法是邻接矩阵(适合稠密图)和邻接表(适合稀疏图)。图遍历包括DFS(深度优先搜索)和BFS(广度优先搜索):DFS深入探索分支,BFS逐层访问邻居。掌握这些技巧对优化算法和解决实际问题至关重要。**
10 1
|
5天前
|
算法 Python
逆袭之路!用 Python 玩转图的 DFS 与 BFS,让数据结构难题无处遁形
【7月更文挑战第12天】图的遍历利器:DFS 和 BFS。Python 中,图可表示为邻接表或矩阵。DFS 沿路径深入,回溯时遍历所有可达顶点,适合找路径和环。BFS 层次遍历,先近后远,解决最短路径问题。两者在迷宫、网络路由等场景各显神通。通过练习,掌握这些算法,图处理将游刃有余。
15 3
|
5天前
|
存储 Python 容器
Python字典
【7月更文挑战第12天】Python字典
8 2
|
5天前
|
存储 缓存 Python
Python中的列表(List)和元组(Tuple)是两种重要的数据结构
【7月更文挑战第12天】Python中的列表(List)和元组(Tuple)是两种重要的数据结构
7 1
|
7天前
|
存储 算法 索引
python dict字典
python dict字典