Python练习题 —类，列表，装饰器结合

题目：新建学生类（学号，姓名，年纪）
# 随机生成10个学生放入列表(年纪随机即可)，按学生的年纪对列表中的学生排序
# 四种方法，并结合装饰器统计四种方法的时间开销

 总代码

import random
import time

# 定义 Student 类来表示学生
class Student:
    def __init__(self, sid, name, age):  # 初始化方法，用于创建学生对象时设置属性
        self.sid = sid
        self.name = name
        self.age = age

    def get_age(self):  # 方法，返回学生年龄的字符串表示
        return f"年龄:{self.age}"

    def show_student(self):  # 方法，返回学生完整信息的字符串表示
        return f"id:{self.sid}, 名字:{self.name}, 年龄:{self.age}"

student = []  # 创建一个空列表用于存储学生对象

# 生成 10 个学生对象并添加到列表中
for i in range(10):  
    sid = 101 if not student else student[-1].sid + 1  # 根据列表情况生成学号
    s0 = Student(sid, f"小明{i + 1}号", random.randint(15, 26))  # 创建学生对象
    student.append(s0)  # 将学生对象添加到列表

# 定义装饰器函数，用于计算被装饰函数的执行时间
def time_cost(f):  
    def calc():  # 装饰器内部的函数
        start = time.time()  # 记录开始时间
        f()  # 执行被装饰的函数
        print(f"{f.__name__}时间开销:{time.time() - start}")  # 计算并打印时间开销
    return calc  # 返回内部函数

# 使用装饰器装饰 s_sorted 函数
@time_cost  
def s_sorted():  
    new_student = sorted(student, key=lambda s: s.age)  # 对学生列表按年龄排序
    for n in new_student:  # 遍历排序后的列表
        print(n.show_student())  # 打印每个学生的信息

s_sorted()  # 调用函数

# 使用装饰器装饰 s_sort 函数
@time_cost
def s_sort():  
    student.sort(key=lambda s: s.age)  # 直接对原列表按年龄排序
    for n in student:  # 遍历排序后的列表
        print(n.show_student())  # 打印每个学生的信息

s_sort()  # 调用函数

# 使用装饰器装饰 mp 函数，实现冒泡排序
@time_cost
def mp():  
    for i in range(len(student) - 1):  # 外层循环控制排序轮数
        for j in range(len(student) - i - 1):  # 内层循环进行每一轮的比较和交换
            if student[j].get_age() > student[j + 1].get_age():  # 如果前一个年龄大于后一个
                student[j], student[j + 1] = student[j + 1], student[j]  # 交换两个学生对象的位置
    for s in student:  # 遍历排序后的列表
        print(s.show_student())  # 打印每个学生的信息

mp()  # 调用函数

# 使用装饰器装饰 px 函数，实现选择排序
@time_cost
def px():  
    for i in range(len(student) - 1):  # 外层循环控制排序轮数
        min_age = i  # 初始化最小年龄的索引
        for j in range(i + 1, len(student)):  # 内层循环寻找最小年龄的索引
            if student[min_age].get_age() > student[j].get_age():  # 如果当前最小年龄大于其他位置的年龄
                min_age = j  # 更新最小年龄的索引
        student[i], student[min_age] = student[min_age], student[i]  # 交换位置
    for s in student:  # 遍历排序后的列表
        print(s.show_student())  # 打印每个学生的信息

px()  # 调用函数

分析

1.定义student类

import random
import time

class Student:
    def __init__(self, sid, name, age):
        self.sid = sid
        self.name = name
        self.age = age

    def get_age(self):
        return f"年龄:{self.age}"

    def show_student(self):
        return f"id:{self.sid}, 名字:{self.name}, 年龄:{self.age}"

（1）__init__ 方法用于初始化学生对象的学号、姓名和年龄。
（2）get_age 方法返回学生年龄的字符串表示。
（3）show_student 方法返回包含学生学号、姓名和年龄的字符串表示。

2.创建空列表

student = []
for i in range(10):
    sid = 101 if not student else student[-1].sid + 1
    s0 = Student(sid, f"小明{i + 1}号", random.randint(15, 26))
    student.append(s0)

  创建了一个空列表 student ，然后通过循环生成 10 个学生对象并添加到列表中。
（1）学号 sid 的生成规则是，如果列表为空则为 101 ，否则为上一个学生的学号加 1 。
（2）姓名以 "小明" 加上编号生成。
（3）年龄通过 random.randint(15, 26) 随机生成在 15 到 26 之间。

3.装饰器函数 time_cost

def time_cost(f):
    def calc():
        start = time.time()
        f()
        print(f"{f.__name__}时间开销:{time.time() - start}")
    return calc

内部定义的 calc 函数记录了函数执行前的时间 start ，执行被装饰的函数 f ，然后计算并打印出函数执行的时间开销。

4.装饰 s_sorted 函数

@time_cost
def s_sorted():
    new_student = sorted(student, key=lambda s: s.age)
    for n in new_student:
        print(n.show_student())

（1）函数内部使用 sorted 函数对 student 列表按照年龄进行排序，并将排序结果存储在 new_student 列表中。
（2）然后遍历 new_student 列表，打印每个学生的信息。

5. 装饰 s_sort 函数

@time_cost
def s_sort():
    student.sort(key=lambda s: s.age)
    for n in student:
        print(n.show_student())

（1）直接对 student 列表本身使用 sort 方法按照年龄进行排序。
（2）然后遍历 student 列表，打印每个学生的信息。

6.装饰 mp 函数

@time_cost
def mp():
    for i in range(len(student) - 1):
        for j in range(len(student) - i - 1):
            if student[j].get_age() > student[j + 1].get_age():
                student[j], student[j + 1] = student[j + 1], student[j]
    for s in student:
        print(s.show_student())

这是冒泡排序的实现。
（1）通过两层循环比较相邻的学生年龄，如果前一个大于后一个就交换位置。
（2）最后遍历排序后的 student 列表，打印每个学生的信息。

7.装饰 px 函数

@time_cost
def px():
    for i in range(len(student) - 1):
        min_age = i
        for j in range(i + 1, len(student)):
            if student[min_age].get_age() > student[j].get_age():
                min_age = j
        student[i], student[min_age] = student[min_age], student[i]

    for s in student:
        print(s.show_student())

（1）外层循环控制排序轮数，内层循环找到每一轮的最小年龄学生的索引 min_age ，然后与当前位置的学生交换。最后遍历排序后的 student 列表，打印每个学生的信息。