来源：AI入门学习

作者：小伍哥

Python的元组与列表类似，元组一旦创建，元组中的数据一旦确立就不能改变，不能对元组中中的元素进行增删改操作，因此元组没有增加元素append、更新元素update、弹出元素pop等相关方法，只有简单的索引和计数的方法。

列表不能作为字典的key， 而元组可以；列表不能做为集合的项，而元组可以。列表是不可哈希unhashable的，列表元素可以被动态改变，所以没有一个固定不变的哈希值-这与集合要求的元素唯一性冲突；而元组的元素被禁止更新，其哈希值在整个生命周期都不会变化，因此可以成为集合的元素。

元组中可以包含任何数据类型，也可以包含另一个元组，如：T=（1,2,3，('a','b')）

空元组（没有元素的元组）：T=（），含1个元素的元组：T=（1，），注意有逗号,多个元素的元组：T=（1,2,3）

一、元组的创建

可以用多种方式构建元组，主要有以下四种，每个都会有相应的案例：

使用一对圆括号来表示空元组: ()

使用一个后缀的逗号来表示单元组: a, 或 (a,)

使用以逗号分隔的多个项: a, b, c or (a, b, c)

使用内置的 tuple(): tuple() 或 tuple(iterable)

'''1、使用一对圆括号来表示空元组: ()'''
num_tuple = (1, 2, 3)
'''2、使用一个后缀的逗号来表示单元组: a, 或 (a,)'''
a = 'a',
a
('a',)
type(a)
tuple
'''3、使用以逗号分隔的多个项: a, b, c or (a, b, c)'''
t = 1,2,3
t
(1, 2, 3)
type(t)
tuple
t = 1,2,3,#结尾多一个逗号也没事，一样的效果
'''4、使用内置的 tuple(): tuple() 或 tuple(iterable)'''
t = (1, 2, 3)
t = tuple([1, 2

注意：使用元组的时候，如果只有一个元素记得加上一个逗号，不然就是一条赋值语句。

#表达式 一个赋值语句
t = (1) 
#用type查看下类型，是整数类型，并不是tuple类型
type(t)
int
t = (1,) #加逗号元组

二、元组的方法

由于元组并不能够像列表一样修改，因此元组并没有特别多的方法，就两个方法，count和index。

print(dir(tuple))
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', 
'__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', 
'__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', 
'__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', 
'__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', 
'__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', 
'__subclasshook__', 'count', 'index']

1、index

作用：tuple的index方法:获取指定元素的下标(就近原则，从左往右，找到第一个就结束)

用法：index(self, value, start=None, stop=None)

参数:

• value-待查询下标的元素
• start-查询起始下标
• stop-查询终止下标(查询到stop前一个下标)

t=('s','a','a','r',5)
t.index('r')
3
t.index(5)
4
# index方法：根据元素找到其位置
t = (1, 2, 3, 1, 2)
t.index(1, 2)  # 寻找第2个元素1的位置

2、count

作用：获取指定元素在元组中出现的次数

用法：count(self, value)

参数：value-待查询出现次数的元素

t.count('a')
2
t.count(5)
1

3、其他操作

先生成两个元组备用

s1=(1,2,3) 
s2=('a','b','c')

1）拼接生成新元组

'''拼接生成新元组''' 
s1+s2
(1, 2, 3, 'a', 'b', 'c')
s1.__add__(s2) 
(1, 2, 3, 'a', 'b', 'c')

2）是否包含

'''是否包含'''
2 in s1
True 
s1.__contains__('a') 
False
s2.__contains__('a') 
True

3）获取元素

'''获取元素'''
s1[0]
1 
s2.__getitem__(0) 
'a'

4）获取长度

'''获取长度 '''
len(s1)
3
s1.__len__()
3

5）重复拼接

'''重复拼接'''
s1*3
(1, 2, 3, 1, 2, 3, 1, 2, 3)

6）删除元组

元祖中的元素值不可以修改和删除，但是我们可以使用 del 关键字删除整个元组。

t= ("a", "b", "c")
del t
t
name 't' is not defined

7）最大最小值

t= (10, 22, 0, 15, 40)
max(t)
40
min(t)
0

三、命名元组

对于元组，这个特性，我认为，才是元组存在的意义所在。只讲命名元组，可能不太好理解。如果称之为带字段名的记录，你可能就清楚了。

这里举个例子，但是实现带字段名，需要另一个库（collections）的支持，你需要导入它。

from collections import namedtuple
#生成一个City类
City = namedtuple("City", "name country polulation coordinates")
#实例化
tokyo = City("Tokyo", 'JP', '36.93', ('35.68','139,69'))
print(tokyo)
City(name='Tokyo', country='JP', polulation='36.93', coordinates=('35.68', '139,69'))
print(tokyo.name)
Toky

看着有点像字典，是不是，但是他不是字典（获取数值的方法也与字典不同），字典是可变。元组在创建后，就无法再对其进行修改。这在某个程度上说明元组适合存放那些无需修改的数据。比如上面的，地名，国家，经纬度。

除了上面的用法之处，这里还要介绍一些元组自己专有的属性。

# 打印字段名
print(City._fields)
('name', 'country', 'polulation', 'coordinates')
# 生成新实例
LatLong = namedtuple('LatLong', 'lat long')
Xiamen_tuple = ('Xiemen', 'China', '40,54', LatLong(24.26,118.03))
Xiamen = City._make(Xiamen_tuple)
print(Xiamen)
City(name='Xiemen', country='China', polulation='40,54', coordinates=(24.26, 118.03))
# 将具名元组转为OrderDict
Xiamen_dict = Xiamen._asdict()
print(Xiamen_dict)
OrderedDict([('name', 'Xiemen'), ('country', 'China'), ('polulation', '40,54'), ('coordinates', LatLong(lat=24.26, long=118.03))])

总结一下，元组是一种很强大的可以当作记录来用的数据类型，这才是他存在的价值和意义所在。而为人所熟知的，它的第二个角色才是充当一个不可变的列表。（以上都是个人看法，如有不同见解，欢迎留言讨论）

四、与列表的比较

类似的问题， 建议移步 StackOverflow 或者 python doc。

https://stackoverflow.com/questions/626759/whats-the-difference-between-lists-and-tuples

https://docs.python.org/zh-cn/3/library/stdtypes.html#sequence-types-list-tuple-range

翻译部分观点如下：

1、Tuples are immutable, lists are mutable.

元组是不可变的， 而列表是可变的。

2、Tuples are heterogeneous data structures, lists are homogeneous sequences. Tuples have structure, lists have order.

元组通常由不同的数据，而列表是相同类型的数据队列。元组表示的是结构，而列表表示的是顺序。举个例子来讲：当你想记录棋盘上一个子的坐标时， 应该使用元组; 当你想记录棋盘上所有的子的坐标（一系列相同的数据）时，应该使用列表。

# 表示一个点
point = (1, 2)
# 表示一系列点
points = [(1, 2), (1, 3), (4, 5)]

3、 You can't use list as a dictionary identifier.

你不能将列表当作字典的key， 而元组可以。

a = (1, 2)
b = [4, 5]
c = {a: 'start point'} # OK  {(1, 2): 'start point'}
c = {b: 'end point'} # Error

4、Due to the smaller size of a tuple operation with it a bit faster but not that much to mention about until you have a huge amount of elements.

由于元组支持的操作比列表小， 所以元组会比列表稍稍快上那么一丢丢。但是除非你有巨量的数据要去处理，否者这一点不需要特别强调。