python元组2

python元组

本章介绍另一个内置类型：元组，同时说明如何结合使用列表、字典和元组。我还将介绍一个有用的特性，即可变长度参数列表，以及汇集和分散操作符。

说明：“tuple”并没有统一的发音，有些人读成“tuh-ple”，音律类似于“supple”； 而在编程的语境下，大部分读成“too-ple”，音律类似于“quadruple”。

元组是不可变的

元组是一组值的序列。 其中的值可以是任意类型， 使用整数索引， 因此从这点上看，元组与列表非常相似。 二者不同之处在于元组的不可变性。

语法上，元组是用逗号隔开一系列值：

>>> t = 'a', 'b', 'c', 'd', 'e'

虽然并非必须，元组通常用括号括起来：

>>> t = ('a', 'b', 'c', 'd', 'e')

使用单一元素创建元组时，需要在结尾处添加一个逗号：

加逗号和不加逗号的区别

将值放置在括号中并不会创建元组：

>>> t2 = ('a')
>>> type(t2)
<class 'str'>

另一个创建元组的方法是使用内建函数 tuple 。 在没有参数传递时，它会创建一个空元组：

>>> t = tuple()
>>> t
()

如果实参是一个序列（字符串、列表或者元组），结果将是一个包含序列内元素的元组。

>>> t = tuple('lupins')
>>> t
('l', 'u', 'p', 'i', 'n', 's')

因为 tuple 是内建函数名，所以应该避免将它用作变量名。

列表的大多数操作符同样也适用于元组。 方括号运算符将索引一个元素：

>>> t = ('a', 'b', 'c', 'd', 'e')
>>> t[0]
'a'

切片运算符选取一个范围内的元素:

>>> t[1:3]
('b', 'c')

但是，如果你试图元组中的一个元素，会得到错误信息：

>>> t[0] = 'A'
TypeError: object doesn't support item assignment

因为元组是不可变的，你无法改变其中的元素。 但是可以使用其他元组替换现有元组：

>>> t = ('A',) + t[1:]
>>> t
('A', 'b', 'c', 'd', 'e')

这个语句创建了一个新元组，然后让 t 引用该元组。

关系型运算符也适用于元组和其他序列； Python 会首先比较序列中的第一个元素，如果它们相等，就继续比较下一组元素，以此类推，直至比值不同。 其后的元素（即便是差异很大）也不会再参与比较。

>>> (0, 1, 2) < (0, 3, 4)
True
>>> (0, 1, 2000000) < (0, 3, 4)
True

元组赋值

两个变量互换值的操作通常很有用。 按照传统的赋值方法，你需要使用一个临时变量。 例如，为了交换 a 和 b 的值：

>>> temp = a
>>> a = b
>>> b = temp

这个方法很繁琐；通过元组赋值来实现更为优雅：

>>> a, b = b, a

等号左侧是变量组成的元组；右侧是表达式组成的元组。 每个值都被赋给了对应的变量。 变量被重新赋值前，将先对右侧的表达式进行求值。

左侧的变量数和右侧值的数目必须相同：

>>> a, b = 1, 2, 3
ValueError: too many values to unpack

一般来说，右侧可以是任意类型（字符串、列表或者元组）的序列。 例如， 将一个电子邮箱地址分成用户名和域名， 你可以这样做：

>>> addr = 'monty@python.org'
>>> uname, domain = addr.split('@')

split 函数返回的对象是一个包含两个元素的列表； 第一个元素被赋给了变量 uname ，第二个被赋给了 domain 。

>>> uname
'monty'
>>> domain
'python.org'

元组作为返回值

严格地说，一个函数只能返回一个值，但是如果这个返回值是元组，其效果等同于返回多个值。 例如，你想对两个整数做除法，计算出商和余数，依次计算出x/yx/y和 xx的效率并不高。同时计算出这两个值更好。

内建函数 divmod 接受两个实参，返回包含两个值的元组：商和余数。 你可以使用元组来存储返回值:

>>> t = divmod(7, 3)
>>> t
(2, 1)

或者使用元组赋值分别存储它们：

>>> quot, rem = divmod(7, 3)
>>> quot
2
>>> rem
1

下面是一个返回元组作为结果的函数例子：

def min_max(t):
    return min(t), max(t)

max和 min 是用于找出一组元素序列中最大值和最小值的内建函数。 min_max函数同时计算出这两个值，并返回二者组成的元组。

可变长度参数元组

函数可以接受可变数量的参数。 以 “*” 开头的形参将输入的参数 汇集 到一个元组中。 例如，printall 可以接受任意数量的参数，并且将它们打印出来：

def printall(*args):
    print(args)

汇集形参可以使用任意名字，但是习惯使用 args。 以下是这个函数的调用效果：

>>> printall(1, 2.0, '3')
(1, 2.0, '3')

与汇集相对的，是 分散（scatter） 。 如果你有一个值序列，并且希望将其作为多个参数传递给一个函数， 你可以使用运算符*。 例如，divmod 只接受两个实参； 元组则无法作为参数传递进去：

>>> t = (7, 3)
>>> divmod(t)
TypeError: divmod expected 2 arguments, got 1

但是如果你将这个元组分散，它就可以被传递进函数：

>>> divmod(*t)
(2, 1)

许多内建函数使用了可变长度参数元组。 例如，max 和 min 就可以接受任意数量的实参：

>>> max(1, 2, 3)
3

但是 sum 不行：

>>> sum(1, 2, 3)
TypeError: sum expected at most 2 arguments, got 3

我们做个练习，编写一个叫做 small 的函数，使它能够接受任何数量的实参并返回它们的和。

列表和元组

zip是一个内建函数，可以接受将两个或多个序列组，并返回一个元组列表， 其中每个元组包含了各个序列中相对位置的一个元素。 这个函数的名称来自名词拉链(zipper)，后者将两片链齿连接拼合在一起。

下面的示例对一个字符串和列表使用 zip 函数：

>>> s = 'abc'
>>> t = [0, 1, 2]
>>> zip(s, t)
<zip object at 0x7f7d0a9e7c48>

输出的结果是一个 zip 对象，包含了如何对其中元素进行迭代的信息。 zip 函数最常用于 for 循环：

>>> for pair in zip(s, t):
...     print(pair)
...
('a', 0)
('b', 1)
('c', 2)

zip对象是迭代器的一种，即任何能够按照某个序列迭代的对象。 迭代器在某些方面与列表非常相似，但不同之处在于，你无法通过索引来选择迭代器中的某个元素。

如果你想使用列表操作符和方法，你可以通过 zip 对象创建一个列表：

>>> list(zip(s, t))
[('a', 0), ('b', 1), ('c', 2)]

结果就是一个包含若干元组的列表；在这个例子中，每个元组又包含了字符串中的一个字符和列表 中对应的一个元素。

如果用于创建的序列长度不一，返回对象的长度以最短序列的长度为准。

>>> list(zip('Anne', 'Elk'))
[('A', 'E'), ('n', 'l'), ('n', 'k')]

您可以在 for 循环中使用元组赋值，遍历包含元组的列表：

t = [('a', 0), ('b', 1), ('c', 2)]
for letter, number in t:
    print(number, letter)

每次循环时，Python 会选择列表中的下一个元组， 并将其内容赋给 letter 和 number 。循环的输出是：

0 a
1 b
2 c

如果将 zip 、for 循环和元组赋值结合起来使用，你会得到一个可以同时遍历两个（甚至多个）序列的惯用法。 例如，has_match 接受两个序列 t1 和 t2 ， 如果存在索引 i 让 t1[i] == t2[i] ，则返回 True ：

def has_match(t1, t2):
    for x, y in zip(t1, t2):
        if x == y:
            return True
    return False

如果需要遍历一个序列的元素以及其索引号，您可以使用内建函数 enumerate ：

for index, element in enumerate('abc'):
    print(index, element)

enumerate的返回结果是一个枚举对象（enumerate object），可迭代一个包含若干个对的序列； 每个对包含了（从0开始计数）的索引和给定序列中的对应元素。 在这个例子中，输出结果是：

0 a
1 b
2 c

和前一个示例的结果一样。

字典和元组

字典有一个叫做 items 的方法，它返回由多个元组组成的序列，其中每个元组是一个键值对。

>>> d = {'a':0, 'b':1, 'c':2}
>>> t = d.items()
>>> t
dict_items([('c', 2), ('a', 0), ('b', 1)])

其结果是一个 dict_items 对象，这是一个对键值对进行迭代的迭代器。 你可以在 for 循环中像这样使用它:

>>> for key, value in d.items():
...     print(key, value)
...
c 2
a 0
b 1

由于是字典生成的对象，你应该也猜到了这些项是无序的。

另一方面，您可以使用元组的列表初始化一个新的字典：

>>> t = [('a', 0), ('c', 2), ('b', 1)]
>>> d = dict(t)
>>> d
{'a': 0, 'c': 2, 'b': 1}

将 dict 和 zip 结合使用，可以很简洁地创建一个字典：

>>> d = dict(zip('abc', range(3)))
>>> d
{'a': 0, 'c': 2, 'b': 1}

字典的 update 方法也接受元组列表，并将其作为键值对添加到已有的字典中去。

在字典中使用元组作为键（主要因为无法使用列表）的做法很常见。 例如，一个电话簿可能会基于用户的姓-名对，来映射至号码。 假设我们已经定义了 last 、 first 和 number 三个变量， 我们可以这样实现映射：

directory[last, first] = number

方括号中的表达式是一个元组。我们可以通过元组赋值来遍历这个字典：

for last, first in directory:
    print(first, last, directory[last,first])

该循环遍历电话簿中的键，它们其实是元组。 循环将元组的元素赋给 last 和 first ， 然后打印出姓名和对应的电话号码。

在状态图中有两种表示元组的方法。更详细的版本是， 索引号和对应元素就像列表一样存放在元组中。例如，元组 ('Cleese', 'John') 可像图12-1：状态图中那样存放。

图12-1：状态图

在更大的图表中，你不会想要再描述这些细节。 例如，该电话簿的状态图可能如图12-2：状态图所示。

图12-2：状态图

在上图中，为了方便起见，使用 Python 语法表示元组。 此图中的电话号码是 BBC 的投诉热线，请不要拨打它。

序列嵌套

我已经介绍了包含元组的列表， 但本章几乎所有示例也适用于列表嵌套列表、元组嵌套元组，以及元组嵌套列表。 为了避免穷举这类可能的嵌套组合，介绍序列嵌套有时更简单一些。

在很多情况下，不同类型的序列（字符串、列表、元组）可以互换使用。 因此，我们该如何选用合适的序列呢？

首先，显而易见的是，字符串比其他序列的限制更多，因为它的所有元素都必须是字符，且字符串不可变。如果你希望能够改变字符串中的字符，使用列表嵌套字符或许更合适。

列表比元组更常用，主要是因为它们是可变的。 但是有些情况下，你可能更倾向于使用元组：

1. 在一些情况下（例如 return 语句），从句式上生成一个元组比列表要简单。
2. 如果你想使用一个序列作为字典的键，那么你必须使用元组或字符串这样的不可变类型。
3. 如果你向函数传入一个序列作为参数，那么使用元组可以降低由于别名而产生的意外行为的可能性。

由于元组的不可变性，它们没有类似（sort） 和 （reverse）这样修改现有列表的方法。 然而 Python 提供了内建函数 sorted 和 reversed ，前者可以接受任意序列，并返回一个正序排列的新列表，后者则接受一个序列，返回一个可逆序迭代列表的迭代器。