Python 元组

本文最后更新于：2023年12月5日下午

有些 Python 入门教程把元组称为“不可变列表”，然而这并没有完全概括元组的特点。除了用作不可变的列表，它还可以用于没有字段名的记录。

元组

元组和记录

元组其实是对数据的记录：元组中的每个元素都存放了记录中一个字段的数据，外加这个字段的位置。正是这个位置信息给数据赋予了意义。

lax_coordinates = (33.9425, -118.408056)
city, year, pop, chg, area = ('Tokyo', 2003, 32450, 0.66, 8014)
traveler_ids = [('USA', '31195855'), ('BRA', 'CE342567'), ('ESP', 'XDA205856')]

for passport in sorted(traveler_ids):
	print('%s/%s' % passport)

元组拆包

上述示例中，我们把元组 (‘Tokyo’, 2003, 32450, 0.66, 8014) 里的元素分别赋值给变量 city、year、pop、chg 和 area，而这所有的赋值我们只用一行声明就写完了。同样，在后面一行中，一个 % 运算符就把 passport 元组里的元素对应到了 print 函数的格式字符串空档中。这两个都是对元组拆包的应用。

可以交换变量值

1	`b, a = a, b`

可以用 * 运算符拆开对象

1 2	`t = (20, 8) divmod(*t)`

在元组拆包中使用 * 也可以帮助我们把注意力集中在元组的部分元素上。

a, b, *rest = range(5)

-->
a, b, rest
(0, 1, [2, 3, 4])

是这个变量可以出现在赋值表达式的任意位置：

a, *body, c, d = range(5)

-->
a, body, c, d
(0, [1, 2], 3, 4)

*head, b, c, d = range(5)

-->
head, b, c, d
([0, 1], 2, 3, 4)

嵌套元组拆包

接受表达式的元组可以是嵌套式的，例如 (a, b, (c, d))。只要这个接受元组的嵌套结构符合表达式本身的嵌套结构，Python 就可以作出正确的对应。

metro_areas = [ ('Tokyo','JP',36.933,(35.689722,139.691667)), ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)), ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)), ('New York-Newark', 'US', 20.104, (40.808611, -74.020386)), ('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833)), ]

具名元组

collections.namedtuple 是一个工厂函数，它可以用来构建一个带字段名的元组和一个有名字的类——这个带名字的类对调试程序有很大帮助。

from collections import namedtuple
City = namedtuple('City', 'name country population coordinates')
tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))

-->
tokyo 
City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722, 139.691667))

tokyo.population
36.933

tokyo[1]
'JP'

创建一个具名元组需要两个参数，一个是类名，另一个是类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象，或者是由空格分隔开的字段名组成的字符串。
存放在对应字段里的数据要以一串参数的形式传入到构造函数中（注意，元组的构造函数却只接受单一的可迭代对象）。
你可以通过字段名或者位置来获取一个字段的信息。

除了从普通元组那里继承来的属性之外，具名元组还有一些自己专有的属性。其中几个最有用的：_fields 类属性、类方法 _make(iterable) 和实例方法 _asdict()。

City._fields
--> ('name', 'country', 'population', 'coordinates')

LatLong = namedtuple('LatLong', 'lat long')
delhi_data = ('Delhi NCR', 'IN', 21.935, LatLong(28.613889, 77.208889))
delhi = City._make(delhi_data)
delhi._asdict()
--> OrderedDict([('name', 'Delhi NCR'), ('country', 'IN'), ('population', 21.935), ('coordinates', LatLong(lat=28.613889, long=77.208889))])

for key, value in delhi._asdict().items(): 
	print(key + ':', value)
--> 
name: Delhi 
NCR country: IN 
population: 21.935 
coordinates: LatLong(lat=28.613889, long=77.208889)

_fields 属性是一个包含这个类所有字段名称的元组。
用 _make() 通过接受一个可迭代对象来生成这个类的一个实例，它的作用跟 City(*delhi_data) 是一样的。
_asdict() 把具名元组以 collections.OrderedDict 的形式返回，我们可以利用它来把元组里的信息友好地呈现出来。

不可变列表

除了跟增减元素相关的方法之外，元组支持列表的其他所有方法。还有一个例外，元组没有 reversed 方法，但是这个方法只是个优化而已，reversed(my_tuple) 这个用法在没有 reversed 的情况下也是合法的。

	list	tuple
`s.__add__(s2)`	√	√	s + s2，拼接
`s.__iadd__(s2)`	√		s += s2，就地拼接
`s.append(e)`	√		在尾部添加一个新元素
`s.clear()`	√		删除所有元素
`s.__contains__(e)`	√	√	s 是否包含 e
`s.copy()`	√		列表的浅复制
`s.count(e)`	√	√	e 在 s 中出现的次数
`s.__delitem__(p)`	√		把位于 p 的元素删除
`s.extend(it)`	√		把可迭代对象 it 追加给 s
`s.__getitem__(p)`	√	√	s[p]，获取位置 p 的元素
`s.__getnewargs__()`	√		在 pickle 中支持更加优化的序列化
`s.index(e)`	√	√	在 s 中找到元素 e 第一次出现的位置
`s.insert(p, e)`	√		在位置 p 之前插入元素e
`s.__iter__()`	√	√	获取 s 的迭代器
`s.__len__()`	√	√	len(s)，元素的数量
`s.__mul__(n)`	√	√	s * n，n 个 s 的重复拼接
`s.__imul__(n)`	√		s *= n，就地重复拼接
`s.__rmul__(n)`	√	√	n * s，反向拼接 *
`s.pop([p])`	√		删除最后或者是（可选的）位于 p 的元素，并返回它的值
`s.remove(e)`	√		删除 s 中的第一次出现的 e
`s.reverse()`	√		就地把 s 的元素倒序排列
`s.__reversed__()`	√		返回 s 的倒序迭代器
`s.__setitem__(p,e)`	√		s[p] = e，把元素 e 放在位置p，替代已经在那个位置的元素
`s.sort([key],[reverse])`	√		就地对 s 中的元素进行排序，可选的参数有键（key）和是否倒序（reverse）