python类和接口函数练习题（Student、Classroom、Course、Teacher）

题目1.0

定义一个名为Student的类，它有两个属性：name和grades。其中，name属性是字符串类型，表示学生的姓名，grades属性是一个列表，表示学生的成绩。类中还有一个名为average_grade的接口函数，它可以计算学生的平均成绩。

class Student:
    def __init__(self, name, grades):
        self.name = name
        self.grades = grades
    
    def average_grade(self):
        if len(self.grades) == 0:
            return 0
        else:
            return sum(self.grades) / len(self.grades)

使用Student类：

# 创建一个学生对象
student = Student('Alice', [90, 85, 95, 80])

# 输出学生的姓名和成绩列表
print(student.name)
print(student.grades)

# 计算学生的平均成绩并输出结果
avg_grade = student.average_grade()
print('Average grade:', avg_grade)

题目2.0

定义一个名为Classroom的类，它有两个属性：name和students。其中，name属性是字符串类型，表示班级的名称，students属性是一个列表，表示班级的学生列表，其中每个元素都是一个Student对象。

Classroom类还有一个名为class_average_grade的接口函数，它可以计算整个班级的平均成绩。

修改上一个问题中的Student类，使其具有计算加权平均分的功能。为此，Student类需要添加一个新的属性weights，它是一个列表，表示每个成绩的权重。此外，Student类中的average_grade函数需要根据成绩的权重计算加权平均成绩。

class Student:
    def __init__(self, name, grades, weights):
        self.name = name
        self.grades = grades
        self.weights = weights
    
    def average_grade(self):
        if len(self.grades) == 0:
            return 0
        else:
            total_weight = sum(self.weights)
            weighted_sum = sum([g*w for g, w in zip(self.grades, self.weights)])
            return weighted_sum / total_weight

class Classroom:
    def __init__(self, name, students):
        self.name = name
        self.students = students
    
    def class_average_grade(self):
        if len(self.students) == 0:
            return 0
        else:
            total_students = len(self.students)
            total_grades = sum([s.average_grade() for s in self.students])
            return total_grades / total_students

使用Classroom类：

# 创建三个学生对象
student1 = Student('Alice', [90, 85, 95, 80], [0.2, 0.3, 0.3, 0.2])
student2 = Student('Bob', [80, 90, 85, 95], [0.2, 0.3, 0.3, 0.2])
student3 = Student('Charlie', [85, 80, 90, 85], [0.2, 0.3, 0.3, 0.2])

# 创建一个班级对象
classroom = Classroom('Class A', [student1, student2, student3])

# 输出班级的名称和学生列表
print(classroom.name)
for student in classroom.students:
    print(student.name, student.grades, student.weights)

# 计算班级的平均成绩并输出结果
print(classroom.class_average_grade())

题目3.0

定义一个名为Course的类，它继承自Classroom类。Course类有一个额外的属性teacher，表示课程的授课教师。Course类还有一个名为course_average_grade的接口函数，它可以计算整个课程的平均成绩，即所有班级的平均成绩的平均值。

class Student:
    def __init__(self, name, grades, weights):
        self.name = name
        self.grades = grades
        self.weights = weights
    
    def average_grade(self):
        if len(self.grades) == 0:
            return 0
        else:
            total_weight = sum(self.weights)
            weighted_sum = sum([g*w for g, w in zip(self.grades, self.weights)])
            return weighted_sum / total_weight

class Classroom:
    def __init__(self, name, students):
        self.name = name
        self.students = students
    
    def class_average_grade(self):
        if len(self.students) == 0:
            return 0
        else:
            total_students = len(self.students)
            total_grades = sum([s.average_grade() for s in self.students])
            return total_grades / total_students

class Course(Classroom):
    def __init__(self, name, students, teacher):
        super().__init__(name, students)
        self.teacher = teacher
    
    def course_average_grade(self):
        if len(self.students) == 0:
            return 0
        else:
            total_classes = len(self.students)
            total_grades = sum([c.class_average_grade() for c in self.students])
            return total_grades / total_classes

使用Course类：

# 创建三个学生对象
student1 = Student('Alice', [90, 85, 95, 80], [0.2, 0.3, 0.3, 0.2])
student2 = Student('Bob', [80, 90, 85, 95], [0.2, 0.3, 0.3, 0.2])
student3 = Student('Charlie', [85, 80, 90, 85], [0.2, 0.3, 0.3, 0.2])
# 创建两个班级对象
class1 = Classroom('Class A', [student1, student2])
class2 = Classroom('Class B', [student3])

# 创建一个课程对象
course = Course('Math', [class1, class2], 'Mr. Smith')

# 计算课程的平均成绩并输出结果
print(course.course_average_grade())

题目4.0

定义一个名为Teacher的类。Teacher类有两个属性，分别为name和course。Teacher类还有名为add_course和get_courses的接口函数，分别为将课程添加到教师课程列表和获取教师课程列表。为Course类也增加名为add_course和get_courses的接口函数。

class Student:
    def __init__(self, name, grades, weights):
        self.name = name
        self.grades = grades
        self.weights = weights

    def average_grade(self):
        if len(self.grades) == 0:
            return 0
        else:
            total_weight = sum(self.weights)
            weighted_sum = sum([g * w for g, w in zip(self.grades, self.weights)])
            return weighted_sum / total_weight


class Classroom:
    def __init__(self, name, students):
        self.name = name
        self.students = students

    def class_average_grade(self):
        if len(self.students) == 0:
            return 0
        else:
            total_students = len(self.students)
            total_grades = sum([s.average_grade() for s in self.students])
            return total_grades / total_students


class Course(Classroom):
    def __init__(self, name, students, teacher):
        super().__init__(name, students)
        self.teacher = teacher

    def add_course(self):
        self.teacher.courses.append(self)

    def get_courses(self):
        return [c.name for c in self.teacher.courses]

    def course_average_grade(self):
        if len(self.students) == 0:
            return 0
        else:
            total_classes = len(self.students)
            total_grades = sum([c.class_average_grade() for c in self.students])
            return total_grades / total_classes


class Teacher:
    def __init__(self, name):
        self.name = name
        self.courses = []

    def add_course(self, course):
        self.courses.append(course)

    def get_courses(self):
        return [c.name for c in self.courses]

使用Teacher类将课程添加到教师课程列表：

# 创建两个学生对象
student1 = Student('Alice', [90, 85, 95, 80], [0.2, 0.3, 0.3, 0.2])
student2 = Student('Bob', [80, 90, 85, 95], [0.2, 0.3, 0.3, 0.2])

students = [student1, student2]
# 创建一个教师对象
teacher = Teacher('Mr. Smith')
# 创建两个课程对象
course1 = Course('Math', students, teacher)
course2 = Course('English', students, teacher)
# 将课程添加到教师课程列表
teacher.add_course(course1)
teacher.add_course(course2)

# 获取教师课程列表
courses = teacher.get_courses()
print(courses)

使用Course类将课程添加到教师课程列表：

# 创建两个学生对象
student1 = Student('Alice', [90, 85, 95, 80], [0.2, 0.3, 0.3, 0.2])
student2 = Student('Bob', [80, 90, 85, 95], [0.2, 0.3, 0.3, 0.2])

students = [student1, student2]
# 创建一个教师对象
teacher = Teacher('Mr. Smith')
# # 创建两个课程对象
course1 = Course('Math', students, teacher)
course2 = Course('English', students, teacher)

# 将课程添加到教师课程列表
course1.add_course()
course2.add_course()

# 获取教师课程列表
courses = teacher.get_courses()
# 获取教师课程列表
print(courses)