Python入门（十一）- 序列相关内置函数

十一、序列相关内置函数

11.1 zip

zip() 函数是 Python 内置函数之一，它可以将多个序列（列表、元组、字典、集合、字符串以及 range() 区间构成的列表）“压缩”成一个 zip 对象。所谓“压缩”，其实就是将这些序列中对应位置的元素重新组合，生成一个个新的元组。就是我们数学上所谓的一一映射。
和 Python 3.x 版本不同，Python 2.x 版本中的 zip() 函数会直接返回列表，而不是返回 zip 对象。但是，返回的列表或者 zip 对象，其包含的元素（都是元组）是相同的。

zip() 函数的语法格式为：

zip(iterable, ...)

其中 iterable,… 表示多个列表、元组、字典、集合、字符串，甚至还可以为 range() 区间等可迭代对象。

下面程序演示了 zip() 函数的基本用法：

my_list = [11,12,13]
my_tuple = (21,22,23)
print([x for x in zip(my_list,my_tuple)])  #此种列表推导式结构将会在后续程序流程控制中学习，现在只需要知道它是打印了zip中的元素即可。
my_dic = {31:2,32:4,33:5}
my_set = {41,42,43,44}
print([x for x in zip(my_dic)])
my_pychar = "python"
my_shechar = "shell"
print([x for x in zip(my_pychar,my_shechar)])
程序执行结果为：
[(11, 21), (12, 22), (13, 23)]
[(31,), (32,), (33,)]
[('p', 's'), ('y', 'h'), ('t', 'e'), ('h', 'l'), ('o', 'l')]

如果读者分析以上的程序和相应的输出结果不难发现，在使用 zip() 函数“压缩”多个序列时，它会分别取各序列中第 1 个元素、第 2 个元素、… 第 n 个元素，各自组成新的元组。需要注意的是，当多个序列中元素个数不一致时，会以最短的序列为准进行压缩。

另外，对于 zip() 函数返回的 zip 对象，既可以像上面程序那样，通过遍历提取其存储的元组，也可以向下面程序这样，通过调用 list() 函数将 zip() 对象强制转换成列表：

my_list = [11,12,13]
my_tuple = (21,22,23)
print(list(zip(my_list,my_tuple)))
程序执行结果为：
[(11, 21), (12, 22), (13, 23)]

11.2 reverse

reserved() 是 Pyton 内置函数之一，其功能是对于给定的序列（包括列表、元组、字符串以及 range(n) 区间），该函数可以返回一个逆序序列的迭代器（用于遍历该逆序序列）。

reserved() 函数的语法格式如下：

reversed(seq)

其中，seq 可以是列表，元素，字符串以及 range() 生成的区间列表。

下面程序演示了 reversed() 函数的基本用法：

#将列表进行逆序
print([x for x in reversed([1,2,3,4,5])])  
#将元组进行逆序
print([x for x in reversed((1,2,3,4,5))])
#将字符串进行逆序
print([x for x in reversed("abcdefg")])
#将 range() 生成的区间列表进行逆序
print([x for x in reversed(range(10))])
程序执行结果为：
[5, 4, 3, 2, 1]
[5, 4, 3, 2, 1]
['g', 'f', 'e', 'd', 'c', 'b', 'a']
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

除了使用列表推导式的方式，还可以使用 list() 函数，将 reversed() 函数逆序返回的迭代器，直接转换成列表。例如：

#将列表进行逆序
print(list(reversed([1,2,3,4,5])))
程序执行结果为：
[5, 4, 3, 2, 1]

再次强调，使用 reversed() 函数进行逆序操作，并不会修改原来序列中元素的顺序，例如：

a = [1,2,3,4,5]
#将列表进行逆序
print(list(reversed(a)))
print("a=",a)
程序执行结果为：
[5, 4, 3, 2, 1]
a= [1, 2, 3, 4, 5]

11.3 sorted

sorted() 作为 Python 内置函数之一，其功能是对序列（列表、元组、字典、集合、还包括字符串）进行排序。

sorted() 函数的基本语法格式如下：

list = sorted(iterable, key=None, reverse=False)  

其中，iterable 表示指定的序列，key 参数可以自定义排序规则；reverse 参数指定以升序（False，默认）还是降序（True）进行排序。sorted() 函数会返回一个排好序的列表。
注意，key 参数和 reverse 参数是可选参数，即可以使用，也可以忽略。

下面程序演示了 sorted() 函数的基本用法：

#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a))
#对元组进行排序
a = (5,4,3,1,2)
print(sorted(a))
#字典默认按照key进行排序
a = {4:1,\
     5:2,\
     3:3,\
     2:6,\
     1:8}
print(sorted(a.items()))
#对集合进行排序
a = {1,5,3,2,4}
print(sorted(a))
#对字符串进行排序
a = "51423"
print(sorted(a))
程序执行结果为：
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[(1, 8), (2, 6), (3, 3), (4, 1), (5, 2)]
[1, 2, 3, 4, 5]
['1', '2', '3', '4', '5']

再次强调，使用 sorted() 函数对序列进行排序， 并不会在原序列的基础进行修改，而是会重新生成一个排好序的列表。例如：

#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a))
#再次输出原来的列表 a
print(a)
程序执行结果为：
[1, 2, 3, 4, 5]
[5, 3, 4, 2, 1]

显然，sorted() 函数不会改变所传入的序列，而是返回一个新的、排序好的列表。

除此之外，sorted(）函数默认对序列中元素进行升序排序，通过手动将其 reverse 参数值改为 True，可实现降序排序。例如：

#对列表进行排序
a = [5,3,4,2,1]
print(sorted(a,reverse=True))
程序执行结果为：
[5, 4, 3, 2, 1]

另外在调用 sorted() 函数时，还可传入一个 key 参数，它可以接受一个函数，该函数的功能是指定 sorted() 函数按照什么标准进行排序。例如：

chars=['https://editor.csdn.net',\
       'https://editor.csdn.net/python/',\
       'https://editor.csdn.net/shell/',\
       'https://editor.csdn.net/java/',\
       'https://editor.csdn.net/golang/']
#默认排序
print(sorted(chars))
#自定义按照字符串长度排序
print(sorted(chars,key=lambda x:len(x)))
程序执行结果为：
['https://editor.csdn.net',
 'https://editor.csdn.net/golang/',
 'https://editor.csdn.net/java/',
 'https://editor.csdn.net/python/',
 'https://editor.csdn.net/shell/']
['https://editor.csdn.net',
 'https://editor.csdn.net/java/',
 'https://editor.csdn.net/shell/',
 'https://editor.csdn.net/python/',
 'https://editor.csdn.net/golang/']

此程序中，使用了 lambda 表示式，其用法会在后续章节进行详细介绍。