基本介绍
元组是值的序列。 这些值可以是任何类型，并且它们由整数进行索引，因此在这方面元组非常类似于列表。 重要的区别在于元组是不可变的（immutable）。
在语法上，tuple 是一个以逗号分隔的值列表，虽然没有必要，但常常将元组括在括号内。
t = 'a', 'b', 'c'
type(t)
#tuple
t = ('a', 'b', 'c')
type(t)
#tuple
要用创建一个 只有一个元素的元组，必须包含一个最后的逗号：
t = 'a',
type(t)
#tuple
括号中的只有一个元素不是元组:
t = ('a')
type(t)
#str
t = ('a',)
type(t)
#tuple
创造一个空的元组：
t =tuple()
t
#()
如果参数是一个序列(字符串、列表或元组) ，结果是一个包含所有其中元素的元组：
t =tuple('mathilda')
t
#('m', 'a', 't', 'h', 'i', 'l', 'd', 'a')
大多数列表操作符也用于元组：
t =tuple('mathilda')
t[0]
#'m'
t[1:3]
#('a', 't')
但是如果试图修改元组的一个元素，会报错：
t[0] = 'A'
#TypeError: 'tuple' object does not support item assignment
因为元组是不可变的，所以不能修改元素。 但是可以用另一个元组替换一个元组（注意第一个要是元组不能是‘M’），语句生成一个新元组，然后命名为t。
t = ('M',) + t[1:]
t
#('M', 'a', 't', 'h', 'i', 'l', 'd', 'a')
关系运算符处理元组和其他序列：Python 从比较每个序列的第一个元素开始。 如果它们相等，则继续到下一个元素，依此类推，直到找到不同的元素。 不考虑后续元素(即使它们非常大)。
(1, 2, 3) < (1, 1, 100)
#false
元组的交换赋值
一般我们要交换两个变量的值，我们会这么写：
temp = a
a = b
b = temp
元组的交换则会更为简略：
a, b = b, a
左边是一个变量元组，右边是一个表达式元组，每个值都分配给其各自的变量，右边的所有表达式都在任何赋值之前进行计算。左边和右边的元素个数必须相同。
右边可以是任何类型的序列(字符串、列表或元组)。 例如，将一个电子邮件地址分割成一个用户名和一个域名，可以这样写：
email = "yrc.mathilda@gmail.com"
uname, doname = email.split("@")
#uname:'yrc.mathilda' doname:gmail.com
返回元组
严格地说，一个函数只能返回一个值，但是如果该值是一个元组，那么可以返回多个值。 例如，如果希望除以两个整数并计算商和余数，那么计算x//y和x%y是低效的，可以同时计算它们。
内置函数divmod接受两个参数并返回两个值(商和余数)组成的元组。 可以将结果存储为一个元组，也可以用元组的赋值分别储存结果：
t = divmod(10, 4)
t
#(2, 2)
a, b = divmod(10, 4)
#a = 2, b = 2
这是一个函数返回元组的例子：
def first_last(l):
return l[0], l[-1]
first_last([1, 2, 3])
#(1, 3)
参数*
函数可以接受可变数量的参数。以为*开头的参数名称将参数收集到元组中。 比如说，
def first_last(*l):
print(type(l))
return l[0], l[-1]
first_last(1, 2, 3)
#<class 'tuple'>
#(1, 3)
*参数可以是任何名称，但是常规用args。
如果是一个元组，也可以用 * 来把它打散
t = (10, 4)
divmod(t)
#TypeError: divmod expected 2 arguments, got 1
divmod(*t)
#(2, 2)
许多内置函数比如max，min就是接受这种参数（Variable-length argument tuples）所以可以接收无数个参数
max(1, 2, 3, 4, 5, 6, 7, ...)
但是sum不可以
sum(1, 2, 3)
#TypeError: sum expected at most 2 arguments, got 3
参数**
*不能在像字典一样的对象中使用
def printall(*args):
print(args)
printall(1, 2, 3)
#(1, 2, 3)
printall(1, 2, third = 3)
#TypeError: printall() got an unexpected keyword argument 'third'
为了获得字典一样的参数可以用**来获取
def printall(*args, **kwargs):
print(args, kwargs)
printall(1, 2, 3)
#(1, 2, 3) {}
printall(1, 2, third = 3)
#(1, 2) {'third': 3}
题外话：a和d是等价的
d = dict(x=1, y=2)
a = {'x':1, 'y':2}
a == d
#True
更多的例子
print(1, 2, 3)
#等价于
print(*[1, 2, 3])
#为1 2 3， print([1, 2, 3])为[1, 2, 3]
def f(*args, **kwargs):
print("ARGS", args)
print("KWARGS", kwargs)
f(1, 2, x = 3, y = 4, z = 5)
#ARGS (1, 2)
#KWARGS {'x': 3, 'y': 4, 'z': 5}
list和tuple
zip是一个内置函数，它需要两个或多个序列，并将它们并在一起。
a = "abc"
b = (1, 2, 3)
zip(a, b)
#<zip at 0x7fe091401f08>
这样的结果是zip对象，但这个对象可以进行遍历，所以zip最常见的用途就是用在循环中
a = "abc"
b = (1, 2, 3)
for pair in zip(a, b):
print(pair)
#('a', 1)
#('b', 2)
#('c', 3)
zip对象是一种迭代器，在某些方面与列表相似，但与列表不同的是，不能使用索引从迭代器中选择元素。
如果想使用列表操作符和方法，可以这样：
list(zip(a, b))
#[('a', 1), ('b', 2), ('c', 3)]
type(list(zip(a, b))[0])
#tuple
结果是一个元组列表。
如果序列的长度不相同，则结果是选取较短序列的长度。
list(zip('avbc', 'sdf'))
#[('a', 's'), ('v', 'd'), ('b', 'f')]
还可以这样
a = "abc"
b = (1, 2, 3)
for ch, num in zip(a, b):
print(ch, num)
#a 1
#b 2
#c 3
如果需要遍历序列的元素及其索引，可以使用内置函数enumerate:
其结果是枚举对象，它迭代一系列对，每个对包含一个索引(从0开始)和一个来自给定序列的元素。
for index, ch in enumerate('abc'):
print(index, ch)
#0 a
#1 b
#2 c
字典和tuple
字典有一个名为items的方法，它返回一个元组序列，其中每个元组是一个键值对。items的对象可以用于循环，在字典里的元素没有特定顺序。
d = {'a':1, 'b':3, 'c':10}
d.items()
#dict_items([('a', 1), ('b', 3), ('c', 10)])
for key, val in d.items():
print(key, val)
#a 1
#b 3
#c 10
反过来，可以使用元组列表来初始化一个新的字典：
t = [('a', 1),('b', 3),('c', 10)]
dict(t)
#{'a': 1, 'b': 3, 'c': 10}
可以结合dict和zip非常简洁的创造字典：
dict(zip('abc', [1,2, 3]))
#{'a': 1, 'b': 2, 'c': 3}
字典中的update方法同样可以接收由tuple组成的list，并且添加到字典中。
在字典中使用tuple作为key是很普遍的，因为不能使用list
可以写：
d[a, b] = c
for a, b in d:
print(a, b, d[a, b])
这样在循环中的ab只会取值d的key赋值给ab