FluentPython 元组不仅仅是不可变的列表

元组

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

如果只把元组理解为不可变的列表，那其他信息——它所含有的元素的总数和它们的位置——似乎就变得可有可无。但是如果把元组当作一些字段的集合，那么数量和位置信息就变得非常重要了。

>>> 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)
...
BRA/CE342567
ESP/XDA205856
USA/31195855
>>> for country, _ in traveler_ids:   #注意下划线的功能，看下节拆包
...     print(country)
USA
BRA
ESP

元组拆包

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

元组拆包用法_os.path.split()

>>> import os
>>> _, filename = os.path.split('/home/qfyu/.ssh/idrsa.pub') #注意“_”的用法
>>> filename
'idrsa.pub'
>>>

在进行拆包的时候，我们不总是对元组里所有的数据都感兴趣，_ 占位符能帮助处理这种情况
在元组拆包中使用 * 也可以帮助我们把注意力集中在元组的部分元素上。用*来处理剩下的元素在 python 中，函数用 *args 来获取不确定数量的参数算是一种经典写法了

举例说明;

>>> a,b,*rest = range(5)
>>> a,b,rest
(0, 1, [2, 3, 4])  # 剩下的元素存在列表中
>>> a,b,*rest = range(3)
>>> a,b,rest
(0, 1, [2])
>>> a,b,*rest = range(2)
>>> a,b,rest
(0, 1, [])
>>>

在平行赋值中，* 前缀只能用在一个变量名前面，但是这个变量可以出现在赋值表达式的任意位置：

>>> 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))

metro_areas = [
('Tokyo','JP',36.933,(35.689722,139.691667)), # ➊每个元组内有 4 个元素，其中最后一个元素是一对坐标。
('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)),
]
print('{:15} | {:^9} | {:^9}'.format('', 'lat.', 'long.'))
fmt = '{:15} | {:9.4f} | {:9.4f}'
for name, cc, pop, (latitude, longitude) in metro_areas: # ➋ 我们把输入元组的最后一个元素拆包到由变量构成的元组里，这样就获取了坐标。
if longitude <= 0: 
print(fmt.format(name, latitude, longitude))

上面示例的输出是这样的：
                | lat.      | long.
Mexico City     | 19.4333   | -99.1333
New York-Newark | 40.8086   | -74.0204
Sao Paul        | -23.5478  | -46.6358

具名元组 namedtuple

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

这样新建 Card 类的：

Card = collections.namedtuple('Card', ['rank', 'suit'])

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

列表或元组的方法或属性

                            列表   元组
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）