返回首页

Roadmap
更新于 2026年11月14日 全文 1252 字未阅读

第 4.2 节 函数进阶:处理不同的数据任务#

预计学习时长: 30 分钟

本节目标:

  • 会用默认参数让一个函数适配多种场景;
  • 会把列表、字典作为参数传进函数;
  • 知道默认参数用可变对象时的坑,以及 None 的正确写法;
  • 理解「一个函数只干一件事」,学会用多个小函数组合出大功能。

函数进阶的三件事#

上一节的函数只能「一种输入 → 一种输出」。要让它真正好用,需要解决三个问题:

  1. 某些参数每次都一样? → 默认参数;
  2. 要处理的数据不止一条? → 把列表当参数;
  3. 逻辑变复杂了? → 拆成几个小函数组合。

Case 31:计算不同班级的平均成绩——使用默认参数#

任务: 写一个按及格线计算通过人数的函数,默认及格线是 60,但允许临时指定。

def count_passed(scores, threshold=60):
    passed = 0
    for score in scores:
        if score >= threshold:
            passed += 1
    return passed


class_a = [88, 95, 76, 45, 61]
class_b = [92, 78, 85, 90, 73]

print("A 班默认及格线:", count_passed(class_a))
print("A 班按 70 分及格:", count_passed(class_a, threshold=70))
print("B 班按 80 分及格:", count_passed(class_b, 80))

输出:

A 班默认及格线: 4
A 班按 70 分及格: 3
B 班按 80 分及格: 3

关键点

  • threshold=60 是默认参数。调用时不传它就用 60,传了就用你传的;
  • 有默认值的参数必须放在没有默认值的参数后面。写成 def f(threshold=60, scores) 会报 SyntaxError;
  • count_passed(class_b, 80) 是位置传参,count_passed(class_a, threshold=70) 是关键字传参。同一段代码里最好统一用一种,可读性差别很大;
  • 默认参数让函数「有一个好用的默认值,同时保留灵活性」——这是 Python 里非常常见的设计。

默认参数不要用可变对象 写成 def f(items=[]): 是错的:这个列表会在所有调用之间共享,函数改一次它,下次调用就带着上次的脏数据。 正确写法是 def f(items=None):,然后在函数体里 if items is None: items = []。 这是 Python 面试和实际项目里的高频坑。

Case 32:批量处理学生成绩——使用列表作为函数参数#

任务: 写一个函数,接收一个学生字典列表,把每个人的成绩换算成等级并存回去。

def to_letter_grade(score):
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 60:
        return "C"
    return "D"


def apply_grades(students, key="score"):
    for student in students:
        student["grade"] = to_letter_grade(student[key])
    return students


students = [
    {"name": "小明", "score": 92},
    {"name": "小红", "score": 78},
    {"name": "小刚", "score": 55},
]

apply_grades(students)

for student in students:
    print(f"{student['name']}: {student['score']} -> {student['grade']}")

输出:

小明: 92 -> A
小红: 78 -> C
小刚: 55 -> D

关键点

  • 函数接收字典组成的列表,遍历时用 student["name"] 这样的键访问,比 student[0] 好懂得多;
  • apply_grades 直接修改了传进来的字典,这叫就地修改(原地修改)。好处是调用后不用再接收返回值;
  • key="score" 让函数可以处理不同字段名,比如传 key="final_score" 就能对另一个分数字段评级;
  • 「一个函数只干一件事」:to_letter_grade 只管算等级,apply_grades 只管批量调用。两个小函数组合起来,比一个又长又乱的函数好维护得多。

什么时候该返回新对象,什么时候就地改? 小数据、你自己控制调用方式 → 就地改最方便。 但如果传进去的是重要数据、又不想被意外改动 → 返回一份新的(比如 student.copy() 或列表推导生成新列表)。 函数的默认约定是「不改你的输入」,破坏了调用者的预期就容易出 bug。

Case 33:构建数据统计工具——使用多个函数完成组合任务#

任务: 把前面学过的几个小函数组合起来,做一个完整的成绩统计流程:清洗 → 分级 → 汇总 → 出报告。

def clean_scores(raw_scores):
    valid = []
    for item in raw_scores:
        if item is None:
            continue
        if 0 <= item <= 100:
            valid.append(float(item))
    return valid


def to_letter_grade(score):
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 60:
        return "C"
    return "D"


def build_report(scores, title="成绩分析报告"):
    clean = clean_scores(scores)
    if not clean:
        return f"{title}\n(没有有效数据)"

    lines = [title, "-" * 20]
    lines.append(f"有效人数:{len(clean)}")
    lines.append(f"平均分:{sum(clean) / len(clean):.2f}")
    lines.append(f"最高分:{max(clean)}")
    lines.append(f"最低分:{min(clean)}")

    counts = {}
    for score in clean:
        grade = to_letter_grade(score)
        counts[grade] = counts.get(grade, 0) + 1

    for grade in ["A", "B", "C", "D"]:
        lines.append(f"{grade} 等级:{counts.get(grade, 0)} 人")

    return "\n".join(lines)


print(build_report([92, None, 78, -5, 88, 150, 61]))

输出:

成绩分析报告
--------------------
有效人数:4
平均分:79.75
最高分:92.0
最低分:61.0
A 等级:1 人
B 等级:1 人
C 等级:2 人
D 等级:0 人

关键点

  • build_report 是组合层:它不自己算平均分,而是调用 clean_scores 和 to_letter_grade。各层各司其职;
  • "\n".join(lines) 把一个字符串列表拼成多行报告。lines.append(...) 逐行构造,比一个大 f-string 更好维护;
  • counts.get(grade, 0) 用默认值 0 兜住「某个等级一个人都没有」的情况;
  • 报告用 return 交出来,而不是 print 出来。这样你可以把它存进文件、发到网页、或者传给别的函数——这就是 return 的价值。

好代码和烂代码的区别之一:层次 烂代码是「一个函数从头处理到尾,200 行」; 好代码是「三个各干一件事的小函数,加一个把它们串起来的函数」。 当你想改「什么算及格」的时候,只需要改 to_letter_grade 一个地方。这就是可维护性。

本节小结#

技巧写法用途
默认参数def f(x, threshold=60):提供好用的默认值
关键字参数f(x, threshold=70)传参更清楚
列表参数def f(students):批量处理数据
就地修改d["k"] = v直接改传入的对象
函数组合在一个函数里调用另一个分层设计

三条核心规矩:默认参数放后面、默认参数别用可变对象、函数返回结果而不是打印结果。

随堂练习#

  1. 写一个 clamp(value, minimum=0, maximum=100) 函数,把数值限制在给定区间内;
  2. 写一个 count_by_grade(students) 函数,返回一个字典,形如 {"A": 1, "B": 2, ...};
  3. 把 Case 33 的 build_report 改成能处理学生字典列表(从 student["score"] 取分数)。
点击查看参考答案
# 练习 1
def clamp(value, minimum=0, maximum=100):
    if value < minimum:
        return minimum
    if value > maximum:
        return maximum
    return value


print(clamp(150), clamp(-5), clamp(80))

# 练习 2
def to_letter_grade(score):
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 60:
        return "C"
    return "D"


def count_by_grade(students):
    counts = {}
    for student in students:
        grade = to_letter_grade(student["score"])
        counts[grade] = counts.get(grade, 0) + 1
    return counts


print(count_by_grade([{"score": 92}, {"score": 78}, {"score": 88}]))

# 练习 3
def build_report(students, title="成绩分析报告"):
    scores = [s["score"] for s in students if s.get("score") is not None]
    clean = clean_scores(scores)
    if not clean:
        return f"{title}\n(没有有效数据)"
    lines = [title, "-" * 20, f"有效人数:{len(clean)}",
             f"平均分:{sum(clean) / len(clean):.2f}"]
    return "\n".join(lines)

练习 2 里注意用 counts.get(grade, 0) 而不是直接 counts[grade] += 1——后者在键不存在时会报 KeyError。

下一节预告 函数写得再好,也都挤在一个文件里。下一节我们把函数拆进不同模块,用 import 互相调用——这是从「一段代码」到「一个项目」的第一步。

阅读 --