python基础之元组tuple详解

***原创不易，欢迎大家收藏关注，谢谢！！！！***

目录介绍

1. 元组的定义 

元组如果只有一个元素，最后必须要添加加英文逗号 

使用tuple()函数将可迭代对象转换为元组 

2. 元组是不可变数据类型 

3. 函数的形参*args传入实参后，args数据类型元组 

4. 元组的切片 

5. 元组的For循环 

6. 元组的copy功能 

7. 元组的合并 

8. 元组的重复扩展 

9. 元组的删除 

10. 元组的内置count()函数 

11. 元组的内置index()函数

12. 判断元素是否位于元组

Python的元组与列表类似，但元组是不可变的，意味着元组的元素一旦创建不能被修改。

元组使用小括号()表示，有以下几个特点：

1. 元组是一个不可变的序列
2. 当元组不是空元组时，括号可以省略
3. 当元组只有一个元素时，需加逗号
4. 元素可重复

元组的定义

• 元组如果只有一个元素，最后必须要添加加英文逗号

#只有一个元素 无逗号，类型为字符串
tupleB = ('color')
print(type(tupleB))
#打印结果
<class 'str'>
  
#只有一个元素 最后有逗号，类型为元组
tupleB = ('color',)
print(type(tupleB))
#打印结果
<class 'tuple'>

使用tuple()函数将可迭代对象转换为元组

• 转换集合

#定义一个集合
number_setA = {"name","age","color"}
print(tuple(number_setA))
#转换结果如下
("age","color","name")

• 转换字典

#定义一个字典
number_dictA = {"name":"lily","age":21,"color":"red"}
#转换字典的键值为元组
print(tuple(number_dictA.keys()))
print(tuple(number_dictA.values()))
print(tuple(number_dictA.items()))
#转化结果如下
('name', 'age', 'color')
('lily', 21, 'red')
(('name', 'lily'), ('age', 21), ('color', 'red'))

• 转换列表

#定义一个列表
number_listA = [1,2,3,4,5]
print(tuple(number_listA))
#转换结果如下
(1, 2, 3, 4, 5)

元组是不可变数据类型

#第1步：定义一个包含数字的元组
number_tupleA =(1,2,3,4,5)

#对元组的元素做更新操作
number_tupleA[0] = 10

#执行后会报错如下：
Traceback (most recent call last):
File "test.py", line 4, in <module>
number_tupleA[0] = 10
TypeError: 'tuple' object does not support item assignment

函数的形参*args传入实参后，args数据类型元组

#定义一个函数，传入可变参数
def number_sum(*args):
	#打印args的数据类型
	print(f'args type :{type(args)}')
	#对元组参数做for循环打印
	for i in args:
		print(i)

#传入参数如下 执行函数
number_sum(1,2,3,4,5)
#执行结果如下：
args type :<class 'tuple'>
1
2
3
4
5

元组的切片

元组的元素索引以0开始，最后一个元素可以表示为-1。

如列表 tupleA = (1,2,3,4,5)，以下表格是元素值和索引的关系表。

元素值	1	2	3	4	5
从前面开始的索引	0	1	2	3	4
从后面开始的索引	-5	-4	-3	-2	-1

tupleA = (1, 2, 3, 4, 5)
#打印第1个元素
print(tupleA[0])
#打印结果
1

#打印最后1个元素
print(tupleA[-1])
#打印结果
5

#打印第2个到第3个元素,元素在切片时冒号后面的元素不包含
print(tupleA[1:3])
#打印结果
(2, 3)

#打印最后第3个元素到最后1个
print(tupleA[-3:])
#打印结果
(3, 4, 5)

#以2为步长打印元素
print(tupleA[::2])
#打印结果
(1, 3, 5)
#第1个到第4个，步长为2
print(tupleA[:4:2])
#打印结果
(1, 3)
#元组的反转顺序
print(tupleA[::-1])
#打印结果
(5, 4, 3, 2, 1)

元组的For循环

• 循环元组内的元素

tupleA = (1, 2, 3, 4, 5)

for i in tupleA:
	print(i)

#打印结果如下
1
2
3
4
5

• 使用len()和range()函数循环元组的index

for i in range(len(tupleA)):
	print(tupleA [i])
#打印结果如下
1
2
3
4
5

• 使用enumerate()函数遍历元组同时获取索引和元素

for i,data in enumerate(tupleA):
	print(f'索引： {i} 元素 ： {data}')
#打印结果如下
索引： 0 元素 ： 1
索引： 1 元素 ： 2
索引： 2 元素 ： 3
索引： 3 元素 ： 4
索引： 4 元素 ： 5

元组的copy功能

元组不像列表和字典，内置copy()函数；拷贝元组可以导入copy包，使用copy.copy()实现浅拷贝或者copy.deepcopy()深拷贝。但是因为元组是不可变数据，copy后的内存地址还是指向同一个对象

import copy
tupleA = (1, 2, 3, 4, 5)
#浅拷贝
tupleB= copy.copy(tupleA)
#深拷贝
tupleC= copy.deepcopy(tupleA)

#打印内对地址
print(f'tupleA 内存地址 ： {id(tupleA)}')
print(f'浅拷贝tupleB 内存地址 ： {id(tupleB)}')
print(f'深拷贝tupleC 内存地址 ： {id(tupleC)}')

#结果：内存地址都指向同一个对象
tupleA 内存地址 ： 1875134815016
浅拷贝tupleB 内存地址 ： 1875134815016
深拷贝tupleC 内存地址 ： 1875134815016

元组的合并

虽然元组不能被修改，但可以使用加号+将不同的元组进行合并或者在元组中添加元素

• 合并元组A和B为一个新元组

tupleA = (1, 2, 3, 4, 5)
tupleB = (6,7,8,9,10)
tupleC = tupleA + tupleB
print(tupleC)
#结果如下
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

• 在元组中添加元素

tupleA = (1, 2, 3, 4, 5)
tupleA += (6,)
print(tupleA)
#结果如下
(1, 2, 3, 4, 5, 6)

元组的重复扩展

使用星号*扩展元组

tupleA = (1, 2, 3, 4, 5)
#扩展4次
tupleC = tupleA * 4
print(tupleC)
#打印结果
(1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5)

元组的删除

使用del 删除元组

tupleA = (1, 2, 3, 4, 5)
del tupleA
print(tupleA)
#删除后 打印不存在的变量会正常报错
Traceback (most recent call last):
File "D:/test.py", line 31, in <module>
print(tupleA)
NameError: name 'tupleA' is not defined

元组的内置count()函数

使用tuple.count(xxx元素值) 统计xxx元素值在元组中出现的次数

tupleA = (1, 2, 3, 4, 5, 1, 3, 4, 3, 1)
print(f'数字1 在tupleA中出现的次数 {tupleA.count(1)}')
#打印结果：
数字1 在tupleA中出现的次数 3

元组的内置index()函数

使用tuple.index(xxx元素值) 统计xxx元素值在元组中出现的位置

tupleA = (1, 2, 3, 4, 5, 1, 3, 4, 3, 1)

#1、传入数字1 默认返回第一次出现的位置
print(f'数字1 在tupleA中出现的位置 {tupleA.index(1)}')
#打印结果：
数字1 在tupleA中出现的位置 0

#2、传入数字1，并从第2个切片位置开始到第6个切片位置结束，统计数字1出现的位置
print(f'数字1 在tupleA中出现的位置 {tupleA.index(1,2,6)}')
#打印结果：
数字1 在tupleA中出现的位置 5

#3、传入数字1，并从第6个切片位置开始到最后，统计数字1出现的位置
print(f'数字1 在tupleA中出现的位置 {tupleA.index(1,6)}')
#打印结果：
数字1 在tupleA中出现的位置 9

判断元素是否位于元组

使用in 或者 not in 判断

tupleA = (1, 2, 3, 4, 5, 1, 3, 4, 3, 1)
print(1 in tupleA)
#打印结果
True

print(2 not in tupleA)
#打印结果
False

共勉： 东汉·班固《汉书·枚乘传》：“泰山之管穿石，单极之绠断干。水非石之钻，索非木之锯，渐靡使之然也。”

-----指水滴不断地滴，可以滴穿石头；

-----比喻坚持不懈，集细微的力量也能成就难能的功劳。