Python 函数基础：从入门到上手，搞定代码复用的核心

函数是 Python 编程的 “核心积木”—— 不管是简单的数值计算，还是复杂的项目开发，函数都是实现代码复用、模块化的关键。很多新手刚接触 Python 时，只会写 “从头到尾” 的线性代码，遇到重复逻辑就复制粘贴，不仅代码臃肿，还难维护。而掌握函数后，能让代码更简洁、更易扩展，这也是从 “新手” 到 “入门” 的关键一步。本文就从最基础的逻辑入手，带你吃透 Python 函数的核心知识。

一、为什么需要函数？

先想一个场景：你需要计算不同矩形的面积，如果不用函数，代码可能是这样的：

# 计算第一个矩形面积
width1 = 5
height1 = 3
area1 = width1 * height1
print(f"矩形1面积：{area1}")

# 计算第二个矩形面积
width2 = 8
height2 = 4
area2 = width2 * height2
print(f"矩形2面积：{area2}")

# 计算第三个矩形面积
width3 = 6
height3 = 7
area3 = width3 * height3
print(f"矩形3面积：{area3}")

重复的计算逻辑写了 3 遍，要是需要修改计算规则（比如加边框），就得改 3 处，效率极低。

而用函数改写后，代码会变得简洁且易维护：

# 定义计算矩形面积的函数
def calculate_rect_area(width, height):
    area = width * height
    return area

# 调用函数计算不同矩形面积
print(f"矩形1面积：{calculate_rect_area(5, 3)}")
print(f"矩形2面积：{calculate_rect_area(8, 4)}")
print(f"矩形3面积：{calculate_rect_area(6, 7)}")

函数的核心价值：

1.代码复用：重复逻辑只写一次，多次调用；

2.模块化：将复杂功能拆分成小函数，逻辑更清晰；

3.易维护：修改功能只需改函数内部，无需改所有调用处；

4.可读性高：函数名能直观表达功能（如calculate_rect_area一看就知道是计算矩形面积）。

二、函数的核心语法：定义与调用

函数的使用分为两步：定义（造工具） 和调用（用工具），这是最基础也最核心的规则。

1. 函数定义的基本结构

def 函数名(参数列表):
    """函数文档字符串（可选，用于说明函数功能）"""
    # 函数体：要执行的代码逻辑
    代码语句
    return 返回值  # 可选，无return则返回None

核心说明：

• def：定义函数的关键字（必须小写）；
• 函数名：遵循 Python 命名规范（小写 + 下划线，如get_user_info），见名知意；
• 参数列表：括号内的变量，用于接收外部传递的数据，可空；
• 函数体：缩进（4 个空格 / 1 个 Tab）的代码块，是函数的核心逻辑；
• return：返回函数的执行结果，无return则默认返回None；
• 文档字符串：""" """包裹的注释，用help(函数名)可查看，建议养成写的习惯。

2. 最简示例：定义并调用函数

# 定义无参数、无返回值的函数
def say_hello():
    """打印问候语"""
    print("你好，Python函数！")

# 调用函数（必须调用才会执行函数体）
say_hello()  # 输出：你好，Python函数！

# 定义有参数、有返回值的函数
def add(a, b):
    """计算两个数的和并返回结果"""
    result = a + b
    return result

# 调用函数并接收返回值
sum1 = add(3, 5)
print(f"3+5={sum1}")  # 输出：3+5=8

# 查看函数文档
help(add)  # 输出：Help on function add in module __main__: ... 计算两个数的和并返回结果

三、函数的参数：灵活传递数据的关键

参数是函数与外部交互的 “接口”，Python 支持多种参数类型，掌握它们就能灵活控制函数的输入。

1. 位置参数（必传参数）

最基础的参数类型，调用时必须按顺序传递，数量要与定义时一致。

def print_info(name, age):
    """打印姓名和年龄"""
    print(f"姓名：{name}，年龄：{age}")

# 正确调用：按位置传参
print_info("小明", 18)  # 输出：姓名：小明，年龄：18

# 错误调用：参数数量不符（会报TypeError）
# print_info("小红")  # 缺少age参数

2. 关键字参数

调用时指定参数名，顺序可以任意，适合参数较多的场景。

# 关键字参数调用，顺序无关
print_info(age=20, name="小红")  # 输出：姓名：小红，年龄：20

# 混合位置参数和关键字参数（位置参数必须在前）
print_info("小刚", age=19)  # 输出：姓名：小刚，年龄：19

3. 默认参数

定义函数时给参数指定默认值，调用时可传可不传（不传则用默认值）。

def print_info(name, age=18):
    """打印姓名和年龄，年龄默认18"""
    print(f"姓名：{name}，年龄：{age}")

# 不传默认参数，使用默认值
print_info("小兰")  # 输出：姓名：小兰，年龄：18

# 传默认参数，覆盖默认值
print_info("小绿", 22)  # 输出：姓名：小绿，年龄：22

4. 可变参数：处理不确定数量的参数

当不确定要传递多少个参数时，可用*args（接收任意数量位置参数）和**kwargs（接收任意数量关键字参数）。

（1）*args：接收可变位置参数（打包成元组）

def sum_numbers(*args):
    """计算任意数量数字的和"""
    total = 0
    for num in args:
        total += num
    return total

# 调用时可传任意数量参数
print(sum_numbers(1, 2, 3))  # 输出：6
print(sum_numbers(5, 10, 15, 20))  # 输出：50
print(sum_numbers())  # 输出：0（无参数时args是空元组）

（2）**kwargs：接收可变关键字参数（打包成字典）

def print_user(**kwargs):
    """打印用户信息（任意字段）"""
    for key, value in kwargs.items():
        print(f"{key}：{value}")

# 调用时传任意数量关键字参数
print_user(name="小李", age=25, city="北京")
# 输出：
# 姓名：小李
# 年龄：25
# 城市：北京

四、返回值：让函数有 “输出”

return语句用于将函数的执行结果返回给调用者，核心规则：

1. return后可跟任意类型数据（数字、字符串、列表、字典等）；
2. 函数执行到return会立即结束，后续代码不会执行；
3. 无return则默认返回None；
4. 可返回多个值（用逗号分隔，返回时自动打包成元组）。

实例：

# 返回单个值
def get_circle_area(radius):
    """计算圆的面积（π取3.14）"""
    pi = 3.14
    area = pi * radius * radius
    return area

print(get_circle_area(5))  # 输出：78.5

# 返回多个值
def get_rect_info(width, height):
    """返回矩形的面积和周长"""
    area = width * height
    perimeter = 2 * (width + height)
    return area, perimeter  # 等价于 return (area, perimeter)

# 接收多个返回值（可解包成多个变量）
area, perimeter = get_rect_info(4, 6)
print(f"矩形面积：{area}，周长：{perimeter}")  # 输出：矩形面积：24，周长：20

五、函数的作用域：变量在哪里生效？

函数内部定义的变量和外部变量是 “隔离” 的，这就是作用域的概念，核心分两种：

1. 局部变量：函数内部定义，仅在函数内生效

def test_scope():
    # 局部变量：仅在test_scope函数内可用
    local_var = "我是局部变量"
    print(local_var)

test_scope()  # 输出：我是局部变量
# print(local_var)  # 报错：NameError，外部无法访问局部变量

2. 全局变量：函数外部定义，整个程序生效（函数内可读取，修改需加 global）

# 全局变量
global_var = "我是全局变量"

def read_global():
    # 函数内可读取全局变量
    print(global_var)

read_global()  # 输出：我是全局变量

def modify_global():
    # 想修改全局变量，必须先声明global
    global global_var
    global_var = "修改后的全局变量"

modify_global()
print(global_var)  # 输出：修改后的全局变量

六、实战案例：

def get_student_score():
    """获取用户输入的学生成绩，返回成绩列表"""
    scores = []
    while True:
        score_input = input("请输入学生成绩（输入q结束）：")
        if score_input.lower() == "q":
            break
        # 异常处理：确保输入的是数字
        try:
            score = float(score_input)
            scores.append(score)
        except ValueError:
            print("输入无效，请输入数字！")
    return scores

def calculate_score_stats(scores):
    """计算成绩的平均分、最高分、最低分，返回统计结果"""
    if not scores:  # 处理空列表
        return None
    avg_score = sum(scores) / len(scores)
    max_score = max(scores)
    min_score = min(scores)
    return {
        "平均分": round(avg_score, 2),
        "最高分": max_score,
        "最低分": min_score
    }

def print_score_stats(stats):
    """打印成绩统计结果"""
    if not stats:
        print("暂无成绩数据！")
        return
    print("\n===== 成绩统计结果 =====")
    for key, value in stats.items():
        print(f"{key}：{value}")

# 主逻辑：调用函数完成流程
if __name__ == "__main__":
    print("=== 学生成绩统计系统 ===")
    scores_list = get_student_score()
    score_stats = calculate_score_stats(scores_list)
    print_score_stats(score_stats)