目录:

1. 元祖的基本概念
2. 创建元祖
3. 将列表转化为元组
4. 查询元组
5. 更新元组
6. 删除元组

1. 元祖的基本概念

• 元祖可以理解为,不可变的列表
• 元祖使用小括号括起所有序列元素(元素1,元素2, ......), 列表使用中括号[元素1,元素2, .......].
• 元组被称为只读列表，数据可被查询，但不能被修改.
• 对于一些不想被修改的数据，可以用元组来保存
• 元组中的元素是不允许删除的，但可以使用del语句来删除整个元组
• 元组没有列表中的增、删、改的操作，只有查的操作

tuple 不可变的好处

相对于 list 而言，tuple 是不可变的，这使得它可以作为 dict 的 key，或者扔进 set 里，而 list 则不行。
tuple 放弃了对元素的增删（内存结构设计上变的更精简），换取的是性能上的提升：创建 tuple 比 list 要快，存储空间比 list 占用更小。所以就出现了“能用 tuple 的地方就不用 list”的说法。
多线程并发的时候，tuple 是不需要加锁的，不用担心安全问题，编写也简单多了。

利用tuple,函数返回（return）多个值

之所以元组这么受欢迎，其实最关键的一点是它的语法的灵活和便捷性，提高了编程体验。其中最大的一个特性就是使函数可以返回多个值，这个特性很常用.
由于在语法上，返回一个tuple是可以省略括号的，而多个变量可以同时接收一个tuple，按位置赋给对应的值。
Python的函数返回多值时，其实就是返回一个tuple。

2. 创建元祖

2.1 创建普通元祖

创建一个元组只需使用逗号分隔值放入小括号的一个序列。

tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5 )

2.2 创建空元祖

空的元组写成两个不含任何东西的小括号

tup1 = ();  

2.3 创建单元素元祖

要编写一个包含单个值的元组，必须包含一个逗号，即使只有一个值(这是规范写法)

tuple1 = (3,)   # 创建元组 （只有一个元素时，在元素后面加上逗号）
tuple2 = (3)    #不加逗号，会被当成其他数据类型处理
print(type(tuple1))
print(type(tuple2))

运行结果如下:

<class 'tuple'>
<class 'int'>

3. 将列表转化为元组

元组与列表可以相互转换，python内置的tuple()函数接受一个列表，可返回一个包含相同元素的元组。

list()函数接受一个元组并返回一个列表。

从二者性质上看，tuple()相当于冻结一个列表，而list()相当于解冻一个元组。

list_name = ["python book","Mac","bile","kindle"]
tup = tuple(list_name) # 将列表转为元组
print(type(list_name))  # 查看list_name类型，并将结果打印出来
print(type(tup))    #  查看tup类型，并将结果打印出来
print (tup) 

运行结果:

<class 'list'>
<class 'tuple'>
('python book', 'Mac', 'bile', 'kindle')

4. 查询元组

# (1)打印索引为0的元素
tup = (1, 2, ['a', 'b', 'c'], 'd', 'e', ('gu', 'tang'))    
print ("tup[0] =",tup[0])    #输出结果: tup[0] = 1
#(2)从索引为1到最后一个元素
print ("tup[1:] =",tup[1:])     #输出结果:tup[1:] = (2, ['a', 'b', 'c'], 'd', 'e', ('gu', 'tang'))
# (3)到倒第二个元素但不包含第二个
print ("tup[:-1] =",tup[:-1])   #输出结果: tup[:-1] = (1, 2, ['a', 'b', 'c'], 'd', 'e')
# (4)等价于tup[1:]   从左到右一个个去取，步长为1
print ("tup[1::1] =",tup[1::1])    #输出结果 tup[1::1] = (2, ['a', 'b', 'c'], 'd', 'e', ('gu', 'tang'))
#(5)从左到右隔一个去取  步长为2
print ("tup[1::2] =",tup[1::2])    #输出结果: tup[1::2] = (2, 'd', ('gu', 'tang'))
# (6)反向输出 步长为1
print ("tup[::-1]",tup[::-1])  #输出结果: tup[::-1] (('gu', 'tang'), 'e', 'd', ['a', 'b', 'c'], 2, 1)
# (7)反向输出 步长为2（隔一个去取））
print ("tup[::-2]",tup[::-2])  #输出结果: tup[::-2] (('gu', 'tang'), 'd', 2)

5. 更新元组

元组是不可变的，这意味着我们无法更新或更改元组元素的值。

[报错:] 当试图修改元组内元素的值时，导致Python返回类型错误消息。由于试图修改元组的

操作是被禁止的，因此Python指出不能给元组的元素赋值:

dimensions = (200, 50)
dimensions[0] = 250
print(dimensions)

运行报错:

Traceback (most recent call last):
  File "/home/python/Documents/note.py", line 28, in <module>
    dimensions[0] = 250
TypeError: 'tuple' object does not support item assignment

针对这种不可变的数据类型,我们想更新它,可以采用切片,再利用运算符拼接的方式来对它进行更新:

tuple_1 = ("星期一","星期二","星期四")
tuple_1 = tuple_1[ :2] + ("星期三",)+tuple_1[2:] #"星期三后边一定要加逗号"
print(tuple_1)

运行结果:('星期一', '星期二', '星期三', '星期四')

[注意:] ("星期三",)后边的逗号,一定不能忘记, 不然这个字段会被认定为其他数据来处理,运行时就会报错,因为元祖只能和元祖拼接:

报错:

tuple_1 = tuple_1[ :2] + ("星期三")+tuple_1[2:]
TypeError: can only concatenate tuple (not "str") to tuple

</br>

6. 删除元组

元祖中的元素不允许删除，但可以使用del语句删除整个元祖

删除元组内的元素(非法,会报错)

tuple3 = (11,22,33,44)
del tuple3[0]
print(tuple3)

运行后报错:

TypeError: 'tuple' object doesn't support item deletion

和上边的更新元组的方法一样, 我们也可以用切边和运算操作符减号-来删除原有的元祖里的元素

删除整个元祖

tuple3 = (11,22,33,44)
del tuple3
print(tuple3)

运行后也会报错, 因为内存已删除: (提示未定义)

NameError: name 'tuple3' is not defined

[注] - 引发异常。这是因为在del tuple3之后，元组不再存在。

</br>

------------ 元组的基本操作------------

元组响应+和*运算符很像字符串; 它们执行连接和重复操作，但结果是一个新的元组，而不是一个字符串。

事实上，元组中类似字符串操作和使用的所有常规序列操作都有作了讲解.

</br>

------------元组的索引，切片和矩阵------------

由于元组是序列，索引和切片的工作方式与列表的工作方式相同.

假设输入以下语句：Tuple =("C++", "Java", "Python'"):

</br>

------------Python中内置的元组函数功能------------

</br>

参考资料:

1. cnblogs: python——元组（tuple）基本操作
2. 易百教程:Python元组
3. <<Python编程: 从入门到实践>>
4. 百家号:Python中元组 tuple 到底有什么用?