Python 元组（tuple）详解
- 元组概念
- Python创建元组
- 使用 ( ) 直接创建
- 使用 tuple()函数创建元组
- Python 访问元组元素
- Python 修改元组
- Python 删除元组
- 元组和列表的区别
元组概念
元组（tuple）是 Python 中另一个重要的序列结构，和列表类似，元组也是由一系列按特定顺序排序的元素组成。
元组也可以看做是不可变的列表，通常情况下，元组用于保存无需修改的内容。
从形式上看，元组的所有元素都放在一对小括号( )中，相邻元素之间用逗号,分隔，如下所示：
(element1, element2, ... , elementn)
从存储内容上看，元组可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且在同一个元组中，元素的类型可以不同，例如：
("c.biancheng.net", 1, [2,'a'], ("abc",3.0))
在这个元组中，有多种类型的数据，包括整形、字符串、列表、元组。
另外，我们都知道，列表的数据类型是 list，那么元组的数据类型是什么呢？我们不妨通过 type() 函数来查看一下：
type( ("c.biancheng.net",1,[2,'a'],("abc",3.0)) )
<class 'tuple'>
可以看到，元组是 tuple 类型，这也是很多教程中用 tuple 指代元组的原因。
Python创建元组
使用 ( ) 直接创建
通过( )创建元组后，一般使用=将它赋值给某个变量，具体格式为：
tuplename = (element1, element2, ..., elementn)
其中，tuplename 表示变量名，element1 ~ elementn 表示元组的元素。
num = (7, 14, 21, 28, 35)
course = ("Python 教程", "http://c.biancheng.net/python/")
abc = ( "Python", 19, [1,2], ('c',2.0) )
在 Python 中，元组通常都是使用一对小括号将所有元素包围起来的，但小括号不是必须的，只要将各元素用逗号隔开，Python 就会将其视为元组，请看下面的例子：
course = "Python 教程", "http://c.biancheng.net/python/"
print(course)
运行结果为：
('Python 教程', 'http://c.biancheng.net/python/')
需要注意的一点是，当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则Python 解释器会将它视为字符串。
#最后加上逗号
a =("http://c.biancheng.net/cplus/",)
print(type(a))
print(a)
#最后不加逗号
b = ("http://c.biancheng.net/socket/")
print(type(b))
print(b
运行结果为：
<class 'tuple'>
('http://c.biancheng.net/cplus/',)
<class 'str'>
http://c.biancheng.net/socket/
你看，只有变量 a 才是元组，后面的变量 b 是一个字符串。
使用 tuple()函数创建元组
除了使用( )创建元组外，Python 还提供了一个内置的函数 tuple()，用来将其它数据类型转换为元组类型。tuple() 的语法格式如下：
tuple(data)
其中，data 表示可以转化为元组的数据，包括字符串、元组、range 对象等。
#将字符串转换成元组
2. tup1 = tuple("hello")
3. print(tup1)
4.
5. #将列表转换成元组
6. list1 = ['Python', 'Java', 'C++', 'JavaScript']
7. tup2 = tuple(list1)
8. print(tup2)
9.
10. #将字典转换成元组
11. dict1 = {'a':100, 'b':42, 'c':9}
12. tup3 = tuple(dict1)
13. print(tup3)
14.
15. #将区间转换成元组
16. range1 = range(1, 6)
17. tup4 = tuple(range1)
18. print(tup4)
19.
20. #创建空元组
21. print(tuple())
运行结果为：
('h', 'e', 'l', 'l', 'o')
('Python', 'Java', 'C++', 'JavaScript')
('a', 'b', 'c')
(1, 2, 3, 4, 5)
()
Python 访问元组元素
和列表一样，我们可以使用索引（Index）访问元组中的某个元素（得到的是一个元素的值），也可以使用切片访问元组中的一组元素（得到的是一个新的子元组）。使用索引访问元组元素的格式为：
tuplename[i]
其中，tuplename 表示元组名字，i 表示索引值。元组的索引可以是正数，也可以是负数。使用切片访问元组元素的格式为：
tuplename[start : end : step]
其中，start 表示起始索引，end 表示结束索引，step 表示步长。
1. url = tuple("http://c.biancheng.net/shell/")
2.
3. #使用索引访问元组中的某个元素
4. print(url[3]) #使用正数索引
5. print(url[-4]) #使用负数索引
6.
7. #使用切片访问元组中的一组元素
8. print(url[9: 18]) #使用正数切片
9. print(url[9: 18: 3]) #指定步长
10. print(url[-6: -1]) #使用负数切片
运行结果：
p
e
('b', 'i', 'a', 'n', 'c', 'h', 'e', 'n', 'g')
('b', 'n', 'e')
('s', 'h', 'e', 'l', 'l')
Python 修改元组
元组是不可变序列，元组中的元素不能被修改，所以我们只能创建一个新的元组去替代旧的元组。
例如，对元组变量进行重新赋值：
1. tup = (100, 0.5, -36, 73)
2. print(tup)
3. #对元组进行重新赋值
4. tup = ('Shell 脚本',"http://c.biancheng.net/shell/")
5. print(tup)
运行结果为：
(100, 0.5, -36, 73)
('Shell 脚本', 'http://c.biancheng.net/shell/')
另外，还可以通过连接多个元组（使用+可以拼接元组）的方式向元组中添加新元素，例如：
1. tup1 = (100, 0.5, -36, 73)
2. tup2 = (3+12j, -54.6, 99)
3. print(tup1+tup2)
4. print(tup1)
5. print(tup2)
运行结果为：
(100, 0.5, -36, 73, (3+12j), -54.6, 99)
(100, 0.5, -36, 73)
((3+12j), -54.6, 99)
你看，使用+拼接元组以后，tup1 和 tup2 的内容没法发生改变，这说明生成的是一个新的元组。
Python 删除元组
当创建的元组不再使用时，可以通过 del 关键字将其删除，例如：
1. tup = ('Java 教程',"http://c.biancheng.net/java/")
2. print(tup)
3. del tup
4. print(tup)
运行结果为：
('Java 教程', 'http://c.biancheng.net/java/')
Traceback (most recent call last):
File "C:\Users\mozhiyan\Desktop\demo.py", line 4, in <module>
print(tup)
NameError: name 'tup' is not defined
Python 自带垃圾回收功能，会自动销毁不用的元组，所以一般不需要通过 del 来手动删除。
元组和列表的区别
元组和列表（list）的不同之处在于：
列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。
元组和列表最大的区别就是，列表中的元素可以进行任意修改，就好比是用铅笔在纸上写的字，写错了还可以擦除重写；而元组中的元素无法修改，除非将元组整体替换掉，就好比是用圆珠笔写的字，写了就擦不掉了，除非换一张纸。
可以理解为，tuple 元组是一个只读版本的 list 列表。需要注意的是，这样的差异势必会影响两者的存储方式，我们来直接看下面的例子：
>>> listdemo = []
>>> listdemo.__sizeof__()
40
>>> tupleDemo = ()
>>> tupleDemo.__sizeof__()
24
可以看到，对于列表和元组来说，虽然它们都是空的，但元组却比列表少占用 16 个字节，这是为什么呢？
事实上，就是由于列表是动态的，它需要存储指针来指向对应的元素（占用 8 个字节）。另外，由于列表中元素可变，所以需要额外存储已经分配的长度大小（占用 8 个字节）。但是对于元组，情况就不同了，元组长度大小固定，且存储元素不可变，所以存储空间也是固定的。
既然列表这么强大，还要元组这种序列类型干什么？
通过对比列表和元组存储方式的差异，我们可以引申出这样的结论，即元组要比列表更加轻量级，所以从总体上来说，元组的性能速度要优于列表。
另外，Python 会在后台，对静态数据做一些资源缓存。通常来说，因为垃圾回收机制的存在，如果一些变量不
被使用了，Python 就会回收它们所占用的内存，返还给操作系统，以便其他变量或其他应用使用。
但是对于一些静态变量（比如元组），如果它不被使用并且占用空间不大时，Python 会暂时缓存这部分内存。
这样的话，当下次再创建同样大小的元组时，Python 就可以不用再向操作系统发出请求去寻找内存，而是可以直接分配之前缓存的内存空间，这样就能大大加快程序的运行速度。
当然，如果你想要增加、删减或者改变元素，那么列表显然更优。因为对于元组来说，必须得通过新建一个元组来完成。
总的来说，元组确实没有列表那么多功能，但是元组依旧是很重要的序列类型之一，元组的不可替代性体现在
以下这些场景中：
- 元组作为很多内置函数和序列类型方法的返回值存在，也就是说，在使用某些函数或者方法时，它的返回值会
元组类型，因此你必须对元组进行处理。 - 元组比列表的访问和处理速度更快，因此，当需要对指定元素进行访问，且不涉及修改元素的操作时，建议使
用元组。 - 元组可以在映射（和集合的成员）中当做“键”使用，而列表不行
文章出处登录后可见！
