Python基础数据结构之元组(tuple)

矫情吗;* 2022-11-29 03:04 265阅读 0赞

前言:上篇文章我们介绍了Python中的列表,那么这篇文章我们来看看Python中的元祖。

目录:

    • 一、元祖的概念
    • 二、元祖和列表的区别
    • 三、元祖的定义
    • 四、访问元祖的值
    • 五、元祖查找元素
    • 六、元祖的循环遍历
    • 七、元祖中的问题

一、元祖的概念

有序的存储任何数据类型,元祖和列表类似,不同之处在于元祖不能修改。元祖是不可变数据类型。


二、元祖和列表的区别

相同点:

  1. 都可以存储任意数据类型的数据
  2. 都是有序的数据类型(支持下表索引和切片)
  3. 都可以使用for、while循环遍历

不同点:

  1. 列表是可变数据类型(增、删、改、查),元祖是不可变数据类型(查)。
  2. 列表用[]定义,元祖用()定义

三、元祖的定义

定义格式:元祖名 = (元素1, 元素2,...)
定义一个正常元祖:

  1. my_tuple1 = (1, 2, 'hello')
  2. print(my_tuple) # 输出(1, 2, 'hello')
  3. my_tuple2 = tuple('hello') # 将传入的对象分成最小单元逐个输出
  4. print(my_tuple2) # 输出('h', 'e', 'l', 'l', 'o')

定义一个特殊元祖(空元祖):

  1. is_tuple1 = ()
  2. print(is_tuple1) # 输出()
  3. is_tuple2 = tuple()
  4. print(is_tuple2) # 输出()

有且只有一个元素的元祖(必须加逗号):

  1. is_tuple = ('hello',)
  2. print(is_tuple) # 输出('hello')
  3. is_tuple1 = ('hello')
  4. print(is_tuple1) # 注意:如果没有加逗号,则is_tuple1不是一个元祖,而是一个字符串

四、访问元祖的值

因为元祖是有序的,所以可以使用索引和切片来访问元祖中的值
通过索引访问元祖中的值(得到元素自身数据类型):

  1. is_tuple = ("小明", 18, 3.14)
  2. value1 = is_tuple[0]
  3. value2 = is_tuple[1]
  4. value3 = is_tuple[2]
  5. print(type(value1), value1) # <class 'str'> 小明
  6. print(type(value2), value2) # <class 'int'> 18
  7. print(type(value3), value3) # <class 'float'> 3.14

通过切片访问元祖中的值(得到的值装在元祖中):

  1. is_tuple = ("小明", 18, 3.14)
  2. new_tuple = is_tuple[::-1] # 逆序输出
  3. print(new_tuple) # 输出(3.14, 18, '小明')
  4. new_tuple1 = is_tuple[:2]
  5. print(new_tuple1) # 输出('小明', 18)

五、元祖查找元素

通过in、not in、index、count来查找元祖中的元素

  1. is_tuple = ("小明", 18, 3.14, 15, "男", 15, 15)
  2. # in:查找指定元素是否在元祖中
  3. if "男" in is_tuple:
  4. print("存在") # 输出存在
  5. # not in
  6. if "你好" not in is_tuple:
  7. print("它不存在") # 输出它不存在
  8. # index:根据object获取到元素的索引值(如该元素有多个,则获取到第一次出现的索引值)
  9. value4 = is_tuple.index(15)
  10. print(value4) # 输出3
  11. # count:元祖里面某个元素有多少个
  12. value5 = is_tuple.count(15)
  13. value6 = is_tuple.count("小明")
  14. print(value5) # 输出3
  15. print(value6) # 输出1

六、元祖的循环遍历

使用for循环或者while循环将元祖中的每个元素都获取出来

  1. # for循环
  2. is_tuple = ("小明", 18, 3.14, 15, "男")
  3. for value in is_tuple:
  4. print(value)
  5. # while循环
  6. i = 0
  7. while i < len(is_tuple):
  8. print(is_tuple[i])
  9. i += 1
  10. """
  11. 两者都输出
  12. 小明
  13. 18
  14. 3.14
  15. 15
  16. """

七、元祖中的问题

元祖本身不可以对元素进行增删改,但是当元祖中嵌套列表时,可以增删改列表中的元素,通过更改列表中的元素间接修改元祖中的元素。

  1. # 创建一个元祖
  2. is_tuple = ("你好",["小明",20,"男"],22)
  3. # 拿到元祖中的列表元素
  4. value = is_tuple[1]
  5. # 进行列表元素的添加
  6. value.append("小花")
  7. value.append(55)
  8. print(is_tuple) # 输出('你好', ['小明', 20, '男', '小花', 55], 22)
  9. # 列表元素的修改
  10. value[0] = "李四"
  11. value[2] = "女 "
  12. print(is_tuple) # 输出('你好', ['李四', 20, '女', '小花', 55], 22)
  13. # 列表元素的删除
  14. del value[0]
  15. print(is_tuple) # 输出('你好', [20, '女 ', '小花', 55], 22)
  16. value.remove("小花")
  17. print(is_tuple) # 输出('你好', [20, '女 ', 55], 22)
  18. value.pop(1)
  19. print(is_tuple) # 输出('你好', [20, 55], 22)

元组可以进行连接组合:

  1. is_tuple1 = (3.14, 5, 'hello', 'world')
  2. is_tuple2 = (100, '你好', '世界')
  3. print(is_tuple1) # 输出(3.14, 5, 'hello', 'world')
  4. print(is_tuple2) # 输出(100, '你好', '世界')
  5. ret = is_tuple1 + is_tuple2
  6. print(ret) # 输出(3.14, 5, 'hello', 'world', 100, '你好', '世界')

元组里面的元素不可以删除,但是可以使用del 元组名删除整个元组:

  1. my_tuple = (1, '你好', '世界')
  2. print(my_tuple) # 输出(1, '你好', '世界')
  3. del my_tuple
  4. print(my_tuple) # 程序报错‘my_tuple’不存在,因为删除了my_tuple这个元组

以上就是博主对Python中元组的讲解,若有不足之处可以提出来,共同探讨;下篇文章讲解Python中的字典。关注博主不迷路,博主带你上高速!!!

发表评论

表情:
评论列表 (有 0 条评论,265人围观)

还没有评论,来说两句吧...

相关阅读