python排序sort&sorted

1.语法详解

#list内置sort()方法用来排序
list.sort(key=None, reverse=False)
#全局sorted()方法来对可迭代的序列排序生成新的序列
sorted(iterable, key=None, reverse=False)

key :主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse: 排序规则，reverse = True 降序， reverse = False 升序（默认）。

2.排序基础

1.sorted

mylist = [4,6,0,1,2,3]
sort_list = sorted(mylist)
print(sort_list)    #排序后的序列：[0, 1, 2, 3, 4, 6]
print(mylist)       #原序列：[4, 6, 0, 1, 2, 3]

2.sort

mylist = [4,6,0,1,2,3]
mylist.sort()
print(mylist)    #排序后改变了原序列：[0, 1, 2, 3, 4, 6]

不同点：
list.sort()方法仅被定义在list中，相反地sorted()方法对所有的可迭代序列都有效。

#dict
new_list = sorted({1: 'D', 2: 'B', 4: 'B', 3: 'E', 5: 'A'})
print(new_list)		#[1, 2, 3, 4, 5]

#tuple
new_list = sorted((4,5,0,1,2,6))
print(new_list)		#[0, 1, 2, 4, 5, 6]

3.升序和降序

mylist = [4,5,0,1,2,6]
mylist.sort()   #默认reverse=False
print(mylist)   #[0, 1, 2, 4, 5, 6]
mylist.sort(reverse=True)
print(mylist)   #[6, 5, 4, 2, 1, 0]

4.key参数/函数

list.sort()和sorted()函数增加了key参数来指定一个函数，此函数将在每个元素比较前被调用

1.通过key指定的函数来忽略字符串的大小写

ll1 = sorted("This is a test string from Andrew".split(), key=str.lower)
print(ll1)      #['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
ll2 = sorted("This is a test string from Andrew".split())
print(ll2)      #['Andrew', 'This', 'a', 'from', 'is', 'string', 'test']

2.根据特定属性排序
key参数的值为一个函数，此函数只有一个参数且返回一个值用来进行比较

student_tuples = [
        ('john', 'A', 15),
        ('jane', 'B', 10),
        ('dave', 'B', 12),
]
#结合lambda， 这里是按照每个元组的第三个元素来排序
student_tuples.sort(key=lambda s: s[2])
print(student_tuples)       #[('jane', 'B', 10), ('dave', 'B', 12), ('john', 'A', 15)]

3.根据对象的属性进行对象排序

class Student:
    def __init__(self, name, grade, age):
        self.name = name
        self.grade = grade
        self.age = age
    def __repr__(self):
        return repr((self.name, self.grade, self.age))
    

student_objects = [
        Student('john', 'A', 15),
        Student('jane', 'B', 12),
        Student('dave', 'B', 10),
]

#通过对象的属性age排序
student_objects.sort(key=lambda student: student.age)
print(student_objects)      #[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

说明：
repr实例1

#关于__repr__， __str__是作为字符串打印时调用
#可能的表示出一个对象来源的类以及继承关系
#如果不添加方法__repr__
print(student_objects[0])			
#<__main__.Student object at 0x000002BA66EDD6A0>

#添加后
('dave', 'B', 10)

repr实例2

import datetime
today = datetime.datetime.now()
print(str(today))
# 2020-12-16 13:46:30.599880
print(repr(today))
# datetime.datetime(2020, 12, 16, 13, 46, 30, 599880)

4.多个排序规则
内置方法：

# import re
# 
student = [{
        'sid': 1,
        'high':176,
        'weight':61
    },
    {
        'sid': 2,
        'high':176,
        'weight':59
    },
    {
        'sid': 3,
        'high':165,
        'weight':62
    },
    {
        'sid': 4,
        'high':180,
        'weight':75
    },
    {
        'sid': 5,
        'high':175,
        'weight':61
    },
    {
        'sid': 6,
        'high':178,
        'weight':61
    },
    {
        'sid': 7,
        'high':165,
        'weight':64
    },
    {
        'sid': 8,
        'high':171,
        'weight':68
    },
    {
        'sid': 9,
        'high':171,
        'weight':68
    },
    ]

#先按照学生的身高排序，如果身高相同，则按照体重排序
student.sort(key=lambda k: (k["high"],k["weight"]))

算法实现
学校举行运动会，学生们按编号（1,2,3……n）进行标识，现需要按照身高由低到高排列，对身高相同的人，按体重由轻到重排列；对于身高体重都相同的人，维持原有的编号顺序关系。请输出排列后的学生编号

def test():
    n = int(input())
    high = input().split(" ")
    weight = input().split(" ")
    data = []
    for i in range(1,n+1):
        info = {"id":i,
                "high":int(high[i-1]),
                "weight":int(weight[i-1])}
        data.append(info)
    
    #冒泡排序
    for i in range(len(data)):
        for j in range(i+1,len(data)):
            if data[j-1]["high"]>data[j]["high"]:
                data[j-1],data[j] = data[j],data[j-1]
            if data[j-1]["high"]==data[j]["high"]:
                if data[j-1]["weight"]>data[j]["weight"]:
                    data[j-1],data[j] = data[j],data[j-1]
    for info in data:
        print(info["id"], end=" ")
test()
#输入
5
172 180 178 172 177
65 70 62 68 71
#输出
1 4 5 3 2