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

2024-06-12 1595阅读

文章目录

- - 🚀一、元组
  - - ⭐1. 元组查询的相关方法
    - ❤️2. 坑点
    - 🎬3. 修改元组
    - 🌈二、集合
    - - ⭐1. 集合踩坑
      - ❤️2. 集合特点
      - 💥无序性
        💥唯一性
        ☔3. 集合（交，并，补）
        🎬4. 集合操作方法
        💥💥增
        💥💥删
        💥💥(增)
        💥💥查
        🚀一、元组
        
        
        
        元组：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)) # tuple4 = (1,) print(type(tuple4)) # # 当（）中只存在一个元素时，其后没有 , 号，那么其类型保持元素原类型 # 有 , 号 ---- 为元组类型
        
        
        
        🎬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)) # <class 'dict'> # 原因：集合（set）与字典（dict）符号一样，但内部数据结构不同，当为{}时，它是被识别为字典 # 因此空集合的创建是用 set() set2 = set() print(type(set2)) #
        
        ❤️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：你想要从集合中移除的指定元素。
        set5 = {1, 'ahah', '数据'} set5.remove('ahah') print(set5) # {1, '数据'} set7 = {1, 'ahah', '数据'} set7.remove('kuail') # KeyError: 'kuail'
        
        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'}

VPS购买请点击我

免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们，邮箱：ciyunidc@ciyunshuju.com。本站只作为美观性配图使用,无任何非法侵犯第三方意图,一切解释权归图片著作权方,本站不承担任何责任。如有恶意碰瓷者,必当奉陪到底严惩不贷!

相关阅读

目录[+]