1. 数据类型综合应用与数据处理 #

1.1 题目背景 #

你正在开发一个学生成绩管理系统，需要处理各种类型的数据：学生信息、成绩计算、数据验证和格式化输出。该系统需要能够处理不同数据类型之间的转换，并进行各种数据操作。

1.2 题目要求 #

请实现以下三个函数：

1.2.1. 数据类型转换与验证函数 #

def process_student_data(student_info):
    """
    处理学生数据，进行类型转换和验证

    参数:
        student_info: 字典，包含学生信息
        格式: {"name": "张三", "age": "20", "score": "85.5", "is_passed": "true"}

    返回:
        处理后的字典，所有值都转换为正确的Python数据类型
        如果数据无效，返回None

    要求:
        - name: 转换为字符串，去除首尾空格
        - age: 转换为整数，范围1-100
        - score: 转换为浮点数，范围0.0-100.0
        - is_passed: 转换为布尔值（"true"/"false"字符串转为True/False）
        - 如果任何转换失败或超出范围，返回None
    """

1.2.2. 成绩计算与格式化函数 #

def calculate_and_format_grades(students):
    """
    计算学生成绩等级并格式化输出

    参数:
        students: 学生信息列表，每个元素是字典
        格式: [{"name": "张三", "score": 85.5}, ...]

    返回:
        格式化后的成绩报告字符串

    要求:
        - 根据分数计算等级：>=90为A，>=80为B，>=70为C，>=60为D，<60为F
        - 计算平均分、最高分、最低分
        - 统计各等级人数
        - 使用f-string格式化输出，保留2位小数
        - 输出格式要美观，包含表格样式
    """

1.2.3. 数据筛选与统计函数 #

def analyze_student_performance(students, filters=None):
    """
    分析学生表现数据

    参数:
        students: 学生信息列表
        filters: 筛选条件字典，可选参数
        格式: {"min_score": 80, "max_score": 95, "grade": "A"}

    返回:
        分析结果字典，包含：
        {
            "total_count": 总人数,
            "filtered_count": 筛选后人数,
            "average_score": 平均分,
            "grade_distribution": 等级分布,
            "top_performers": 前3名学生,
            "pass_rate": 及格率
        }

    要求:
        - 支持按分数范围筛选
        - 支持按等级筛选
        - 计算及格率（>=60分）
        - 找出前3名高分学生
        - 处理边界情况（空数据、无效筛选条件等）
    """

1.3 测试用例 #

# 测试数据
test_students = [
    {"name": " 张三 ", "age": "20", "score": "85.5", "is_passed": "true"},
    {"name": "李四", "age": "19", "score": "92.0", "is_passed": "true"},
    {"name": "王五", "age": "21", "score": "78.3", "is_passed": "false"},
    {"name": "赵六", "age": "22", "score": "65.7", "is_passed": "true"},
    {"name": "钱七", "age": "20", "score": "45.2", "is_passed": "false"}
]

# 筛选条件测试
test_filters = [
    {"min_score": 80, "max_score": 95},
    {"grade": "A"},
    {"min_score": 60}
]

1.4 预期输出示例 #

=== 学生成绩管理系统 ===

处理后的学生数据:
姓名: 张三, 年龄: 20, 分数: 85.5, 及格: True

成绩报告:
==========================================
学生姓名    分数    等级
==========================================
张三       85.50    B
李四       92.00    A
王五       78.30    C
赵六       65.70    D
钱七       45.20    F
==========================================
平均分: 73.34
最高分: 92.00
最低分: 45.20
等级分布: A:1人, B:1人, C:1人, D:1人, F:1人

分析结果:
总人数: 5, 筛选后: 2, 平均分: 88.75, 及格率: 60.0%

2. 参考答案 #

2.1 代码 #

# 定义处理学生数据的函数，对数据进行类型转换与验证
def process_student_data(student_info):
    # 文档字符串：说明函数作用
    """
    处理学生数据，进行类型转换和验证
    """
    try:
        # 定义必须存在的字段
        required_fields = ["name", "age", "score", "is_passed"]
        # 检查每个必填字段是否在传入数据中
        for field in required_fields:
            # 如果字段缺失，返回None
            if field not in student_info:
                return None

        # 将姓名转换为字符串并去除首尾空格
        name = str(student_info["name"]).strip()
        # 检查姓名是否为空字符串
        if not name:
            return None

        # 尝试将年龄转换为整数并检查取值范围
        try:
            age = int(student_info["age"])
            # 年龄范围应在1到100之间
            if not (1 <= age <= 100):
                return None
        # 捕捉类型或取值转换异常
        except (ValueError, TypeError):
            return None

        # 尝试将分数转换为浮点数并检查取值范围
        try:
            score = float(student_info["score"])
            # 分数范围应在0.0到100.0之间
            if not (0.0 <= score <= 100.0):
                return None
        # 捕捉类型或取值转换异常
        except (ValueError, TypeError):
            return None

        # 将及格状态转为字符串并小写化
        is_passed_str = str(student_info["is_passed"]).lower()
        # 判断及格状态，转换为布尔值
        if is_passed_str == "true":
            is_passed = True
        elif is_passed_str == "false":
            is_passed = False
        else:
            # 若不是true/false字符串，返回None
            return None

        # 返回类型转换后，经过验证的学生信息字典
        return {
            "name": name,
            "age": age,
            "score": score,
            "is_passed": is_passed
        }
    # 捕获所有未预料的异常，返回None
    except Exception:
        return None

# 定义函数：计算学生成绩等级并格式化输出
def calculate_and_format_grades(students):
    # 文档字符串：函数描述
    """
    计算学生成绩等级并格式化输出
    """
    # 如果学生列表为空，返回提示字符串
    if not students:
        return "没有学生数据"

    # 定义嵌套函数，根据分数返回等级
    def get_grade(score):
        if score >= 90:
            return "A"
        elif score >= 80:
            return "B"
        elif score >= 70:
            return "C"
        elif score >= 60:
            return "D"
        else:
            return "F"

    # 创建带等级字典的新学生列表
    students_with_grades = []
    # 遍历学生列表，逐一计算等级并加入新列表
    for student in students:
        grade = get_grade(student["score"])
        students_with_grades.append({
            **student,
            "grade": grade
        })

    # 提取所有分数到新列表
    scores = [s["score"] for s in students_with_grades]
    # 计算平均分
    average_score = sum(scores) / len(scores)
    # 获取最高分
    max_score = max(scores)
    # 获取最低分
    min_score = min(scores)

    # 统计每个等级的人数
    grade_counts = {}
    for student in students_with_grades:
        grade = student["grade"]
        grade_counts[grade] = grade_counts.get(grade, 0) + 1

    # 格式化输出字符串
    result = "成绩报告:\n"
    # 添加分隔线
    result += "=" * 42 + "\n"
    # 添加表头
    result += f"{'学生姓名':<10} {'分数':<8} {'等级':<4}\n"
    # 添加分隔线
    result += "=" * 42 + "\n"

    # 格式化输出每个学生的信息
    for student in students_with_grades:
        result += f"{student['name']:<10} {student['score']:<8.2f} {student['grade']:<4}\n"

    # 添加分隔线
    result += "=" * 42 + "\n"
    # 添加平均分
    result += f"平均分: {average_score:.2f}\n"
    # 添加最高分
    result += f"最高分: {max_score:.2f}\n"
    # 添加最低分
    result += f"最低分: {min_score:.2f}\n"

    # 构造等级分布字符串，如“B:2人, D:1人”
    grade_dist = ", ".join([f"{grade}:{count}人" for grade, count in sorted(grade_counts.items())])
    result += f"等级分布: {grade_dist}\n"

    # 返回格式化后的结果
    return result

# 定义函数：分析学生表现数据，可以筛选并统计
def analyze_student_performance(students, filters=None):
    # 文档字符串：描述函数作用
    """
    分析学生表现数据
    """
    # 如果没有学生数据，返回默认的分析结果
    if not students:
        return {
            "total_count": 0,
            "filtered_count": 0,
            "average_score": 0.0,
            "grade_distribution": {},
            "top_performers": [],
            "pass_rate": 0.0
        }

    # 统计总人数
    total_count = len(students)

    # 拷贝学生列表
    filtered_students = students.copy()

    # 如果有筛选条件，则应用筛选
    if filters:
        # 如果有最小分数筛选，筛去低于该分数的学生
        if "min_score" in filters:
            filtered_students = [s for s in filtered_students if s["score"] >= filters["min_score"]]
        # 如果有最大分数筛选，筛去高于该分数的学生
        if "max_score" in filters:
            filtered_students = [s for s in filtered_students if s["score"] <= filters["max_score"]]
        # 如果有等级筛选，根据成绩等级过滤
        if "grade" in filters:
            # 定义返回成绩等级的辅助函数
            def get_grade(score):
                if score >= 90: return "A"
                elif score >= 80: return "B"
                elif score >= 70: return "C"
                elif score >= 60: return "D"
                else: return "F"
            # 取目标等级
            target_grade = filters["grade"]
            # 只保留等级等于目标等级的学生
            filtered_students = [s for s in filtered_students if get_grade(s["score"]) == target_grade]

    # 计算筛选后学生数量
    filtered_count = len(filtered_students)

    # 如果筛选后有学生，计算平均分，否则为0
    if filtered_students:
        average_score = sum(s["score"] for s in filtered_students) / len(filtered_students)
    else:
        average_score = 0.0

    # 统计筛选后学生各等级人数
    grade_distribution = {}
    for student in filtered_students:
        score = student["score"]
        if score >= 90: grade = "A"
        elif score >= 80: grade = "B"
        elif score >= 70: grade = "C"
        elif score >= 60: grade = "D"
        else: grade = "F"
        grade_distribution[grade] = grade_distribution.get(grade, 0) + 1

    # 前三名高分学生，按分数降序排列取前3
    sorted_students = sorted(filtered_students, key=lambda x: x["score"], reverse=True)
    top_performers = sorted_students[:3]

    # 筛选后及格人数（分数大于等于60）
    passed_count = sum(1 for s in filtered_students if s["score"] >= 60)
    # 计算及格率（百分比），若筛选人数为0则为0%
    pass_rate = (passed_count / filtered_count * 100) if filtered_count > 0 else 0.0

    # 返回分析结果字典
    return {
        "total_count": total_count,
        "filtered_count": filtered_count,
        "average_score": average_score,
        "grade_distribution": grade_distribution,
        "top_performers": top_performers,
        "pass_rate": pass_rate
    }

# 主程序入口，输出初始提示
print("=== 学生成绩管理系统 ===")

# 定义测试用的学生数据列表
test_students = [
    {"name": " 张三 ", "age": "20", "score": "85.5", "is_passed": "true"},
    {"name": "李四", "age": "19", "score": "92.0", "is_passed": "true"},
    {"name": "王五", "age": "21", "score": "78.3", "is_passed": "false"},
    {"name": "赵六", "age": "22", "score": "65.7", "is_passed": "true"},
    {"name": "钱七", "age": "20", "score": "45.2", "is_passed": "false"}
]

# 测试数据类型转换部分
print("1. 数据类型转换测试:")
# 存放处理后的学生数据
processed_students = []
# 遍历测试数据，逐个进行数据处理并输出结果
for i, student in enumerate(test_students):
    processed = process_student_data(student)
    if processed:
        processed_students.append(processed)
        print(f"学生{i+1}: {processed}")
    else:
        print(f"学生{i+1}: 数据无效")

# 测试成绩计算与格式化输出
print("\n2. 成绩计算与格式化:")
if processed_students:
    grade_report = calculate_and_format_grades(processed_students)
    print(grade_report)

# 测试数据筛选和统计分析
print("3. 数据筛选与统计:")
# 准备三组不同的筛选条件
test_filters = [
    {"min_score": 80},
    {"grade": "A"},
    {"min_score": 60, "max_score": 90}
]

# 遍历每组筛选条件，输出分析结果
for i, filter_condition in enumerate(test_filters, 1):
    print(f"\n筛选条件{i}: {filter_condition}")
    result = analyze_student_performance(processed_students, filter_condition)
    print(f"总人数: {result['total_count']}, 筛选后: {result['filtered_count']}")
    print(f"平均分: {result['average_score']:.2f}, 及格率: {result['pass_rate']:.1f}%")
    print(f"等级分布: {result['grade_distribution']}")
    print(f"前3名: {[s['name'] for s in result['top_performers']]}")

# 测试边界与异常情况
print("\n4. 边界情况测试:")

# 构造无效数据进行处理测试
invalid_data = {"name": "", "age": "150", "score": "abc", "is_passed": "maybe"}
result = process_student_data(invalid_data)
print(f"无效数据处理: {result}")

# 测试空数据分析
empty_result = analyze_student_performance([])
print(f"空数据分析: {empty_result}")

2.2 运行结果示例 #

=== 学生成绩管理系统 ===
1. 数据类型转换测试:
学生1: {'name': '张三', 'age': 20, 'score': 85.5, 'is_passed': True}
学生2: {'name': '李四', 'age': 19, 'score': 92.0, 'is_passed': True}
学生3: {'name': '王五', 'age': 21, 'score': 78.3, 'is_passed': False}
学生4: {'name': '赵六', 'age': 22, 'score': 65.7, 'is_passed': True}
学生5: {'name': '钱七', 'age': 20, 'score': 45.2, 'is_passed': False}

2. 成绩计算与格式化:
成绩报告:
==========================================
学生姓名       分数       等级  
==========================================
张三         85.50    B   
李四         92.00    A   
王五         78.30    C   
赵六         65.70    D   
钱七         45.20    F   
==========================================
平均分: 73.34
最高分: 92.00
最低分: 45.20
等级分布: A:1人, B:1人, C:1人, D:1人, F:1人

3. 数据筛选与统计:

筛选条件1: {'min_score': 80}
总人数: 5, 筛选后: 2
平均分: 88.75, 及格率: 100.0%
等级分布: {'B': 1, 'A': 1}
前3名: ['李四', '张三']

筛选条件2: {'grade': 'A'}
总人数: 5, 筛选后: 1
平均分: 92.00, 及格率: 100.0%
等级分布: {'A': 1}
前3名: ['李四']

筛选条件3: {'min_score': 60, 'max_score': 90}
总人数: 5, 筛选后: 3
平均分: 76.50, 及格率: 100.0%
等级分布: {'B': 1, 'C': 1, 'D': 1}
前3名: ['张三', '王五', '赵六']

4. 边界情况测试:
无效数据处理: None
空数据分析: {'total_count': 0, 'filtered_count': 0, 'average_score': 0.0, 'grade_distribution': {}, 'top_performers': [], 'pass_rate': 0.0}

2.3 知识点覆盖 #

1. 数据类型转换：字符串、整数、浮点数、布尔值之间的转换
2. 数据验证：类型检查、范围验证、空值处理
3. 字符串操作：strip()、格式化、f-string使用
4. 浮点数处理：精度控制、格式化输出
5. 布尔运算：条件判断、逻辑运算
6. 整数运算：算术运算、比较运算
7. 数据结构操作：列表、字典的增删改查
8. 异常处理：try-except、边界条件处理
9. 算法应用：排序、统计、筛选
10. 实际应用：学生管理系统、数据分析