第十讲常用数据结构之元组

男娘i 2023-09-26 21:51 100阅读 0赞

前面的两节课，我们为大家讲解了 Python 中的列表，它是一种容器型的数据类型，通过列表类型的变量，我们可以保存多个数据并通过循环实现对数据的批量操作。当然，Python 中还有其他容器型的数据类型，接下来我们就为大家讲解另一种容器型的数据类型，它的名字叫元组（tuple）。

### [元组的定义和运算][Link 1] ###

在 Python 中，元组也是多个元素按照一定顺序构成的序列。元组和列表的不同之处在于，**元组是不可变类型**，这就意味着元组类型的变量一旦定义，其中的元素不能再添加或删除，而且元素的值也不能修改。如果试图修改元组中的元素，将引发`TypeError`错误，导致程序崩溃。定义元组通常使用形如`(x, y, z)`的字面量语法，元组类型支持的运算符跟列表是一样的，我们可以看看下面的代码。

# 定义一个三元组
    t1 = (35, 12, 98)
    # 定义一个四元组
    t2 = ('骆昊', 43, True, '四川成都')
    
    # 查看变量的类型
    print(type(t1))  # <class 'tuple'>
    print(type(t2))  # <class 'tuple'>
    
    # 查看元组中元素的数量
    print(len(t1))  # 3
    print(len(t2))  # 4
    
    # 索引运算
    print(t1[0])    # 35
    print(t1[2])    # 98
    print(t2[-1])   # 四川成都
    # 切片运算
    print(t2[:2])   # ('骆昊', 43)
    print(t2[::3])  # ('骆昊', '四川成都')
    
    # 循环遍历元组中的元素
    for elem in t1:
        print(elem)
    
    # 成员运算
    print(12 in t1)         # True
    print(99 in t1)         # False
    print('Hao' not in t2)  # False
    
    # 拼接运算
    t3 = t1 + t2
    print(t3)  # (35, 12, 98, '骆昊', 43, True, '四川成都')
    
    # 比较运算
    print(t1 == t3)            # False
    print(t1 >= t3)            # False
    print(t1 <= (35, 11, 99))  # False
    复制代码

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

a = ()
    print(type(a))  # <class 'tuple'>
    b = ('hello')
    print(type(b))  # <class 'str'>
    c = (100)
    print(type(c))  # <class 'int'>
    d = ('hello', )
    print(type(d))  # <class 'tuple'>
    e = (100, )
    print(type(e))  # <class 'tuple'>
    复制代码

### [打包和解包操作][Link 2] ###

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

# 打包操作
    a = 1, 10, 100
    print(type(a))  # <class 'tuple'>
    print(a)        # (1, 10, 100)
    # 解包操作
    i, j, k = a
    print(i, j, k)  # 1 10 100
    复制代码

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

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

有一种解决变量个数少于元素的个数方法，就是使用星号表达式。通过星号表达式，我们可以让一个变量接收多个值，代码如下所示。需要注意两点：首先，用星号表达式修饰的变量会变成一个列表，列表中有0个或多个元素；其次，在解包语法中，星号表达式只能出现一次。

a = 1, 10, 100, 1000
    i, j, *k = a
    print(i, j, k)        # 1 10 [100, 1000]
    i, *j, k = a
    print(i, j, k)        # 1 [10, 100] 1000
    *i, j, k = a
    print(i, j, k)        # [1, 10] 100 1000
    *i, j = a
    print(i, j)           # [1, 10, 100] 1000
    i, *j = a
    print(i, j)           # 1 [10, 100, 1000]
    i, j, k, *l = a
    print(i, j, k, l)     # 1 10 100 [1000]
    i, j, k, l, *m = a
    print(i, j, k, l, m)  # 1 10 100 1000 []
    复制代码

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

a, b, *c = range(1, 10)
    print(a, b, c)
    a, b, c = [1, 10, 100]
    print(a, b, c)
    a, *b, c = 'hello'
    print(a, b, c)
    复制代码

### [交换变量的值][Link 3] ###

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

a, b = b, a
    复制代码

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

a, b, c = b, c, a
    复制代码

需要说明的是，上面的操作并没有用到打包和解包语法，Python 的字节码指令中有`ROT_TWO`和`ROT_THREE`这样的指令可以直接实现这个操作，效率是非常高的。但是如果有多于三个变量的值要依次互换，这个时候是没有直接可用的字节码指令的，需要通过打包解包的方式来完成变量之间值的交换。

### [元组和列表的比较][Link 4] ###

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

1.  元组是不可变类型，**不可变类型更适合多线程环境**，因为它降低了并发访问变量的同步化开销。关于这一点，我们会在后面讲解并发编程的时候跟大家一起探讨。
2.  元组是不可变类型，通常**不可变类型在创建时间上优于对应的可变类型**。我们可以使用`timeit`模块的`timeit`函数来看看创建保存相同元素的元组和列表各自花费的时间，`timeit`函数的`number`参数表示代码执行的次数。下面的代码中，我们分别创建了保存`1`到`9`的整数的列表和元组，每个操作执行`10000000`次，统计运行时间。
    
        import timeit
        
        print('%.3f' % timeit.timeit('[1, 2, 3, 4, 5, 6, 7, 8, 9]', number=10000000))
        print('%.3f' % timeit.timeit('(1, 2, 3, 4, 5, 6, 7, 8, 9)', number=10000000))
        复制代码
    
    输出：
    
        0.633
        0.078
        复制代码
    
    > **说明**：上面代码的执行结果因软硬件系统而异，在我目前使用的电脑上，执行`10000000`次创建列表的操作时间是`0.633`秒，而执行`10000000`次创建元组的操作时间是`0.078`秒，显然创建元组更快且二者时间上有数量级的差别。大家可以在自己的电脑上执行这段代码，把你的执行结果放到评论区，看看谁的电脑配置更厉害。

当然，Python 中的元组和列表类型是可以相互转换的，我们可以通过下面的代码来完成该操作。

infos = ('骆昊', 43, True, '四川成都')
    # 将元组转换成列表
    print(list(infos))  # ['骆昊', 43, True, '四川成都']
    
    frts = ['apple', 'banana', 'orange']
    # 将列表转换成元组
    print(tuple(frts))  # ('apple', 'banana', 'orange')
    复制代码

### [总结][Link 5] ###

**列表和元组都是容器型的数据类型**，即一个变量可以保存多个数据，而且它们都是按一定顺序组织元素的有序容器。**列表是可变数据类型**，**元组是不可变数据类型**，所以列表可以添加元素、删除元素、清空元素、排序反转，但这些操作对元组来说是不成立的。列表和元组都可以支持**拼接运算**、**成员运算**、**索引运算**、**切片运算**等操作，后面我们要讲到的字符串类型也支持这些运算，因为字符串就是字符按一定顺序构成的序列，在这一点上三者并没有什么区别。我们**推荐大家使用列表的生成式语法来创建列表**，它不仅好用而且效率很高，是 Python 语言中非常有特色的语法。

[Link 1]: http://tuwen.1000phone.net/details?id=MTMzMg==#%E5%85%83%E7%BB%84%E7%9A%84%E5%AE%9A%E4%B9%89%E5%92%8C%E8%BF%90%E7%AE%97
[Link 2]: http://tuwen.1000phone.net/details?id=MTMzMg==#%E6%89%93%E5%8C%85%E5%92%8C%E8%A7%A3%E5%8C%85%E6%93%8D%E4%BD%9C
[Link 3]: http://tuwen.1000phone.net/details?id=MTMzMg==#%E4%BA%A4%E6%8D%A2%E5%8F%98%E9%87%8F%E7%9A%84%E5%80%BC
[Link 4]: http://tuwen.1000phone.net/details?id=MTMzMg==#%E5%85%83%E7%BB%84%E5%92%8C%E5%88%97%E8%A1%A8%E7%9A%84%E6%AF%94%E8%BE%83
[Link 5]: http://tuwen.1000phone.net/details?id=MTMzMg==#%E6%80%BB%E7%BB%93