（四）Python排序、枚举、迭代内置函数

排序与逆序

1. 排序函数sorted()

Python内置排序函数sorted()的说明如下

In [8]:sorted?
Signature: sorted(iterable, /, *, key=None, reverse=False)
Docstring:
Return a new list containing all items from the iterable in ascending order.

A custom key function can be supplied to customize the sort order, and the
reverse flag can be set to request the result in descending order.
Type:      builtin_function_or_method

使用sorted函数对一个可以排序的迭代对象进行排序，并且返回一个新列表（sorted操作不会更改原来的列表）。
参数

iterable：迭代对象
key：迭代依据，默认为None，即按照正常大小顺序排列
reverse：是否反转，默认为False，即按照升序排列

In [1]:x = list(range(12))
In [2]:import random
In [3]:random.shuffle(x)
In [4]:x
Out[4]: [7, 0, 9, 1, 8, 10, 2, 4, 11, 6, 3, 5]
In [5]:sorted(x)
Out[5]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
In [6]:sorted(x, reverse=True)
Out[6]: [11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
In [7]:x
Out[7]: [7, 0, 9, 1, 8, 10, 2, 4, 11, 6, 3, 5]

看看参数key的作用，一般来说，把一个匿名函数表达式赋值给参数key可以起到迭代依据的作用

In [19]: y = ['a', 'ba', 'ksml', 'bc', 'bcd', 'efg', 'edg', 'nnmm']
In [20]: sorted(y)
Out[20]: ['a', 'ba', 'bc', 'bcd', 'edg', 'efg', 'ksml', 'nnmm']
In [21]: sorted(y, key=lambda item:len(item)) #按照字符串的长度来排序
Out[21]: ['a', 'ba', 'bc', 'bcd', 'efg', 'edg', 'ksml', 'nnmm']
In [22]: sorted(y, key=lambda item:(len(item), item))
Out[22]: ['a', 'ba', 'bc', 'bcd', 'edg', 'efg', 'ksml', 'nnmm']

3. 反转函数reversed()

Python内置反转函数reversed()的说明如下

In [23]: reversed?
Init signature: reversed(sequence, /)
Docstring:      Return a reverse iterator over the values of the given sequence.
Type:           type
Subclasses:     

reversed函数对可迭代对象（除了生成器对象，zip，map，filter，enumerate对象）进行翻转，返回一个可迭代的reversed对象

In [32]: reversed(y)
Out[32]: <list_reverseiterator at 0x2c2e151ab00>

In [33]: k = reversed(y)
In [33]: for item in k:
    ...:     print(item)
nnmm
edg
efg
bcd
bc
ksml
ba
a

枚举与迭代

1. 枚举函数enumerate()

enumerate函数将一个可迭代对象中的元素及其索引打包成一个元组，并返回一个enumerate对象。

>>>a = ['name', 1, 4, 'jack']
>>>e = enumerate(a)
>>>for index, item in e:
    	prine(index, item)
1 1
2 4
3 jack

在循环完成后，迭代对象enumerate会清空所有元素，此时如果将其转换成列表对象的话，返回的就是一个空列表

>>>e = enumerate(['foo', 'bar', 'name', 'knn'])
>>>e
Out[9]: <enumerate at 0x25b007ede10>
>>>list(e)
Out[10]: [(0, 'foo'), (1, 'bar'), (2, 'name'), (3, 'knn')]

还可以用字典对象来储存可迭代对象的值和索引

lst = ['foo', 'bar', 'name', 'knn']
dic_1 = {
     }
dic_2 = {
     }
#一般方法
for i in range(len(lst)):
    dic_1[lst[i]] = i
#使用enumerate函数
for i, v in enumerate(lst):
    dic_2[v] = i

>>>dic_1
Out[12]: {
     'foo': 0, 'bar': 1, 'name': 2, 'knn': 3}

>>>dic_2
Out[13]: {
     'foo': 0, 'bar': 1, 'name': 2, 'knn': 3}

2. 迭代函数range()

这个函数一般和循环结合使用，语法格式为range(start=1=0, end, step=1)。返回一个range对象，开始默认为0，步长默认为1。
当步长step为负数时，意味着将返回一个从start到end的反向区间。

>>>list(range(5)) #左闭右开区间
Out[14]: [0, 1, 2, 3, 4]

>>>list(range(1, 5, 2))
Out[15]: [1, 3]

>>>list(range(10, 1, 2))
Out[16]: []

>>>list(range(10, 1, -2))
Out[17]: [10, 8, 6, 4, 2]

>>>list(range(10, 1, -1))
Out[18]: [10, 9, 8, 7, 6, 5, 4, 3, 2]

3. 压缩函数zip()

zip函数有两个功能：

1. 一个是将多个可迭代对象的元素，按照可迭代对象中最短的那个进行压缩，压缩过程是将每个可迭代对象对齐，从头开始将每个可迭代对象中对齐的元素放入元组中。

>>>seq1 = ['foo','name','Jack']
>>>seq2 = ['123','kkk','rnn']
>>>seq3 = [True, False, 'last','first']

>>>zipped = zip(seq1, seq2, seq3)

>>>zipped
Out[24]: <zip at 0x25b7eef37c8>

>>>list(zipped)
Out[25]: [('foo', '123', True), ('name', 'kkk', False), ('Jack', 'rnn', 'last')]

>>>zipped
Out[27]: <zip at 0x25b7eef37c8>

>>>list(zipped)
Out[28]: []

>>>zipped = zip(seq1, seq2, seq3)

>>>for i, (a, b, c) in enumerate(zipped):
    	print("{0}: {1}, {2}, {3}".format(i, a, b, c))
0: foo, 123, True
1: name, kkk, False
2: Jack, rnn, last

2. 另外一个功能是解压序列，也就是将一个被压缩的序列解压出来。

>>>new = list(zip(seq1, seq2, seq3))

>>>new
Out[32]: [('foo', '123', True), ('name', 'kkk', False), ('Jack', 'rnn', 'last')]

>>>l1, l2, l3 = zip(*new)

>>>l1
Out[34]: ('foo', 'name', 'Jack')

>>>l2
Out[35]: ('123', 'kkk', 'rnn')

>>>l3
Out[36]: (True, False, 'last')

函数作用在序列上

1. map()函数

map函数的作用是，将已定义的函数fun，作用到一个序列上，从而省略了循环步骤，简化了代码。

>>>func = lambda x:x**2 #单参数函数

>>>func
Out[39]: <function __main__.<lambda>(x)>

>>>l = range(14)

>>>m = map(func, l)

>>>m
Out[42]: <map at 0x25b00b33828>

>>>list(m)
Out[43]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169]

比如，想要将一个输入的数字字符串转换成一个整数列表，可以这样使用

>>>list(map(int, '114514'))
Out[44]: [1, 1, 4, 5, 1, 4]

>>>[int(x) for x in '114514'] #用列表生成式也行
Out[45]: [1, 1, 4, 5, 1, 4]

>>>l = []
>>>for x in '114514':   #用循环
    	l.append(int(x))
>>>l
Out[49]: [1, 1, 4, 5, 1, 4]

2. filter()函数

和map一样，filter函数将一个函数fun全部作用在一个序列上， 不同的是，filter函数将函数fun作用后值为True的元素返回，并不修改原序列。
当fun为None时，filter函数将返回本身为True的元素。

>>>r = range(10)

>>>f = filter(lambda x:x%2, r)

>>>list(f)
Out[56]: [1, 3, 5, 7, 9]