ToB企服应用市场:ToB评测及商务社交产业平台

标题: 深挖 Python 元组 pt.2 [打印本页]
作者: 欢乐狗    时间: 2023-10-21 11:31
标题: 深挖 Python 元组 pt.2
哈喽大家好，我是咸鱼
在《深挖 Python 元组 pt.1》中我们了解 Python 元组的一些概念（索引和切片等），以及如何创建元组，最重要的是我们还介绍了元组的不可变特性
那么今天我们来继续深挖 Python 元组
打包&解包

在 python 中，元组可以被打包（packing ）和解包（unpacking ）
例如，point = x, y, z 将会把 x, y 和 z 的值打包到 point 中，于是创建了一个新元组
  1. >>> x = 1
  2. >>> y = 2
  3. >>> z = 3
  4. >>> point = x,y,z
  5. >>> point
  6. (1, 2, 3)
复制代码
我们还可以执行反向操作（解包），将元组 point 的值解包为适当数量的变量
  1. >>> point = (7, 14, 21)
  3. >>> x, y, z = point
  4. >>> x
  5. 7
  6. >>> y
  7. 14
  8. >>> z
  9. 21
复制代码
可以看到，x, y, z = point 神奇地将point的内容解压缩为三个变量。注意，值按顺序转到变量。(第一个值归第一个变量，第二个值归第二个变量，依此类推)
Python 3.5 扩展了元组解包语法，以处理各种可迭代对象
所以不单单元组可以解包，可迭代对象也可以解包
在常规解包中，变量的数量必须与要解包的值的数量相匹配。否则会报错
  1. >>> point = (7, 14, 21)
  3. >>> x, y = point
  4. Traceback (most recent call last):
  5.     ...
  6. ValueError: too many values to unpack (expected 2)
复制代码
解包最常见的用例就是利用解包在变量之间交换值
没有解包的话使用常规赋值在两个变量之间交换值，必须使用临时变量
  1. >>> a = 200
  2. >>> b = 400
  4. >>> temp = a
  5. >>> a = b
  6. >>> b = temp
  8. >>> a
  9. 400
  10. >>> b
  11. 200
复制代码
通过解包来交换变量值
  1. >>> a = 200
  2. >>> b = 400
  4. >>> a, b = b, a
  6. >>> a
  7. 400
  8. >>> b
  9. 200
复制代码
解包还有一个用处是并行分配，比如说下面的操作：我们在进行赋值时需要知道对应的索引
  1. >>> employee = ("John Doe", 35, "Python Developer")
  3. >>> name = employee[0]
  4. >>> age = employee[1]
  5. >>> job = employee[2]
复制代码
如果通过解包来实现，则无需使用索引。这样能使代码更易阅读和理解，且不易出错
  1. >>> name, age, job = ("John Doe", 35, "Python Developer")
复制代码
Python 还有一个打包和解包运算符 （ * ），我们可以使用它让解包（打包）操作更加灵活
例如当左边的变量数和右边元组的元素数量不匹配时，可以使用 *  使得单个变量接收多个值
  1. >>> numbers = (1, 2, 3, 4, 5)
  3. >>> *head, last = numbers
  4. >>> head
  5. [1, 2, 3, 4]
  6. >>> last
  7. 5
  9. >>> first, *middle, last = numbers
  10. >>> first
  11. 1
  12. >>> middle
  13. [2, 3, 4]
  14. >>> last
  15. 5
  17. >>> first, second, *tail = numbers
  18. >>> first
  19. 1
  20. >>> second
  21. 2
  22. >>> tail
  23. [3, 4, 5]
  25. >>> first, *_ = numbers
  26. >>> first
  27. 1
复制代码
关于这个操作符的更多用法，可以看我之前的文章：《python 星号 * 还能这么用》
函数返回元组

在某些情况下，需要从函数返回多个值。所以可以构建一个带有逗号分隔的一系列参数的 return 语句，这样返回的是一个元组
我们还可以使函数返回值是列表，这样需要我们显式地使用方括号来构建列表
内置 divmod() 函数是返回多个值的函数的一个很好的例子。该函数接受两个数字，并在执行整数除法时返回一个包含商和余数的元组：
  1. >>> divmod(4, 2)
  2. (2, 0)
  4. # 由于该函数返回元组，因此可以使用解包语法将每个值存储在其专用变量中
  5. >>> quotient, remainder = divmod(8, 2)
  6. >>> quotient
  7. 4
  8. >>> remainder
  9. 0
复制代码
又或者我打算写一个函数，这个函数返回一组数的最大值和最小值
  1. >>> def find_extremes(iterable):
  2. ...     data = tuple(iterable)
  3. ...     if len(data) == 0:
  4. ...         raise ValueError("input iterable must not be empty")
  5. ...     return min(data), max(data)
  6. ...
  8. >>> extremes = find_extremes([3, 4, 2, 6, 7, 1, 9])
  9. >>> extremes
  10. (1, 9)
  12. >>> type(extremes)
  13. <class 'tuple'>
复制代码
可以看到函数的返回值有两个：最大值、最小值。当用逗号分隔一系列值时，将创建一个元组。因此，此函数返回一个 tuple 对象
深拷贝浅拷贝

当需要转换数据时，通常需要复制对象，同时保持原始数据不变。在处理可变数据类型(如列表和字典)时，副本非常有用
副本可以在不影响原数据的情况下对数据进行更改
我们先来看一个例子
  1. >>> student_info = ("Linda", 18, ["Math", "Physics", "History"])
  3. >>> student_profile = student_info[:]
  4. >>> id(student_info) == id(student_profile)
  5. True
  6. >>> id(student_info[0]) == id(student_profile[0])
  7. True
  8. >>> id(student_info[1]) == id(student_profile[1])
  9. True
  10. >>> id(student_info[2]) == id(student_profile[2])
  11. True
复制代码
可以看到，student_info、 student_profile 是对同一元组对象的引用。所以， student_profile 是 的 student_info 别名而不是副本
copy 模块中的 copy() 函数生成等效结果
  1. >>> from copy import copy
  3. >>> student_info = ("Linda", 18, ["Math", "Physics", "History"])
  5. >>> student_profile = copy(student_info)
  6. >>> id(student_info) == id(student_profile)
  7. True
  8. >>> id(student_info[0]) == id(student_profile[0])
  9. True
  10. >>> id(student_info[1]) == id(student_profile[1])
  11. True
  12. >>> id(student_info[2]) == id(student_profile[2])
  13. True
复制代码
可以看到，两个变量student_info、 student_profile 都包含对同一元组对象和相同元素的引用
上面的元组里面包含了一个列表元素，我们知道列表是可变的，我们来试着更改一下
  1. >>> student_profile[2][2] = "Computer science"
  3. >>> student_profile
  4. ('Linda', 18, ['Math', 'Physics', 'Computer science'])
  5. >>> student_info
  6. ('Linda', 18, ['Math', 'Physics', 'Computer science'])
复制代码
可以看到，student_profile 更改会影响 student_info 中的原始数据
下面的例子中， student_info 通过 deepcopy() 函数制作了student_profile
  1. >>> from copy import deepcopy
  3. >>> student_info = ("Linda", 18, ["Math", "Physics", "History"])
  4. >>> student_profile = deepcopy(student_info)
  6. >>> id(student_info) == id(student_profile)
  7. False
  8. >>> id(student_info[0]) == id(student_profile[0])
  9. True
  10. >>> id(student_info[1]) == id(student_profile[1])
  11. True
  12. >>> id(student_info[2]) == id(student_profile[2])
  13. False
复制代码
可以看到，两个变量student_info、 student_profile 指向的元组对象不是同一个
如果我们对里面的列表元素进行更改
  1. >>> student_profile[2][2] = "Computer science"
  2. >>> student_profile
  3. ('Linda', 18, ['Math', 'Physics', 'Computer science'])
  4. >>> student_info
  5. ('Linda', 18, ['Math', 'Physics', 'History'])
复制代码
可以看到，对student_profile 的修改不会影响 student_info 中的数据
总结一下：
其他操作

在 Python 中连接两个元组，可以使用加号运算符 （ + ）
  1. >>> personal_info = ("John", 35)
  2. >>> professional_info = ("Computer science", ("Python", "Django", "Flask"))
  4. >>> profile = personal_info + professional_info
  5. >>> profile
  6. ('John', 35, 'Computer science', ('Python', 'Django', 'Flask'))
复制代码
需要注意的是，+ 左右两边必须都是元组，即只能将元组跟元组拼接。如果元组跟列表或其他对象拼接的话，会报错
  1. >>> (0, 1, 2, 3, 4, 5) + [6, 7, 8, 9]
  2. Traceback (most recent call last):
  3.     ...
  4. TypeError: can only concatenate tuple (not "list") to tuple
复制代码
元组使用重复运算符 （ * ）将元素克隆多次
  1. >>> numbers = (1, 2, 3)
  3. >>> numbers * 3
  4. (1, 2, 3, 1, 2, 3, 1, 2, 3)
  6. >>> 4 * numbers
  7. (1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)
复制代码
内置 reversed() 函数将序列作为参数，并返回一个迭代器，该迭代器以相反的顺序从输入序列生成值
  1. >>> days = (
  2. ...     "Monday",
  3. ...     "Tuesday",
  4. ...     "Wednesday",
  5. ...     "Thursday",
  6. ...     "Friday",
  7. ...     "Saturday",
  8. ...     "Sunday",
  9. ... )
  11. >>> reversed(days)
  12. <reversed object at 0x107032b90>
  14. >>> tuple(reversed(days))
  15. (
  16.     'Sunday',
  17.     'Saturday',
  18.     'Friday',
  19.     'Thursday',
  20.     'Wednesday',
  21.     'Tuesday',
  22.     'Monday'
  23. )
复制代码
使用元组作为参数进行调用 reversed() 时，将获得一个迭代器对象，该对象以相反的顺序生成项
如果要对元组进行排序，可以使用内置 sorted() 函数，该函数将值的可迭代对象作为参数并以列表形式返回排序后的值
  1. >>> numbers = (2, 9, 5, 1, 6)
  3. >>> sorted(numbers)
  4. [1, 2, 5, 6, 9]
复制代码
如果元组里面的元素数据类型不一致（异构数据），则无法排序

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4