Python 元组 — tuple

谁践踏了优雅 2022-08-29 10:05 406阅读 0赞

元组的定义

  • Tuple（元组）与列表类似，不同之处在于元组的 元素不能修改

    • 元组 表示多个元素组成的序列
    • 元组 在 Python 开发中，有特定的应用场景
  • 用于存储 一串 信息，数据 之间使用 , 分隔
  • 元组用 () 定义

  • 元组的 索引 从 0 开始

    • 索引 就是数据在 元组 中的位置编号

    info_tuple = (“hui”, 21, 1.75)

创建元组

  1. info_tuple = ()    # 空元组

元组中 只包含一个元素 时，需要 在元素后面添加逗号

  1. info_tuple = (21, )

如果不添加逗号的话，将不是元组类型，用 IPython 进行测验一下：

  1. In [1]: info_tuple = (50)
  3. In [2]: info_tuple
  4. Out[2]: 50
  6. In [3]: type(info_tuple)
  7. Out[3]: int
  9. In [4]: info_tuple = (50, )
  11. In [5]: type(info_tuple)
  12. Out[5]: tuple
  14. In [6]: info_tuple
  15. Out[6]: (50,)
  17. In [7]:

经测验发现，不添加逗号的话，类型为 int 不是元组。

因此当创建一个只有一个元素的元组时，需要 在元素后面添加逗号

  • info_tuple = (21, ) √ 类型是元组
  • info_tuple = (21) X 类型不是元组，是整型

元组元素不可修改

  1. In [69]: info_tuple = ('hui', 21, 1.75)
  3. In [70]: info_tuple[0]
  4. Out[70]: 'hui'
  6. In [71]: info_tuple[0] = 'wang'
  7. ---------------------------------------------------------------------------
  8. TypeError                                 Traceback (most recent call last)
  9. <ipython-input-71-40015c5375d3> in <module>
  10. ----> 1 info_tuple[0] = 'wang'
  12. TypeError: 'tuple' object does not support item assignment

类型错误：元组对象不支持元素的赋值操作

元组常用操作

元组中方法很少就两个

  • index() 获取元素第一次在元组中出现的索引
  • count() 统计元素在元组中出现的次数

元组常用操作

  • 在 ipython 中定义一个 元组，例如：info_tuple = (50, )
  • 输入 info_tuple. 按下 TAB 键，ipython 会提示 元组 能够使用的函数如下：

元组的方法

元组index()方法测验

index() 方法的作用：获取元素第一次在元组中出现的索引

  1. In [8]: info_tuple = ('hui', 'zack', 'wang', 'hui')
  3. In [9]: info_tuple.index('hui')
  4. Out[9]: 0
  6. In [10]: info_tuple.index('zack')
  7. Out[10]: 1
  9. In [11]: info_tuple.index('wang')
  10. Out[11]: 2

元组count()方法测验

count() 方法的作用：统计元素在元组中出现的次数

  1. In [12]: info_tuple = ('hui', 'zack', 'wang', 'hui')
  3. In [13]: info_tuple.count('hui')
  4. Out[13]: 2
  6. In [14]: info_tuple.count('zack')
  7. Out[14]: 1
  9. In [15]: info_tuple.count('wang')
  10. Out[15]: 1

循环遍历

  • 取值 就是从 元组 中获取存储在指定位置的数据

  • 遍历 就是 从头到尾 依次 从 元组 中获取数据

    In [17]: info_tuple = (‘hui’, 21, 1.75)

    In [18]: for obj in info_tuple:

    1. ...:     print(obj)
    2. ...:

    hui
    21
    1.75

    In [19]:

在 Python 中，可以使用 for 循环遍历所有非数字型类型的变量：列表、元组、字典 以及 字符串

在实际开发中，除非 能够确认元组中的数据类型，否则针对元组的循环遍历需求并不是很多

应用场景

互换两个变量值

通常情况我们要借助一个临时变量来辅助进行互换连个变量的值

  1. In [23]: a = 10
  3. In [24]: b = 20
  5. In [25]: # 借助临时变量的情况
  7. In [26]: temp = a
  9. In [27]: a = b
  11. In [28]: b = temp
  13. In [29]: a
  14. Out[29]: 20
  16. In [30]: b
  17. Out[30]: 10

而在Python中可以借助元组非常的便捷的来完成互换变量值。

  1. In [31]: # 利用元组
  3. In [32]: a = 10
  5. In [33]: b = 20
  7. In [34]: a, b = b, a
  9. In [35]: a
  10. Out[35]: 20
  12. In [36]: b
  13. Out[36]: 10

当做函数的参数和返回值

一个函数可以接收 任意多个参数，或者 一次返回多个数据

函数返回多个数据

  1. In [45]: def get_info():
  2.     ...:     name = 'hui'
  3.     ...:     age = 21
  4.     ...:     return name, age
  5.     ...:
  7. In [46]: name, age = get_info()
  9. In [47]: name
  10. Out[47]: 'hui'
  12. In [48]: age
  13. Out[48]: 21
  15. In [49]: type(get_info())
  16. Out[49]: tuple

通过上面代码可以看出，函数返回的结果类型为元组

Q: 为什么返回的是元组类型呢？

A: 首先 Python解释器 会将 name，age 变量进行装包，打包成一个整体即元组，但返回格式的变量之间必须要有逗号隔开。所以返回的类型是元组，达到了函数返回多个数据的功能。

Q: 返回的竟然是元组类型，接收函数返回结果又怎么能用多个变量呢？

A: 返回可以将多个变量打包成元组，那么解释器也可以将元组拆包成多个变量

这是Python解释器隐式帮我们完成了元组的装、拆包的过程。

函数接受任意参数

  1. In [54]: def set_info(*args):
  2.     ...:     print(type(args))
  3.     ...:     print(args)
  4.     ...:
  6. In [55]: set_info('hui', 21)
  7. <class 'tuple'>
  8. ('hui', 21)
  10. In [56]:

将非关键字参数打包成元组进行参数窗体，具体细节将在后面的函数进阶会详细讲解，这里先了解一下。

格式字符串

格式化字符串后面的 () 本质上就是一个元组

  1. In [38]: name = 'hui'
  3. In [39]: age = 21
  5. In [40]: info = (name, age)
  7. In [41]: type(info)
  8. Out[41]: tuple
  10. In [43]: print('%s 的年龄为 %d' % (name, age))
  11. hui 的年龄为 21
  13. In [44]: print('%s 的年龄为 %d' % info)
  14. hui 的年龄为 21
  16. In [45]:

元组和列表之间的转换

让列表变成成元组元素不可以被修改，以保护数据安全

使用 list 函数可以把元组转换成列表

  1. In [63]: infos = ('hui', 21, 1.75)
  3. In [64]: type(infos)
  4. Out[64]: tuple
  6. In [65]: infos
  7. Out[65]: ('hui', 21, 1.75)
  9. In [66]: infos = list(infos)
  11. In [67]: type(infos)
  12. Out[67]: list
  14. In [68]: infos
  15. Out[68]: ['hui', 21, 1.75]

使用 tuple 函数可以把列表转换成元组

  1. In [72]: infos = [1, 2, 3, 4, 5]
  3. In [73]: type(infos)
  4. Out[73]: list
  6. In [74]: infos
  7. Out[74]: [1, 2, 3, 4, 5]
  9. In [75]: infos = tuple(infos)
  11. In [76]: type(infos)
  12. Out[76]: tuple
  14. In [77]: infos
  15. Out[77]: (1, 2, 3, 4, 5)

尾语

✍ 用 Code 谱写世界，让生活更有趣。❤️

✍ 万水千山总是情，点赞再走行不行。❤️

✍ 码字不易，还望各位大侠多多支持。❤️

017.png

发表评论

表情：
评论列表 （有 0 条评论，406人围观）

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

相关阅读

    相关 Python 元组(Tuple)操作

    Python的元组与列表类似，不同之处在于元组的元素不能修改,元组使用小括号,列表使用方括号,元组创建很简单,只需要在括号中添加元素,并使用逗号隔开即可 一、创建元组 代码

    爱被打了一巴掌爱被打了一巴掌/ 0 赞/ 159 阅读