Python不可变类型之元组tuple

python中数据类型有四种：

1. 元组
2. 列表
3. 字典
4. 集合

一：元组

1. 我们来讲讲什么是元组？

元组是有序的且不可更改的集合 ，用 （） 表示,元组的元素无法修改

2. 元组中的元素

元素内的元素得是数字，字符串可以用双引号“”、单引号‘’引起来，当元组中只包含一个元素时候，需要在元素后面添加逗号，不然会被当做运算符使用

3. 下表索引方式

元组和列表一样，可以使用下标索引访问元组中的某个元素（得到一个元素的值），也可以切片访问元组中的一组元素（一组子元组）
下标索引分正向索引，反向索引

	tuple_name = (1, 2, 3, 4, 5)
	print(tuple_name[1]) #正向索引
	print(tuple_name[-1])# 反向索引
1
2
3

4. 切片访问

	元组值 (  1   2   3   4   5   6  )
	正向索引   0   1   2   3   4   5
	方向索引  -6  -5  -4  -3  -2  -1
1
2
3

5. 切片表达式

表达式：tuple_name = (start：end：step)  
start：表示起始索引
end：结束索引
step：表示步长
1
2
3
4

使用表示式：tuple_name = (start：end) 是左闭右开区间，访问不了end的元素

6. 判断元组中的元素是否存在

tuple_name = (1, 2, 3, 4, 5,6)
print(2 in tuple_name)
1
2

7. for循环遍历元组

tuple_name = (1, 2, 3, 4, 5,6)
print(tuple_name)
for i in tuple_name:
    print(i)
1
2
3
4

8. 元组拼接

使用 + 拼接

tuple_name1 = (1, "aS", "无敌")
tuple_name2 = (2, "sad", "小手")
print(tuple_name1 + tuple_name2)
print(tuple_name2 *2)
1
2
3
4

使用 * 5 复制

tuple_name2 = (2, "sad", "小手")
print(tuple_name2 *2)
1
2

9.元组的不可变性

tuple_name = (1, 2, 3, 4, 5,6)
tuple_name[0] = 99
print(tuple_name)
1
2
3

代码报错：TypeError: ‘tuple’ object does not support item assignment 不支持修改元素

tup = (1,2,3)
print(id(tup))
tup = (4,5,6)
print(id(tup))

1822504511168
1822504544704

1
2
3
4
5
6
7
8

重新赋值，保存的内存地址也不一样，没有去修改原来的tup对象，而是重新绑定新的对象

10. 元组 的 增删改查

元组增加元素方法一：元组 使用__add__( ) 方法,添加元素重洗赋值给a

a = (1,)
print(id(a))
print(a)
a = a.__add__((2,3,6))
print(id(a))
print(a)

运行之后：
1948714869184
(1,)
1948717773424
(1, 2, 3, 6)
1
2
3
4
5
6
7
8
9
10
11
12

因为元组是不可变的，需要重新赋值给a

a = (1,)
print(id(a))
print(a)
a.__add__((2,3,6))
print(id(a))
print(a)

运行之后：
1689827353024
(1,)
1689827353024
(1,)
1
2
3
4
5
6
7
8
9
10
11
12

元组增加元素方法二：将需要添加的元组，变为列表list，使用append()方法添加到列表当中，在转换为tuple元组

a = (1,2,3)
a = list(a)
print(type(a))
a.append(8)
a = tuple(a)
print(a)
print(type(a))

运行代码：
<class 'list'>
(1, 2, 3, 8)
<class 'tuple'>
1
2
3
4
5
6
7
8
9
10
11
12

元组删除元素
元组是不可变的，可以删除整个元组

tupe = (1, 2, 3, 4, 5, 6)
del tupe
1
2

可以将元组转变为列表去删除，让我们认识一下有哪些方法？

1、remove( )方法 ：一次删除一个元素；如果列表内有重复元素则删除第一个；元素不存在时抛出异常ValueError
2、pop( ): 删除一个指定的索引位置上的元素；指定索引不存在则抛出异常IndexError
3、clear( ): 清空列表
4、del: 删除列表
5、使用元组的方法 去切片

1、使用remove（）方法：

tupe = (1, 2, 3, 4, 5, 6)
print(tupe)
tupe = list(tupe)
print(type(tupe))
tupe.remove(2)
tupe = tuple(tupe)
print(type(tupe))
print(tupe)

运行代码：
(1, 2, 3, 4, 5, 6)
<class 'list'>
<class 'tuple'>
(1, 3, 4, 5, 6)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2、使用pop( )方法

注意：如果不指定参数，则默认删除最后一个元素

tupe = (1, 2, 3,3, 4,4, 5, 6)
print(tupe)
tupe = list(tupe)
print(type(tupe))
tupe.pop(1)
tupe = tuple(tupe)
print(type(tupe))
print(tupe)

运行代码：
(1, 2, 3, 3, 4, 4, 5, 6)
<class 'list'>
<class 'tuple'>
(1, 3, 3, 4, 4, 5, 6)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3、使用clear( )方法

在这里面发现一个问题，使用列表list.clean() 报错

排查到在python3中，list.clear()方法不可使用，需要用**del list[:]**替代clear()方法。

4、del: 删除列表 方法

5、切片

切片的本意为截取原有列表中指定的的某一段，或者说是复制指定的那一段，并返回了新的列表。
借助列表的添加方式，原来添加的操作中，使得lst[start,stop] = lst1（此为添加的元素）
那么删除操作可以类似的，使lst1为空列表，那么原列表中指定一段的元素被空替代，则完成删除
其中切片的具体操作在python中list列表的切片截取操作，包含倒序输出

tupe = (1, 2, 3, 4, 5, 6)
print(f"原元组{tupe}")
tupe = tupe[3:]  # 重新赋值
print(f"切片后{tupe}")

运行代码后：
原元组(1, 2, 3, 4, 5, 6)
切片后(4, 5, 6)
1
2
3
4
5
6
7
8

当只有一个冒号时返回所有元素的副本。例子：a[:]
a[3:]下标3之后的所有元素，这里面不包括下标三这个元素。
a[-3:] 最后3 个元素
a[:-5] 除最后五个元素以外的所有元素。
a[: :3]每三个元素选一个。

11. 元组的类型转换

1、转列表list

tupe = (1, 2, 3, "无敌小手")
print(type(tupe))
print(tupe)

tupe = list(tupe)  # 转列表
print(type(tupe))
print(tupe)

运行代码：
<class 'tuple'>
(1, 2, 3, '无敌小手')
<class 'list'>
[1, 2, 3, '无敌小手']
1
2
3
4
5
6
7
8
9
10
11
12
13

2、元组tuple转集合set

tupe = (1, 2, 3, "无敌小手")
print(type(tupe))
print(tupe)
tupe = set(tupe)
print(type(tupe))
print(tupe)

运行代码：
<class 'tuple'>
(1, 2, 3, '无敌小手')
<class 'set'>
{1, 2, 3, '无敌小手'}
1
2
3
4
5
6
7
8
9
10
11
12

3、 元组和列表不能直接转字典

12. 元组的内置函数

1、count（）方法 返回指定值在元组中出现的次数。

tupe = (1, 2, 3, 4, 5, 6)
print(tupe.count(2))

运行代码后：
1
1
2
3
4
5

2、index（）方法 查找指定值的第一次出现。

tupe = (1, 2,2,2, 3, 4, 5, 6)
print(tupe.index(3))

运行代码后：
4
1
2
3
4
5

注意：当被搜索值在元组中存在多个，则返回第一次出现的下标

如果未找到该值，index() 方法将引发异常，ValueError: tuple.index(x): x not in tuple。

14.元组跟列表的区别

元组：
静态数组，不可变，元组内部数据建立就不可修改
元组缓存于python的运行时的环境，使用元组无需访问内核去分配内存
元组可以拼接元组，转换类型去增删改查
支持切片

列表：
态数组，可变，可以设置长度，可以改变内部元素
append()、extend()、insert()、remove()和pop()等方法实现添加和修改，元组没有
列表不能作为字典的键，而元组则可以
支持切片

15. 元组的总结

静态数组，不可变，元组内部数据建立就不可修改
元组缓存于python的运行时的环境，使用元组无需访问内核去分配内存
元组可以拼接元组，转换类型去增删改查
支持切片
元组不可修改，安全
可读、速度快
可以存多个值 有序,
依赖索引取值
不可变类型—>可 hash 类型

​