Python 排序及格式化输出

Python函数

内置函数

Python中有一些定义好的内置函数，具体列表可查看链接。
其中，filter和map用的比较多，之前写scala的时候见到过，没想到python内也有。

foo = [2, 18, 9, 22, 17, 24, 8, 12, 27]
print(list(filter(lambda x: x % 3 == 0, foo)))
# [18, 9, 24, 12, 27]

print(list(map(lambda x: x * 2 + 10, foo)))
# [14, 46, 28, 54, 44, 58, 26, 34, 64]

Lambda

lambda实际上就是匿名函数

一般形式：

lambda arguments: expression

写成函数形式就是

def <lambda>(arguments):
    return expression

lambda 是为了减少单行函数的定义而存在的，而在各种排序中，尤其是dict的排序中，会用到很多单行排序技巧。

各种排序

简单list排序

lis = ['a', 'b', 'c']
print(sorted(lis))
# ['a', 'b', 'c']
print(sorted(lis, reverse=True))
# ['c', 'b', 'a']

dict的key排序

dic = {'c': 1, 'b': 2, 'a': 3}
print(sorted(dic))
# ['a', 'b', 'c']
print(sorted(dic, reverse=True))
# ['c', 'b', 'a']

dict的value排序

dic = {'c': 1, 'b': 2, 'a': 3}
print(sorted(dic, key=lambda k: dic[k]))
# ['c', 'b', 'a']
print(sorted(dic, key=lambda k: dic[k], reverse=True))
# ['a', 'b', 'c']

list内嵌套list排序

lis = [[4, 2, 9], [1, 5, 6], [7, 8, 3]]
print(sorted(lis, key=lambda k: k[0]))
# [[1, 5, 6], [4, 2, 9], [7, 8, 3]]
print(sorted(lis, key=lambda k: k[1]))
# [[4, 2, 9], [1, 5, 6], [7, 8, 3]]
print(sorted(lis, key=lambda k: k[2]))
# [[7, 8, 3], [1, 5, 6], [4, 2, 9]]
print(sorted(lis, key=lambda k: k[0], reverse=True))
# [[7, 8, 3], [4, 2, 9], [1, 5, 6]]

dict内嵌套dict排序

dic = {
    'a': {'x': 3, 'y': 2, 'z': 1},
    'b': {'x': 2, 'y': 1, 'z': 3},
    'c': {'x': 1, 'y': 3, 'z': 2},
}
print(sorted(dic, key=lambda k: dic[k]['x']))
# ['c', 'b', 'a']
print(sorted(dic, key=lambda k: dic[k]['y']))
# ['b', 'a', 'c']
print(sorted(dic, key=lambda k: dic[k]['z']))
# ['a', 'c', 'b']
print(sorted(dic, key=lambda k: dic[k]['x'], reverse=True))
# ['a', 'b', 'c']

list内嵌套dict排序

lis = [
    {'x': 3, 'y': 2, 'z': 1},
    {'x': 2, 'y': 1, 'z': 3},
    {'x': 1, 'y': 3, 'z': 2},
]
print(sorted(lis, key=lambda k: k['x']))
# [{'z': 2, 'x': 1, 'y': 3}, {'z': 3, 'x': 2, 'y': 1}, {'z': 1, 'x': 3, 'y': 2}]
print(sorted(lis, key=lambda k: k['y']))
# [{'z': 3, 'x': 2, 'y': 1}, {'z': 1, 'x': 3, 'y': 2}, {'z': 2, 'x': 1, 'y': 3}]
print(sorted(lis, key=lambda k: k['z']))
# [{'z': 1, 'x': 3, 'y': 2}, {'z': 2, 'x': 1, 'y': 3}, {'z': 3, 'x': 2, 'y': 1}]
print(sorted(lis, key=lambda k: k['x'], reverse=True))
# [{'z': 1, 'x': 3, 'y': 2}, {'z': 3, 'x': 2, 'y': 1}, {'z': 2, 'x': 1, 'y': 3}]

dict内嵌套list排序

dic = {
    'a': [1, 2, 3],
    'b': [2, 1, 3],
    'c': [3, 1, 2],
}
print(sorted(dic, key=lambda k: dic[k][0]))
# ['a', 'b', 'c']
print(sorted(dic, key=lambda k: dic[k][1]))
# ['b', 'c', 'a']
print(sorted(dic, key=lambda k: dic[k][2]))
# ['c', 'b', 'a']
print(sorted(dic, key=lambda k: dic[k][0], reverse=True))
# ['c', 'b', 'a']

格式化输出

使用固定宽度对齐文本

很多时候我们希望在每行输出的多列字符串的每一列能够保持某一个固定的宽度，如果字符串的宽度比这个宽度小，就用空格或其他字符填充以保持输出的美观性，同时还可以指定每一列左/右对齐/居中对齐，视觉上类似windows文档夹的效果.

format函数就可以让我们输出的字符串达到这种每一列固定长度同时指定对齐方式的效果，使用方式为’{format_spec}’.format(args)，其中format_spec 格式为

[[fill]align][sign][#][0][width][,][.precision][type]

其中fill,align,width这3个参数使用较多，fill表示填充字符，align表示对齐方式，width表示宽度，其余参数使用不是很频繁，因此简化下上述格式为[[fill]align][width]，因此总的格式为{index:[[fill]align][width]}.format(args)，其中index表示args参数的位置，fill参数可以是任意字符，align参数可以为<(左对齐),>(右对齐)，^(居中),=(使用不多，不做介绍)，下面看个示例：

for i in range(10):
    print('{0: <5} {1: ^15}{2: >5}'.format(i,id(i),str(i)))

字符串输出宽度对齐函数

python本身提供了字符串格式化对齐的函数，主要包括左对齐str.ljust，居中对齐str.center，右对齐str.rjust,这三个函数的参数及其意义如下：

• str.ljust(width, [fillchar])
• str.center(width, [fillchar])
• str.rjust(width, [fillchar])

这三个函数的参数相同，意义也相同，width表示总的字节宽度，fillchar为可选参数，表示填充字符，如果不传递该参数，则默认使用空格填充。因此前面那个示例我们改为用对齐函数表示则如下所示：

for i in range(10):
    print("{}".format(i).ljust(5),"{}".format(id(i)).center(15),"{}".format(str(i)).rjust(5))

两个函数输出为:

Python 排序及格式化输出