CodeSalt | Python解决按学生年龄排序的实际问题

mingsquall

Python解决按学生年龄排序的实际问题

问题:定义一个Class:包含姓名name、性别gender、年龄age,需要按年龄给学生排序。
输入:包含学生对象的List
输出:按照年龄age进行排序好的List

思路1:使用冒泡排序,比较相邻的学生,如果第一个学生的age值比第二个学生的age值大,那么就整体交换这两个元素。持续每次对越来越少的元素重复上面的步骤。一直到没有任何一对学生需要比较。
思路2:使用Python內建方法sorted()

(这个问题其实是笔者面试时候手写的一个实际问题,比较面向小白,我们可以通过这样一个简单的问题复习Python的一些基础知识点)

1. 前期准备

1.1 定义Class

class Student(object):
    def __init__(self, name, gender, age):
        self.__name = name
        self.__gender = gender
        self.__age = age
    
    # 取得age属性
    def getAge(self):
        return self.__age
    
    # 打印
    def printStudent(self):
        return self.__name, self.__gender, self.__age

1.2 生成包含随机学生对象的List

# 生成包含随机学生对象的list
def generateStudent(num):
    # num为需要生成的测试对象数
    list = []
    for i in range(num):
        randName = ''.join(random.sample(string.ascii_letters, 4))
        randGender = random.choice(['Male', 'FeMale'])
        randAge = random.randint(10,30)
        s = Student(randName, randGender, randAge)
        list.append(s)
    return list

2. 开始排序

2.1 使用冒泡排序

思路已在开头介绍,我们直接来看代码:

def sortStudent(list):
    for i in range(len(list)):
        for j in range(1, len(list)-i):
            if list[j-1].getAge() > list[j].getAge():
                list[j-1], list[j] = list[j], list[j-1]
    return list

2.2 使用Python內建方法sorted

配合lambda表达式使用,非常简洁,代码如下:

sorted(list, key=lambda student: student.getAge()) # 将对象的age属性作为排序的Key

我们在这里补充一下 sorted()lambda表达式 的相关知识点:

2.2.1 sorted(iterable, *, key=None, reverse=False)

官方文档
关于参数的说明:
key specifies a function of one argument that is used to extract a comparison key from each list element: key=str.lower. The default value is None (compare the elements directly).
reverse is a boolean value. If set to True, then the list elements are sorted as if each comparison were reversed.

  • key里接收的可以是某一个指定的函数(如lambda函数)返回的一个值,作为指定的比较依据。
  • reverse默认是False从小到大排序,设置为True后可以从大到小。

关于稳定性的说明:
The built-in sorted() function is guaranteed to be stable.

(看到官方文档的说明中写道,这个方法是保证稳定的哟!)

  • 关于原理:Python内置的sorted()方法背后使用的是Timsort算法,当数据越接近Ordered Data的时候,时间复杂度越接近O(N)。在我们的这个问题中,年龄属性是比较符合Ordered Data的。感兴趣的可以点击Timsort查看更多哈!

2.2.2 lambda表达式

直接看一个简单的例子就能明白了~

>>> pairs = [('one',1),('two',2),('three',3),('five',5),('zero',0),('four',4)]
>>> sorted(pairs, key=lambda pair: pair[1]) # List中每个tuple对的排序依据是tuple中的第2个值
[('zero', 0), ('one', 1), ('two', 2), ('three', 3), ('four', 4), ('five', 5)] 

3. 执行测试

构建测试用的随机数据,计算两种方法的执行时间进行比较~

if __name__ == '__main__':

    # list 形式是[('hZDw', 'FeMale', 17)...]
    list = generateStudent(10000)

    # 方法1:使用冒泡排序
    start_Time1 = time.time()
    sortStudent(list)
    end_Time1 = time.time()
    # 方法1中,使用10000个测试数据的排序时间是22.243秒以上(非精确)
    print('%s cost time %s' % ('sortStudent' , end_Time1 - start_Time1))


    # 方法2:使用Python内建的sorted方法+lambda表达式
    # 由于sorted方法背后使用的timsort方法,当数据越接近Ordered data的时候,时间复杂度越接近O(N)。
    # 在这个例子里面,年龄属性是比较接近Ordered data的。
    start_Time2 = time.time()
    sorted(list, key=lambda student: student.getAge()) # 将对象的属性作为排序的Key
    end_Time2 = time.time()
    print('%s cost time %s' % ('sorted' , end_Time2 - start_Time2))

测试结果:
使用方法1(冒泡排序),当测试数据量是10000个的时候,排序时间是22.243秒左右。
使用方法2(內建方法),当测试数据量是1000000个的时候,排序时间的0.575秒左右。
虽然不是很精确,但差别显然可见啦!


以上。

如有错误,还望指正~
完整实现及测试可在Github找到:ActualProblem-Solution
感谢。

阅读 3.1k

CodeSalt
汲取代码微量元素。

[Hard:Make:m]

19 声望
2 粉丝
0 条评论

[Hard:Make:m]

19 声望
2 粉丝
文章目录
宣传栏