基础篇_010_函数_sorted()函数

----引言的引言 ===》

　　Question_1: 来来来，让我们试着按由小到大的顺序重新排一下my_list = [5, 4, 3, 2, 1]。

　　Answer_1: 呵，这不简单，直接这样: my_list = [1, 2, 3, 4, 5]完事儿~~。

　　Question_2: emmm...行叭，你5个可以试试1w+的(累不死你)？

　　Answer_2: 嗐！直接这样: list(reversed(my_list))不就行了嘛，害像小明以一样搁这儿问东问西的。

　　Question_3: ......(啪！嘭！)，这货生前是个体面人，大家不妨唾口痰再走...

　　Answer_3: (当场去世，原地升天)

 

----引言 ===》

　　好了，不bb了，直接开锤！

　　盲猜一波大家首先想到的是"for循环 + max()函数" / "for循环 + 直接选择法" / "for循环 + 冒泡排序法"...比如说 ===》

# 冒泡排序法:
def maoPaoPaiXu(arg):
    for index in range(0, len(arg)):
        for sub_index in range(1, len(arg) - index):
            if arg[sub_index - 1] > arg[sub_index]:
                temp = arg[sub_index]
                arg[sub_index] = arg[sub_index - 1]
                arg[sub_index - 1] = temp
    return arg
print(maoPaoPaiXu([2, 5, 4, 1]))   # 输出：[1, 2, 4, 5]

　　这样好像有点麻烦，所以贴心的Python早已为我们准备了一个内置函数: sorted()函数。它可以自动地帮助我们进行由小到大的排序，如果想要由大到小的排序，则可以运用reversed()函数 ===》

# sorted()函数的简单用法
# 默认的由小到大的排序
print(sorted((5, 4, 3, 2, 1)))  # 输出：[1, 2, 3, 4, 5]
# 由大到小的排序
print(list(reversed(sorted((5, 3, 4, 2, 1)))))  # 输出：[5, 4, 3, 2, 1]

　　

----sorted()函数与zip()函数相结合 ===》

　　现在有一个需求: 按照年龄的大小，由小到大进行排列，并显示出此人的所有信息，people_age_dict = {"simba_age": 10000, "vivian_age": 20, "cc_age": 18} ===》

people_age_dict = {
    "simba_age": 10000, # 老夫
    "vivian_age": 20,   # 老夫的大哥
    "cc_age": 18,       # 老夫的"忘年交"
}
# 现在有一个需求: 按照年龄的大小，由小到大进行排列，并显示出此人的所有信息
# 首先想到有zip()函数和sort()函数的结合 ===》
my_zip = zip(people_age_dict.values(), people_age_dict.keys())  # 将字典的键值对转换成一个一个的元组存起来，并以value开头
zip_list = list(my_zip)     # 将返回值转换成列表的形式
zip_list_sorted = sorted(zip_list)  # 将列表进行排序，这个排序函数本质上就是取最大值，所以说与max()和min()函数的规则极为相似
print(zip_list_sorted)      # 打印排序后的结果：[(18, 'cc_age'), (20, 'vivian_age'), (10000, 'simba_age')]

　　现在这个字典一如既往地变了: people_list_dict = [{"name": "simba", "age": 1000}, {"name": "vivian", "age": 500}, {"name": "cc", "age": 17.999}]变成了一个列表，列表中包含一个人的信息，这些信息的结构是字典===》

people_list_dict = [
    {"name": "simba", "age": 1000}, # 老夫
    {"name": "vivian", "age": 500}, # 老夫的大哥
    {"name": "cc", "age": 17.999}   # 老夫的"忘年交"
]
my_zip_list = []
for item in people_list_dict:
    my_zip_list.append(list(reversed(list(zip(item.values(), item.keys()))))) # 典型的函数式编程
    # 可以分解为一下即可步骤 ===》
    # 1. 将列表中的元素遍历，遍历变量为item，是dict类型;
    # 2. my_zip = zip(item.values(), item.keys())，将字典中的键值对转换成元组;
    # 3. zip_list = list(my_zip)，将得到的每一个字典所对应的元组转换成列表;
    # 4. zip_list_reversed = reversed(zip_list)，将每一个列表都倒置，保证"age"在前面;
    # 5. zip_list_reversed_list = list(zip_list_reversed)，转换成列表;
print(my_zip_list)
# 输出：[[('simba', 'name'), (1000, 'age')], [('vivian', 'name'), (500, 'age')], [('cc', 'name'), (17.999, 'age')]]
my_zip_list_sorted = sorted(my_zip_list)    # 排序
print(my_zip_list_sorted)
# 输出：[[(17.999, 'age'), ('cc', 'name')], [(500, 'age'), ('vivian', 'name')], [(1000, 'age'), ('simba', 'name')]]
result_list = []
for item in my_zip_list_sorted:
    result_list.append(tuple((item[0][0], item[1][0])))
print(result_list)  # 输出：[(17.999, 'cc'), (500, 'vivian'), (1000, 'simba')]

　　可以看出这不仅很麻烦(逻辑上 / 代码量上)，而且还存在这一个巨大的漏洞: 如果传入的列表中的字典一开始就是"age": xxx的形式，之后取反序就与我们所期待的结果背道而驰了。

 

----sorted()函数的高级用法 ===》

　　为了解决上述这一问题，sorted()函数也提供了关键字参数"key"，它是一个方法(可以说是匿名方法变量)变量，它的用处就是将序列中的元素遍历，依据这个方法的返回值进行由小到大的排序 ===》

# people_list_dict = [
#     {"name": "simba", "age": 1000}, # 老夫
#     {"name": "vivian", "age": 500}, # 老夫的大哥
#     {"name": "cc", "age": 17.999}   # 老夫的"忘年交"
# ]
# # 设列表的遍历变量为item，这句话的意思就是以item中的"age"对应的值为依据进行由小到大的排序
# sorted_lambda = sorted(people_list_dict, key = lambda dic:dic["age"])
# print(sorted_lambda)    # 输出的仍然是一个列表
# # 输出的值: [{'name': 'cc', 'age': 17.999}, {'name': 'vivian', 'age': 500}, {'name': 'simba', 'age': 1000}]

　　这样不仅可以那个巨大漏洞和繁杂的逻辑，而且处理之后的数据结构还能保持不变。