Python 函数 —— 代码复用的基石

Python 函数 —— 代码复用的基石

一、函数的定义与基本语法

在 Python 中，函数是代码复用和逻辑封装的核心单元。通过 def 关键字定义函数，基本语法如下：

def function_name(parameters):
    """文档字符串：描述函数功能"""
    # 函数逻辑
    return result  # 可选，默认返回None

示例：计算两数之和

def calculate_sum(a, b):
    """返回两个数的和"""
    return a + b

result = calculate_sum(3, 5)  # 调用函数，输出8

二、参数传递的艺术

函数的灵活性很大程度上取决于参数的设计，Python 支持多种参数类型：

1. 位置参数（Positional Arguments）

最基础的参数传递方式，按定义顺序传入值：

def greet(name, age):
    return f"{name} is {age} years old."

print(greet("Alice", 30))  # 输出：Alice is 30 years old.

2. 关键字参数（Keyword Arguments）

通过参数名指定值，打破顺序限制：

print(greet(age=25, name="Bob"))  # 输出：Bob is 25 years old.

3. 默认参数（Default Arguments）

为参数设置默认值，调用时可省略：

def greet(name, age=18):  # age默认值为18
    return f"{name} is {age} years old."

print(greet("Charlie"))  # 输出：Charlie is 18 years old.

4. 可变参数（Arbitrary Arguments）

• *args：接收任意数量的位置参数（元组）

  def sum_all(*args):
      return sum(args)
  
  print(sum_all(1, 2, 3, 4))  # 输出：10
  

• **kwargs：接收任意数量的关键字参数（字典）

  def print_info(**kwargs):
      for key, value in kwargs.items():
          print(f"{key}: {value}")
  
  print_info(name="David", age=35, city="Shanghai")
  

三、返回值的多样性

函数通过 return 语句返回结果，支持以下类型：

1. 单值返回

最常见的形式，返回任意类型对象：

def square(x):
    return x ** 2  # 返回整数

2. 多值返回（元组解包）

返回多个值时，Python 默认封装为元组，可通过解包获取：

def get_user():
    return "Eve", 28, "Designer"  # 隐式返回元组

name, age, job = get_user()  # 解包赋值
print(name, age, job)  # 输出：Eve 28 Designer

3. 无返回值（NoneType）

若省略 return 或无 return 语句，函数默认返回 None：

def print_hello():
    print("Hello!")  # 无返回值

result = print_hello()
print(result)  # 输出：None

注意：None 不等于 0 或空字符串，需用 is 关键字判断：

if result is None:
    print("函数未返回有效结果")

四、函数的说明文档与注解

良好的文档是代码可读性的关键：

1. 文档字符串（Docstring）

在函数内部首行用三引号注释，描述功能、参数、返回值：

def calculate_avg(numbers):
    """
    计算列表中数字的平均值
    
    参数:
        numbers (list): 包含数字的列表
    
    返回:
        float: 平均值
    """
    return sum(numbers) / len(numbers)

通过 函数名.__doc__ 或 help(函数名) 查看文档。

2. 类型注解（Type Hints）

为参数和返回值添加类型提示（非强制，但提升可维护性）：

def add(a: int, b: int) -> int:
    return a + b

五、变量作用域与嵌套调用

1. 局部变量 vs 全局变量

• 局部变量：函数内部定义，仅在函数内可用。
• 全局变量：函数外定义，需用 global 关键字声明后修改。

count = 0  # 全局变量

def increment():
    global count  # 声明使用全局变量
    count += 1

increment()
print(count)  # 输出：1

2. 嵌套函数（闭包）

函数内部定义函数，内部函数可访问外部函数的变量：

def outer(x):
    def inner(y):
        return x + y  # 闭包捕获x的值
    return inner

add_5 = outer(5)
print(add_5(3))  # 输出：8

六、Lambda 匿名函数

用于定义简短的一次性函数，语法为 lambda 参数: 表达式：

# 等价于 def square(x): return x**2
square = lambda x: x ** 2
print(square(4))  # 输出：16

# 结合map/filter使用
numbers = [1, 2, 3, 4]
even_squares = list(map(lambda x: x**2, filter(lambda x: x%2==0, numbers)))
print(even_squares)  # 输出：[4, 16]

总结

Python 函数是编程的基石，掌握参数设计、返回值处理、作用域和匿名函数等特性，能显著提升代码的复用性和可维护性。无论是日常脚本还是大型项目，函数都是化繁为简的关键工具。

---

细节决定成败!
个人愚见，如有不对，恳请斧正!