元组
Tuple Docstring:
tuple() -> empty tuple ；
tuple(iterable) -> tuple initialized from iterable's items
1. 元组的优点 (相比于列表)
1.通常将元组用于不同的数据类型，将列表用于相同（或相似）的数据类型。
2.由于元组不可变，所以对元组的迭代比列表要快（性能略有提升）。
3.元组可以用作字典的 key，而列表不行（因为字典的 key 必须是不可变的，而元组本身就是不可变的）。
4.如果数据不需要更改，将其作为元组来实现可以确保“写保护”。
2. 元组的定义
Python 中，元组由内置的 tuple 类型定义。
创建元组，需要将所有元素放在圆括号（()）内，以逗号（,）分隔；
构造只有一个元素的元组比较特殊，括号内只包含一个元素是不够的，还需要在元素后添加一个逗号；
t=(1) # 改变优先级 int/str/float ；
t=(1,) # 元祖类型；
元组中的元素可以有任意多个，并且可以是不同类型的（例如：数字、字符串、列表等）：
>>> t = () # 空元组
>>>
>>> t = ('P', 'y') # 字符串类型元组
>>>
>>> t = (1, 5.5, 'Python') # 混合类型元组
>>>
>>> t = (6, 'Hello', ('P', 'y')) # 嵌套元组
>>>
>>> t = 1, 5.5, 'Python' # 元组可以没有括号，称为元组包装
>>> t
(1, 5.5, 'Python')
>>>
>>> a, b, c = t # 元组解包
>>> a
1
>>> b
5.5
>>> c
'Python'
加法和乘法仍然是可以;
t2 =(2,)
t2+t2 | (2, 2)
t2*3 | (2, 2, 2)
3.更改元组
元组是不可变的，也就是说，元组中的元素在被赋值后不能改变。
但是，如果元素本身是一个可变数据类型（例如：列表、字典），那么其嵌套项可以被改变：
>>> t = (6, 'Hello', ['P', 'y'])
>>>
>>> t[0] = 10 # 不能改变元素
...
TypeError: 'tuple' object does not support item assignment
>>>
>>> t[2][1] = 's' # 可变元素内部可以被改变
>>> t
(6, 'Hello', ['P', 's'])
4.删除元组
如上所述，不能更改元组中的元素，这也意味着无法删除元组中的元素。
但如果元素本身是一个可变数据类型，那么其嵌套项是可以被删除的，而且使用关键字 del 可以删除整个元组：
>>> t = (6, 'Hello', {'name':'Waleon', 'age':18})
>>>
>>> del t[2] # 不能删除元素
...
TypeError: 'tuple' object doesn't support item deletion
>>>
>>> del t[2]['name'] # 可变元素的嵌套项可以被删除
>>> t
(6, 'Hello', {'age': 18})
>>>
>>> del t # 可以删除整个元组
>>> t
...
NameError: name 't' is not defined
2.1 元组方法
元组中的方法相对较少，可以通过 dir() 来查看方法列表：
>>> 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']
可以看到，有可用的方法：
元组方法:
| 方法 | 描述 |
|---|---|
| index() | 返回第一个匹配的索引 |
| count() | 统计某个元素在列表中出现的次数 |
| len(tuple) | 返回元素的个数 |
元组：count/index方法都是O(n) ; 随着规模的增大，而效率下降；
2.2 列表和元组互转
列表和元组之间可以相互转换，分别使用 tuple() 和 list() 来实现
>>> l = ['H', 'e', 'l', 'l', 'o']
>>> tx = tuple(l) # 列表转元组
>>> tx
('H', 'e', 'l', 'l', 'o')
>>>
>>> t = ('P', 'y')
>>> lx = list(t) # 元组转列表
>>> lx
['P', 'y']
既然可以互转，那么要改变元组，可以先将其转化为列表，对列表进行更改，然后再将列表转换为元组。
例如，删除元组中的元素：
>>> t = ('P', 'y')
>>>
>>> lx = list(t) # 将元组转换为列表
>>> lx.remove('y') # 删除列表中的元素
>>> t = tuple(lx) # 再将列表转换为元组
>>> t
('P',)
注意：元组本身是不可变的，这里说的并不是传统意义的改变(增、删、改)，相当于元组的重新赋值。
元组还有些什么？
元组也支持一些基本操作，例如：连接（+）、重复（*）、成员测试（in/not in）等。此外，它还可以与一些内置函数一起使用来执行不同的任务，例如：min()、max()、len() 等。这里就不再介绍了，请参考 Python 列表 。
高级元组namedtuple
1.顾名思义，就是带有名字的元组，这是什么意思呢？就是取值时不再需要通过下标索引的方式来获取了，可以直接叫名字(字段名)，先来看怎么定义的吧。
命名元组，返回一个元组的子类，并定义了字段；
field_names可以是空白符或逗号分隔的字段的字符串，可以是字段的列表
from collections import namedtuple
# 定义namedtuple类
User = namedtuple("User", 'name gender height weight')
# 或者
# User = namedtuple("User", ['name', 'gender', 'height', 'weight'])
# 初始化namedtuple实例对象
user = User(name="jack", gender="female", height=170, weight=120)
user.name #'jack'
user.gender #'female'
模块导入的两种方式：
import collections
from collections import namedtuple
定义 namedtuple 时，第一个参数就是元组的名字，这里很像我们自定义类中的类名，第二个参数是用空格隔开的字符串（也可以是字符串组成的列表），代表元组中的4个字段，相当于类中的4个属性。初始化方式和类的实例对象是一样的，如果用普通类来定义可表示为：
class User:
def __init__(self, name, gender, height, weight):
self.name = name
self.gender = gender
self.height = height
self.weight = weight
user = User(name="jack", gender="female", height=170, weight=120)
user.name #'jack'
对比起来，其实 namedtuple 就是一个轻量级的类，代码更简洁，当我们的类非常简单，只有属性又不需要定义其他方法时，完全可以用 namedtuple 来代替类，使用 namedtuple 效率比使用普通类更高效，同样因为内部不需要维护太多的东西。
2. namedtuple其实是继承 tuple 的一个子类，它保留了 tuple 的特性，比如通过索引获取元素，切片功能，同样地，字段不能重新赋值。
>>> user[1:3]
('female', 170)
>>> user[0]
'jack'
>>> user.name = 'bob'
Traceback (most recent call last):
File "", line 1, in
AttributeError: can't set attribute
namedtuple 比 tuple 的优势在于 namedtuple 具有可自我描述的特点，因为 tuple 中的值不看上下文你不知道具体代表什么，而 namedtuple 自己就可以说明各字段代表什么。
源码的阅读
帮助文档看不懂，看源码；源码中很多地方用到了namedtuple
map（str,a）生成可迭代对象；一一转换；