数据结构：元组Tuple

元组定义与使用

定义

元组是有序的不可变对象集合
元组使用小括号包围，各个对象之间使用逗号分隔
元组是异构的，可以包含多种数据类型

创建

使用逗号分隔
通过小括号填充元素
通过构造方法 tuple(iterable)

# 1、直接使用逗号分隔
t5 = 1, 2, 3
print(type(t5))
>>>(1, 2, 3)

# 2、通过小括号填充元素
t3 = (1, 2, 3)
print(t3)
>>>(1, 2, 3)
t4 = ('a', 'b', 'c')
print(t4)
>>>('a', 'b', 'c')

# 3、通过构造函数tuple()
t1 = tuple()
print(type(t1))
>>><class 'tuple'>
t2 = tuple([1, 2, 3])
print(t2)
>>>(1, 2, 3)
print(type(t2))
>>><class 'tuple'>

# 4、注意:单元素元组，逗号不可或缺
tup6 = 1,
print(type(tup6), tup6)
tup7 = (2,)
print(type(tup7), tup7)
>>> <class 'tuple'> (1,)
>>> <class 'tuple'> (2,)

索引

同列表
可以通过索引值来访问对应的元素。
正向索引，默认编号从 0 开始
反向索引，默认编号从-1 开始

切片

切片 [start: stop: step]
三个值都是可选的，非必填
start 值: 指示开始索引值，如果没有指定，则默认开始值为 0；
stop 值：指示到哪个索引值结束，但不包括这个结束索引值。如果没有指定，则取元组允许的最大索引值；
step 值：步长值指示每一步大小，如果没有指定，则默认步长值为 1。

# 切片的使用
t = (1, 2, 3, 4, 5,  6)

print(t[:])
print(t[:3])
print(t[2:4])
print(t[2:5:2])
>>>(1, 2, 3, 4, 5, 6)
>>>(1, 2, 3)
>>>(3, 4)
>>>(3, 5)

# 特殊的切片写法：逆序
print(t[::-1])
>>>(6, 5, 4, 3, 2, 1)

元组常用方法

index()

index(item)
返回与目标元素相匹配的首个元素的索引。
目标必须在元组中存在的，否则会报错

t = (1, 3, 2, 3, 2)
print(t.index(3))
>>>1
t = ('h', 'o', 'g', 'w', 'a', 'r', 't', 's', 'a')
print(t.index('a'))
>>>4

count()

count(item)：返回某个元素出现的次数。
入参：对象 item
返回：次数

t = (1, 2, 2, 3, 3, 3, 3)
print(t.count(3))
>>>4
>
t = ('h', 'o', 'o', 'o', 'g', 'w', 'a', 'r', 't', 's')
print(t.count('a'))
>>>1

元组解包

元组解包：把一个可迭代对象里的元素，一并赋值到由对应的变量组成的元组中。

# 传统逐个赋值的方式

t = (1, 2, 3)
a = t[0]
b = t[1]
c = t[2]
print(a, b, c)
>>>1 2 3

# 使用元组解包，等号两边的位数需要相同
a, b, c = (1, 2, 3)
print(a, b, c)
>>>1 2 3

元组与列表的异同

相同点

都是有序的
都是异构的，能够包含不同类型的对象
都支持索引和切片

区别

声明方式不同，元组使用()，列表使用 []
列表是可变的，元组是不可变的