day07-元祖

标签：tuple 元素 day07 列表 print my 元祖

元组 (Tuple) 是一个有序、不可变的数据类型，与列表很相似，但元组中的元素不允许被修改，因此元组也被称作只读列表 元组使用小括号() ，元素之间使用逗号 ， 分隔，元组中的元素可以是字符串、数字、列表、元组等其他数据类型。

1、创建元祖

使用（）创建

tuple = (1, 2, 3, 4, 5)  # 创建包含整数元素的元祖
tuple = ("1", "2", "3", "4", "5")  # 创建包含字符串元素的元祖
tuple = ({}, {})  # 创建包含字典元素的元祖
tuple = ([1, 2, 3], [4, 5, 6])  # 创建包含列表的元祖
tuple = (True, False)  # 创建包含布尔值的元祖
tuple = (1, "2", {"a": 1}, (2), True)  # 创建包含不同类型元素的元祖

  使用tuple() 函数创建 tuple() 是一个内置函数，用于将可迭代对象转换为元祖。 其中，可迭代对象可以是字符串、元组、集合、字典等。tuple() 函数将可迭代对象的每个元素收集起来，并返回一个新的元祖。

string = "Hello"
my_tuple = tuple(string)  # 将字符串转换为元组

my_list = [1, 2, 3]
my_tuple = tuple(my_list)  # 将列表转换为元祖

my_set = {1, 2, 3}
my_tuple = tuple(my_set)  # 将集合转换为元祖

my_dict = {'a': 1, 'b': 2, 'c': 3}
my_tuple = tuple(my_dict)  # 将字典的键转换为元祖

同理，那如果我们定义一个空元祖怎么实现呢？ 像列表那样，list = [ ] 表示一个空列表，那我们同样用元祖实现可以吗？

my_list = []
print(type(my_list))

my_tuple = ()
print(type(my_tuple))

# 输出结果
<class 'list'>
<class 'tuple'>

是没问题的 那我们在深入一下，[1]表示列表还是什么，(1)表示元祖还是什么

my_list = [1]
print(type(my_list))

my_tuple = (1)
print(type(my_tuple))

# 输出结果
<class 'list'>
<class 'int'>

出现问题了啊，[1]是列表没问题，但是(1)代表整数 问题在于定义单元素元组，需要在元素后面添加逗号，需要告诉Python这是一个元祖类型的

my_tuple = (1,)
print(type(my_tuple))

# 输出结果
<class 'tuple'>
 
那我们在深入一下，如果只有逗号没有（），他还是元祖类型吗？
my_tuple = 1, 2, 3, 4, 5
print(type(my_tuple))

# 输出结果
<class 'tuple'>

是元祖的类型，这源自于元祖的特性——任何无符号的对象，以逗号分割，默认被视为元组   我们在创建空元祖的时候，可以使用tuple()函数来创建

my_tuple = tuple()
print(type(my_tuple))

# 输出结果
<class 'tuple'>

2、元祖的运算（与列表相似）

符号	说明
+	元祖连接
*	重复元素
in/not in	成员判断
= != > <	元祖比较

加号运算符+可以将两个元祖连接成一个新的元祖。

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
print(tuple1 + tuple2)

# 输出结果
(1, 2, 3, 4, 5, 6)

  乘号运算符*可以将元祖重复指定次数

my_tuple = (1, 2, 3)
print(my_tuple * 3)

# 输出结果
(1, 2, 3, 1, 2, 3, 1, 2, 3)

  使用关键字 in 和 not in 可以判断元素是否存在于元祖中

tuple = (1, 2, 3, 4, 5)
print(3 in tuple)  # 输出：True
print(2 not in tuple)  # 输出：False

  元祖可以进行比较运算符的比较，包括等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）、小于等于（<=）

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 3)
print(tuple1 == tuple2)  # 输出：True
print(tuple1 != tuple2)  # 输出：False
print(tuple1 > tuple2)  # 输出：False
print(tuple1 < tuple2)  # 输出：False

3、元祖切片

我们可以通过下标获取列表的某个元素

# 元祖切片
tuple = (1, 2, 3, 4, 5)  # 一共6个字符

print(tuple[0])  # 取第1个字符
print(tuple[1])  # 取第2个字符
print(tuple[5])  # 取第6个字符

print(tuple[-1])  # 取倒数第1个元素
print(tuple[-3])  # 取倒数第4个元素

# 输出结果
1
2
IndexError: list index out of range
5
3

取不到元素时会报：索引越界  

my_tuple[start:end:step]

• start：切片的起始索引（包含），默认为 0。
• end：切片的结束索引（不包含），默认为列表的长度。
• step：切片的步长（可选），表示每次取元素的间隔，默认为 1。

对了，如果我们在切片操作中，如果不指定起始位置，默认为索引0（元祖的开头）。如果不指定终止位置，默认为元祖的长度（元祖的结尾），元祖的长度可以用len(tuple)来得到

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

print(my_tuple[:])  # 取全部元素
print(my_tuple[0:])  # 取全部元素
print(my_tuple[:len(my_tuple)])  # 取全部元素
print(my_tuple[2:])  # 取第3个元素之后的所有元素
print(my_tuple[-4:])  # 取倒数第4个元素到结my_tuple
print(my_tuple[1:5])  # 取第2个元素到第4个元素
print(my_tuple[0:-3])  # 取第1个元素到倒数第3个元素
print(my_tuple[1:-1])  # 取第2个元素到倒数第2个元素

# 输出结果
(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)
(1, 2, 3, 4, 5)
(3, 4, 5)
(2, 3, 4, 5)
(2, 3, 4, 5)
(1, 2)
(2, 3, 4)

  高级的例子

my_tuple = (1, 2, 3, 4, 5, 6)
print(my_tuple[::1])  # 取全部元素

print(my_tuple[::-1])  # 倒序取所有元素
print(my_tuple[::2])  # 取所有元素，每两个取一个
print(my_tuple[1:6:2])  # 取第2个字符到第5个元素，每两个取一个

# 输出结果
(1, 2, 3, 4, 5, 6)
(6, 5, 4, 3, 2, 1)
(1, 3, 5)
(2, 4, 6)

  有个思考，我们通过切片后的元祖跟原来的元祖还有关系吗？ 我们来验证下：

my_tuple = (1, 2, 3, 4, 5, 6)
my_tuple2 = my_tuple[::1]  # 取全部元素

print(my_tuple, id(my_tuple))
print(my_tuple2, id(my_tuple2))

# 输出结果
(1, 2, 3, 4, 5, 6) 2494334591328
(1, 2, 3, 4, 5, 6) 2494334591328

查看内存地址，发现内存是一样的，元祖其实并没有被改变，因为元祖是不可变的数据类型，相反的如果是列表，切片操作会生成一个新的副本，列表是可变的

4、修改元祖、删除元祖

修改元祖 元祖既然是不可变数据类型，那我们可以修改元祖吗？

my_tuple = (1, 2, 3, 4, 5, 6)
my_tuple[0] = 2  # 修改元祖第一个元素

# 输出结果
TypeError: 'tuple' object does not support item assignment

报错：元祖元素不允许被修改 那我们就想修改元素怎么操作呢？ 可以把元祖转换成可变类型比如列表，修改完元素后再转换为元祖数据类型

my_tuple = (1, 2, 3)
my_list = list(my_tuple)  # 将元组转换为列表
my_list[0] = 4  # 修改列表中的第一个元素
my_tuple = tuple(my_list)  # 将列表转换回元组

print(my_tuple)  # 输出: (4, 2, 3)

  还有一种情况，元祖内包含可变的数据类型，我们虽然不能修改元祖，但是元祖元素为可变类型时则支持修改。

my_tuple = ([1, 2, 3], 4, 5)
my_tuple[0][0] = 10  # 修改元组中的列表的第一个元素

print(my_tuple)  # 输出: ([10, 2, 3], 4, 5)

删除元祖 我们先删除列表看看

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
del my_list[0]  # 删除第一个元素
print(my_list)

del my_list  # 删除整个列表

# 输出结果
[2, 3, 4, 5, 6, 7, 8, 9, 10]

  删除列表删除其中的元素或者删除整个列表都是可以的   我们删除元祖试下

my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
del my_tuple[0]  # 删除第一个元素

# 报错了
TypeError: 'tuple' object doesn't support item deletion

说明元祖的元素是不能被删除的   不过我们可以删除整个元祖

my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
del my_tuple  # 删除整个元祖

5、元祖的基本函数

函数名	含义
len(tuple)	返回元祖元素个数
max(tuple)	返回元祖中最大的元素
min(tuple)	返回元祖中最小的元素

my_tuple = (1, 4, 3, 11, 7, 8, 15)

print(len(my_tuple))  # 返回元祖长度
print(max(my_tuple))  # 返回元祖最大值
print(min(my_tuple))  # 返回元祖最小值

# 输出结果
7
15
1

max函数的深度用法我们在列表中已经使用过，所以现在我们不再深究

6、元祖的常用函数

元祖不像列表，没有那么多的内置方法，我们常用的以下这两个：

统计个数	tuple.count(element)	返回指定元素在元祖中出现的次数
获取元素下标	tuple.index(element, start=0, end=len(list))	返回元祖中第一个匹配指定元素的索引。
排序&&翻转&&复制	tuple.sort(key=None, reverse=False)	对元祖进行排序，可以指定排序关键字和是否降序排序
	tuple.reverse()	反转元祖中的元素顺序
	tuple.copy()	返回元祖的一个浅拷贝副本

# 元祖统计个数
tuple = [10, 2, 3, 4, 5, 10, 7, 8, 9, 10]
print(tuple.count(10))


# 元祖获取元素下标
tuple = (10, 2, 3, 4, 5, 10, 7, 8, 9, 10)

print(tuple.index(10))  # 元素多个，只返回第一个元素的下标0

# 输出结果
3
0

day07练习

初级 1.两种方式创建一个空元祖 2.声明一个元祖，tuple = (18, ['name', 'hu'], '你好') 3.计算2题中元祖的长度 4.修改2题中元素'hu' 修改为'ming'   中级 1.有以下两个元祖，tup1 = (1,3,5,7)，tup2 = (2,4,6,8) 1) 打印输出两个元祖 2) 将tup1 与tup2 合并成一个新元祖tup，并打印输出新元祖 3) 将2中的新元祖tup按照从小到大的顺序排序 4) 求新元祖tup的长度和平均值 5) 求新元祖tup的最大值和最小值 6) 求新元祖tup的第一项和最后一项 7）统计0在新元祖tup中出现的次数 2.有元祖tup = (5, 2, 9, 2, 1, 4, 3, 7, 5)，找出元祖中最大元素的索引值  

标签：tuple,元素,day07,列表,print,my,元祖
From： https://www.cnblogs.com/nuomituan/p/17832190.html