定义和使用元组

在Python中，元组也是多个元素按照一定的顺序构成的序列。元组和列表的不同之处在于，元组是不可变类型，这就意味着元组类型的变量一旦定义，其中的元素不能再添加或删除，而且元素的值也不能进行修改。定义元组通常使用()字面量语法，元组类型支持的运算符跟列表是一样。下面的代码演示了元组的定义和运算。

  1. # 定义一个三元组
  2. t1 = (30, 10, 55)
  3. # 定义一个四元组
  4. t2 = ('程不懂', 40, True, '四川成都')
  6. # 查看变量的类型
  7. print(type(t1), type(t2))    # <class 'tuple'> <class 'tuple'>
  8. # 查看元组中元素的数量
  9. print(len(t1), len(t2))      # 3 4
  11. # 通过索引运算获取元组中的元素
  12. print(t1[0], t1[-3])         # 30 30
  13. print(t2[3], t2[-1])         # 四川成都 四川成都
  15. # 循环遍历元组中的元素
  16. for member in t2:
  17.     print(member)
  19. # 成员运算
  20. print(100 in t1)    # False
  21. print(40 in t2)     # True
  23. # 拼接
  24. t3 = t1 + t2
  25. print(t3)           # (30, 10, 55, '程不懂', 40, True, '四川成都')
  27. # 切片
  28. print(t3[::3])      # (30, '程不懂', '四川成都')
  30. # 比较运算
  31. print(t1 == t3)    # False
  32. print(t1 >= t3)    # False
  33. print(t1 < (30, 11, 55))    # True

一个元组中如果有两个元素，我们就称之为二元组；一个元组中如果五个元素，我们就称之为五元组。需要提醒大家注意的是，()表示空元组，但是如果元组中只有一个元素，需要加上一个逗号，否则()就不是代表元组的字面量语法，而是改变运算优先级的圆括号，所以('hello', )和(100, )才是一元组，而('hello')和(100)只是字符串和整数。我们可以通过下面的代码来加以验证。

  1. # 空元组
  2. a = ()
  3. print(type(a))    # <class 'tuple'>
  4. # 不是元组
  5. b = ('hello')
  6. print(type(b))    # <class 'str'>
  7. c = (100)
  8. print(type(c))    # <class 'int'>
  9. # 一元组
  10. d = ('hello', )
  11. print(type(d))    # <class 'tuple'>
  12. e = (100, )
  13. print(type(e))    # <class 'tuple'>

元组的应用场景

例子1：打包和解包操作。

当我们把多个用逗号分隔的值赋给一个变量时，多个值会打包成一个元组类型；当我们把一个元组赋值给多个变量时，元组会解包成多个值然后分别赋给对应的变量，如下面的代码所示。

  1. # 打包
  2. a = 1, 10, 100
  3. print(type(a), a)    # <class 'tuple'> (1, 10, 100)
  4. # 解包
  5. i, j, k = a
  6. print(i, j, k)       # 1 10 100

在解包时，如果解包出来的元素个数和变量个数不对应，会引发ValueError异常，错误信息为：too many values to unpack（解包的值太多）或not enough values to unpack（解包的值不足）。

  1. a = 1, 10, 100, 1000
  2. i, j, k = a             # ValueError: too many values to unpack (expected 3)
  3. i, j, k, l, m, n = a    # ValueError: not enough values to unpack (expected 6, got 4)

有一种解决变量个数少于元素的个数方法，就是使用星号表达式，我们之前讲函数的可变参数时使用过星号表达式。有了星号表达式，我们就可以让一个变量接收多个值，代码如下所示。需要注意的是，用星号表达式修饰的变量会变成一个列表，列表中有0个或多个元素。还有在解包语法中，星号表达式只能出现一次。

  1. a = 1, 10, 100, 1000
  2. i, j, *k = a
  3. print(i, j, k)          # 1 10 [100, 1000]
  4. i, *j, k = a
  5. print(i, j, k)          # 1 [10, 100] 1000
  6. *i, j, k = a
  7. print(i, j, k)          # [1, 10] 100 1000
  8. *i, j = a
  9. print(i, j)             # [1, 10, 100] 1000
  10. i, *j = a
  11. print(i, j)             # 1 [10, 100, 1000]
  12. i, j, k, *l = a
  13. print(i, j, k, l)       # 1 10 100 [1000]
  14. i, j, k, l, *m = a
  15. print(i, j, k, l, m)    # 1 10 100 1000 []

需要说明一点，解包语法对所有的序列都成立，这就意味着对字符串、列表以及我们之前讲到的range函数返回的范围序列都可以使用解包语法。大家可以尝试运行下面的代码，看看会出现怎样的结果。

  1. a, b, *c = range(1, 10)
  2. print(a, b, c)  # 1 2 [3, 4, 5, 6, 7, 8, 9]
  3. a, b, c = [1, 10, 100]
  4. print(a, b, c)  # 1 10 100
  5. a, *b, c = 'hello'
  6. print(a, b, c)  # h ['e', 'l', 'l'] o

现在我们可以反过来思考一下函数的可变参数，可变参数其实就是将多个参数打包成了一个元组，可以通过下面的代码来证明这一点。

  1. def add(*args):
  2.     print(type(args), args)
  3.     total = 0
  4.     for val in args:
  5.         total += val
  6.     return total
  9. add(1, 10, 20)        # <class 'tuple'> (1, 10, 20)
  10. add(1, 2, 3, 4, 5)    # <class 'tuple'> (1, 2, 3, 4, 5)

例子2：交换两个变量的值。

交换两个变量的值是编程语言中的一个经典案例，在很多编程语言中，交换两个变量的值都需要借助一个中间变量才能做到，如果不用中间变量就需要使用比较晦涩的位运算来实现。在Python中，交换两个变量a和b的值只需要使用如下所示的代码。

  1. a, b = b, a

同理，如果要将三个变量a、b、c的值互换，即b赋给a，c赋给b，a赋给c，也可以如法炮制。

  1. a, b, c = b, c, a

需要说明的是，上面并没有用到打包和解包语法，Python的字节码指令中有ROT_TWO和ROT_THREE这样的指令可以实现这个操作，效率是非常高的。但是如果有多于三个变量的值要依次互换，这个时候没有直接可用的字节码指令，执行的原理就是我们上面讲解的打包和解包操作。

例子3：让函数返回多个值。

有的时候一个函数执行完成后可能需要返回多个值，这个时候元组类型应该是比较方便的选择。例如，编写一个找出列表中最大值和最小的函数。

  1. def find_max_min(items):
  2.     """
  3.     找出列表中最大和最小的元素
  4.     :param items: 列表
  5.     :return: 最大值和最小值构成的二元组
  6.     """
  7.     max_one, min_one = items[0], items[0]
  8.     for item in items:
  9.         if item > max_one:
  10.             max_one = item
  11.         elif item < min_one:
  12.             min_one = item
  13.     return max_one, min_one

上面函数的return语句中有两个值，这两个值会组装成一个二元组然后返回。所以调用find_max_min函数会得到这个二元组，如果愿意也可以通过解包语法将二元组中的两个值分别赋给两个变量。

元组和列表的比较

这里还有一个非常值得探讨的问题，Python中已经有了列表类型，为什么还需要元组这样的类型呢？这个问题对于初学者来说似乎有点困难，不过没有关系，我们先抛出观点，大家可以一边学习一边慢慢体会。

  • 元组是不可变类型，不可变类型更适合多线程环境，因为它降低了并发访问变量的同步化开销。关于这一点，我们会在后面讲解多线程的时候为大家详细论述。
  • 元组是不可变类型，通常不可变类型在创建时间和占用空间上面都优于对应的可变类型。我们可以使用sys模块的getsizeof函数来检查保存相同元素的元组和列表各自占用了多少内存空间。我们也可以使用timeit模块的timeit函数来看看创建保存相同元素的元组和列表各自花费的时间，代码如下所示。 ```python import sys import timeit

a = list(range(100000)) b = tuple(range(100000)) print(sys.getsizeof(a), sys.getsizeof(b)) # 900120 800056

print(timeit.timeit(‘[1, 2, 3, 4, 5, 6, 7, 8, 9]’)) print(timeit.timeit(‘(1, 2, 3, 4, 5, 6, 7, 8, 9)’))

  2. - Python中的元组和列表是可以相互转换的，我们可以通过下面的代码来做到。
  3. ```python
  4. # 将元组转换成列表
  5. info = ('程不懂', 185, True, '四川成都')
  6. print(list(info))       # ['程不懂', 185, True, '四川成都']
  7. # 将列表转换成元组
  8. fruits = ['apple', 'banana', 'orange']
  9. print(tuple(fruits))    # ('apple', 'banana', 'orange')

简单的总结

列表和元组都是容器型的数据类型，即一个变量可以保存多个数据。列表是可变数据类型，元组是不可变数据类型，所以列表添加元素、删除元素、清空、排序等方法对于元组来说是不成立的。但是列表和元组都可以进行拼接、成员运算、索引和切片这些操作，就如同之前讲到的字符串类型一样，因为字符串就是字符按一定顺序构成的序列，在这一点上三者并没有什么区别。