【Think Python】Python笔记（十二）元组

内置数据类型：元组（tuple）

（一）元组是不可变的

• 元组是一组值 的序列；其中的值可以是任意的类型，使用整数进行索引；
• 元组类型与数组的不同在于元组的不可变性；

元组的创建：

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

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

• 虽然并非是必须的，但是元组通常使用圆括号：

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

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

>>> t1 =  'a',
>>> type(t1)
<class 'tuple'>

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

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

• 可以使用内建函数tuple创建元组，当没有参数进行传递的时候，创建一个空元组

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

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

>>> t = tuple('apple')
>>> t
('a', 'p', 'p', 'l', 'e')

元组的操作：

列表的大多数操作同样适用于元组；

• 使用方括号进行索引：

>>> t = ('a', 'p', 'p', 'l', 'e')
>>> t[0]
'a'

• 同样可以使用切片操作：

>>> t[1:3]
('p', 'p')

• 当试图修改元组中的值的时候会发生错误；因为元组是不可变的，但是可以使用其他元组替代现有的元组：

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

>>> t = ('A',) + t[1:]
>>> t
('A', 'p', 'p', 'l', 'e')

元组之间的比较：

关系运算符同样适用于元组和其他序列；

• python会先比较第一个元素，根据第一个元素的大小进行排序，当第一个元素相同的时候，逐一比较后面的元素；

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

（二）使用元组赋值

变量之间的交换值的操作，使用元组可以更加便捷；

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

• 使用元组

a, b = b, a   #左侧的变量数和右侧变量数必须相同

• 一般来说，右侧可以是任意类型（字符串、列表或者元组）的序列：

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

这其中，split返回的对象是一个包含两个元素的列表；

（三）元组作为返回值

一般来说，一个函数只能有一个返回值，但是当这个返回值是元组类型的时候，相当于多个返回值；

• 内建函数divmod接受两个实参，返回这两个值的元组：商和余数：

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

或者使用下面的存储方式：

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

（四）元组作为可变长参数

• 函数可以接受可变数量的参数；
• 以*开头的形参可以将输入的参数放进一个元组中；
• 这个形参的名字可以使用任意的名字，但是习惯上使用args

def printall(*args):
    print(args)
    
>>> printall(1, 2.0, '3')
(1, 2.0, '3')

• 与汇集相对的是分散（scatter）；
• 当有一个值的序列，想要作为多个参数进行传递的时候，可以使用*运算符；

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

（五）列表和元组

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

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

结果是包含若干元组的列表；

如果用于创建zip对象的两个序列的长度不一，则返回的长度以最短的序列的长度为准；

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

• 将zip、for循环和元组赋值结合起来使用，可以得到同事遍历两个（甚至多个）序列的方法：

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的返回结果是一个枚举对象，可迭代一个包含若干个对的序列；每个对包含了（从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方法也接受元组列表，并将其作为键值对添加到字典中
• 字典中使用元组作为键是常见的，比如使用姓-名作为和电话号码的映射：

directory[last, first] = number

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nNk86LgG-1583290718509)(D:/installed/Typora/upload/image-20200302192502078.png)]

（七）序列嵌套

常见的序列：字符串、列表、元组；

• 选择合适的序列：
  • 字符串：每个元素都是字符，并且不可变
  • 列表：比元组常用，因为它是可变的；
  • 元组：下面的情况更时候与使用元组：
    • 有时候，如return语句，从句式上生成一个元组更加容易；
    • 作为字典的键；
    • 作为函数的参数；
• 元组并没有sort和reverse这样修改现有列表的方法，凡是python有sorted()和reversed()这样的内建函数；

（八）调试

• 列表、字典、元组都是数据结构（data structures）；
• 复合数据结构：列表与元组的嵌套等
• 这些复合数据结构是非常实用的，但是容易出现形状错误（shape errors），也就是由于数据结构的类型、大小或结构问题而引发的错误；
  • 例如，当希望使用一个整数组成的列表时，我却给了你一个纯粹的整数（没有放在列表中），就会出现错误。

• 为了方便调试，可以使用structshape模块，它提供了一个同名函数，可以接受任意类型的数据结构作为实参，然后返回一个描述它形状的字符串：

>>> from structshape import structshape
>>> t = [1, 2, 3]
>>> structshape(t)
'list of 3 int'

>>> t3 = [1, 2, 3, 4.0, '5', '6', [7], [8], 9]
>>> structshape(t3)
'list of (3 int, float, 2 str, 2 list of int, int)'

下载地址