python容器——tuple元组的创建，访问，关于可变元组元素的替换_tuple访问

tuple元组

元组与列表的区别

1. 列表是可变序列，元组是不可变序列

元组没有增加元素，修改元素，删除元素的方法

2. 访问和处理速度比列表快

3. 元组可作为字典的键，而列表不能（整数，字符串，元组不可变）

元组的创建

1通过()创建

()可以省略

>>> a
(10, 20, 30, 40)
>>> b=10,20,30,40
>>> b
(10, 20, 30, 40)
>>> c=12,#只有一个对象时需加‘，’
>>> c
(12,)
1
2
3
4
5
6
7
8

2通过tuple()创建元组

>>> a=tuple()#创建空元组
>>> a=tuple("abc")
>>> a
('a', 'b', 'c')
>>> b=tuple(range(3))#迭代对象转化成元组
>>> b
(0, 1, 2)
>>> c=tuple([1,2,3,4,5])#列表转化成元组
>>> c
(1, 2, 3, 4, 5)
1
2
3
4
5
6
7
8
9
10

3生成器推导式创建元组

从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号

列表推导是直接生成列表

生成器推导式生成一个生成器对象

-> 1 列表或元组

-> 2 使用生成器对象的__ next __ ()方法进行遍历

->3 直接作为迭代器对象使用

元素访问结束后，需重新创建生成器对象才可访问

>>> s=(x*2 for x in range(5))
>>> s
<generator object <genexpr> at 0x00000243DCA91F50>
>>> list(s)
[0, 2, 4, 6, 8]
>>> tuple(s)
()
>>> list(s)
[]
1
2
3
4
5
6
7
8
9

>>> s=(x*2 for x in range(5))
>>> s.__next__()
0
>>> s.__next__()
2
>>> s.__next__()
4
>>> s.__next__()
6
>>> s.__next__()
8
>>> s.__next__()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

访问

元组的元素不可修改

>>> a=(30,20,10,40)
>>> a[3]#索引
40
>>> a[1:3:2]#切片
(20,)
>>> b=sorted(a)#排序，生成列表
>>> b
[10, 20, 30, 40]
1
2
3
4
5
6
7
8

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
1
2
3

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

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

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 # 多次出现，返回第一次出现的位置
1
2
3
4

注意，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
1
2
3
4
5
6

zip

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回一个对象。

>>> a=[10,50,90]
>>> b=[70,30,60]
>>> c=[80,20,40]
>>> d=zip(a,b,c)
>>> d
<zip object at 0x00000243DCAE1640>
>>> list(d)
[(10, 70, 80), (50, 30, 20), (90, 60, 40)]
1
2
3
4
5
6
7
8

Python的可变tuple

tuple里面的元素是不可替换的。但是这针对的是仅包含基础数据类型（数字类型、布尔类型、字符串类型）的数据，对于组合数据类型，则不受这个约束。

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

这里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])
1
2
3
4
5
6
7

这个时候，我们发现，元组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
1
2
3
4
5
6
7
8

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