Python的tuple容器

Posted 2021-05-18 开飞机的苏克_Sucre

元组(tuple)和list一样，也是一个有序容器，在元组中，同样可以包含0个或者多个元素，并且也支持索引访问、切片等操作。
定义元组的方式是使用小括号()将元组内的元素括起来。

T = (\'Alice\', \'Bob\', \'Candy\', \'David\', \'Ellena\')
# 通过下标的方式访问元素
print(T[0]) # ==> Alice
print(T[4]) # ==> Ellena
# 切片
print(T[1:3]) # ==> (\'Bob\', \'Candy\')

元组数据类型可以把不是元组的容器转换为元组，比如将列表转换成元组。

L = [\'Alice\', \'Bob\', \'Candy\', \'David\', \'Ellena\']
print(L) # ==> [\'Alice\', \'Bob\', \'Candy\', \'David\', \'Ellena\']
T = tuple(L)
print(T) # ==> (\'Alice\', \'Bob\', \'Candy\', \'David\', \'Ellena\')

同样的，对于列表数据类型，也可以把元组转换成列表。

T = (\'Alice\', \'Bob\', \'Candy\', \'David\', \'Ellena\')
print(T) # ==> (\'Alice\', \'Bob\', \'Candy\', \'David\', \'Ellena\')
L = list(T)
print(L) # ==> [\'Alice\', \'Bob\', \'Candy\', \'David\', \'Ellena\']

但是，tuple和list不一样的是，tuple是固定不变的，一旦变成tuple，tuple中的每一个元素都不可被改变，同时也不能再往tuple中添加数据，而list是可以的。

T = (\'Alice\', \'Bob\', \'Candy\', \'David\', \'Ellena\')
# 替换元素
T[1] = \'Boby\'
# 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: \'tuple\' object does not support item assignment

请注意，元组(tuple)的这个特性是非常重要的，在运行上tuple的性能是list的数倍。

 

访问tuple元素的其他方法

由于tuple一旦定义之后便不可修改，所以在实际编程中，tuple经常用于存放固定不变的数据。
因此在使用上，tuple提供了便捷的方法可以访问tuple中的数据。

count()方法

count()方法用来统计tuple中某个元素出现的次数。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(1)) # ==> 3
print(T.count(5)) # ==> 1

对于不存在的元素，count方法不会报错，而是返回0，这是合理的，因为元组里面有0个不存在的元素。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
print(T.count(10)) # ==> 0

index()方法

index()方法可以返回指定元素的下标，当一个元素多次重复出现时，则返回第一次出现的下标位置。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(9) # ==> 10
T.index(5) # ==> 8
T.index(1) # ==> 0 # 多次出现，返回第一次出现的位置

注意，index()方法和count()方法不一样，当指定的元素不存在时，使用index()方法Python会报错。

T = (1, 1, 2, 2, 3, 3, 1, 3, 5, 7, 9)
T.index(100)
# 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple

　　

Python创建单个元素的tuple

tuple和list一样，可以包含 0 个、1个和任意多个元素。
包含多个元素的 tuple，前面我们已经创建过了。

包含 0 个元素的 tuple，也就是空tuple，直接用()表示：

T = ()
print(T) # ==> ()

接着，我们创建包含一个元素的tuple。

T = (1)
print(T) # ==> 1

这和我们期望的输出有些差异，为什么包含一个元素的元组打印出来之后没有小括号，而是只有一个数字1呢？

回顾一下前面数字的四则运算。

result = 3 * 4 - 2
print(result) # ==> 10
# 改变优先级，先运算减法
result = 3 * (4 - 2)
print(result) # ==> 6

可以看到，改变优先级我们是通过()来实现的，这和元组的定义有冲突，这就解释了前面只有一个元素的元组，为什么打印出来却得到一个数字的结果了。
因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果(1)被Python解释器计算出结果 1，导致我们得到的不是tuple，而是整数 1。
因此，要定义只有一个元素的tuple，需要在元素后面添加一个逗号,。

T = (1, )
print(T) # ==> (1, )

而对于多个元素的tuple，则加和不加这个逗号，效果是一样的。

>>> T = (1, 2, 3,)
>>> print(T) # ==> (1, 2, 3)

　　

Python的可变tuple

前面我们学习了，对于tuple，它和list一个最大的不同点就是tuple是不可变的，tuple里面的元素，也是不可替换的。但是这针对的是仅包含基础数据类型（数字类型、布尔类型、字符串类型）的数据，对于组合数据类型，则不受这个约束。

T = (1, \'CH\', [3, 4])

这里T有三个元素，第一个元素是数字类型，第二个元素是字符串类型，第三个元素是列表类型的，我们尝试修改第三个元素的数据。

T = (1, \'CH\', [3, 4])
L = T[2]
print(L) # ==> [3, 4]
# 尝试替换L中的元素
L[1] = 40
print(L) # ==> [3, 40]
print(T) # ==> (1, \'CH\', [3, 40])

这个时候，我们发现，元组T中的第三个元素已经成功被改变了，这就有悖前面的定义，元组是不可改变的。那么这到底是为什么呢？
这是因为虽然tuple中的list元素改变了，但是tuple本身指向的list仍然是同一个list，list本身并没有改变，改变的只是list里面的一个元素，这是tuple所约束不到的范围。

 

 

T = (1, \'CH\', [3, 4])
L2 = [3, 40]
# 尝试替换tuple中的list
T[2] = L2
# 报错
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: \'tuple\' object does not support item assignment

如果我们直接替换list，这也是不行的。

原文：https://www.imooc.com/learn/1261