Python中怎样自定义函数

什么是函数?为何需要自定义函数?

函数是组织好的、可重复使用的、用于执行指定任务的代码块。在Python中怎样自定义函数,本质上是掌握如何通过def语句构建独立功能单元的过程。相较于直接编写冗长脚本,自定义函数具有以下核心优势:

  • ✅ 代码复用:一次定义,多处调用,避免重复编写相同逻辑
  • ✅ 模块化设计:将复杂问题分解为独立子任务,提升可读性与维护性
  • ✅ 便于测试与调试:每个函数可单独验证行为,降低错误传播风险
  • ✅ 支持抽象封装:隐藏实现细节,仅暴露必要接口,提升代码健壮性

在数据科学、Web开发、自动化运维等领域,Python中怎样自定义函数是构建可扩展应用的基础能力。例如:在Pandas中,apply()方法本质是调用用户自定义函数;Flask路由处理函数即为典型自定义函数应用。

函数定义的核心原则

设计高效函数需遵循三大黄金法则:

  • 🔹 单一职责原则:每个函数只完成一个明确功能,如calc_area()仅计算面积,不处理打印或保存
  • 🔹 命名语义化:使用动词开头的驼峰/下划线命名(如get_user_token),避免do_something等模糊名称
  • 🔹 输入输出明确:通过参数接收输入,通过return返回结果,避免隐式依赖全局状态

违背上述原则将导致函数难以复用。例如:若函数login_and_save()既验证凭证又写入数据库,当只需验证而无需保存时,将被迫重复实现逻辑。

常见误区与反模式

新手常犯以下错误,导致函数设计失效:

  • ⚠️ 过长函数体:单函数超50行易隐藏逻辑错误,应拆分为子函数
  • ⚠️ 硬编码常量:直接写死值如3.14,应提取为参数或常量
  • ⚠️ 全局变量滥用:函数依赖外部状态,破坏封装性
  • ⚠️ 返回类型不一致:有时返回字符串,有时返回None,导致调用方处理复杂化

反例:以下函数违反单一职责与硬编码原则

def print_grade(score):
    if score >= 90: grade = 'A'
    elif score >= 80: grade = 'B'
    else: grade = 'C'
    print(f"分数{score}对应等级{grade}")

优化后应分离计算与输出逻辑

def get_grade(score):
    if score >= 90: return 'A'
    elif score >= 80: return 'B'
    else: return 'C'
def print_grade(score):
    print(f"分数{score}对应等级{get_grade(score)}")

函数定义基础语法与结构

标准定义格式

Python中怎样自定义函数的标准语法如下:

def 函数名(参数列表):
    """可选:函数文档字符串"""
    函数体
    return [返回值]
  • 🔹 def:定义函数的关键字
  • 🔹 函数名:遵循标识符规则,推荐小写+下划线(如get_user_info)
  • 🔹 参数列表:用逗号分隔的变量名,可为空
  • 🔹 文档字符串:三引号包裹的说明文本,可通过函数.__doc__访问
  • 🔹 return:结束函数执行并返回值,无返回值时默认返回None

示例:计算两数之和的函数

def add_two_numbers(a, b):
    """返回两个数字的和"""
    result = a + b
    return result

调用方式:

sum_result = add_two_numbers(10, 20)  # result = 30

无参数函数的典型场景

当功能不依赖外部输入时,可定义无参数函数:

def get_current_time():
    """返回当前系统时间字符串"""
    import datetime
    return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
current = get_current_time()
print(current)  # 输出:2023-10-25 14:30:15

注意:此类函数应明确说明其行为是否依赖外部状态(如系统时间、网络请求),避免调用者误判其确定性。

文档字符串的最佳实践

高质量文档字符串提升代码可维护性,推荐采用Google风格:

def calculate_bmi(weight, height):
    """计算身体质量指数(BMI)
    Args:
        weight (float): 体重(单位:千克)
        height (float): 身高(单位:米)
    Returns:
        float: BMI值,四舍五入至小数点后1位
    Raises:
        ValueError: 当体重或身高为非正数时抛出
    """
    if weight <= 0 or height <= 0:
        raise ValueError("体重和身高必须为正数")
    bmi = weight / (height ** 2)
    return round(bmi, 1)

使用help(calculate_bmi)可直接查看此文档,极大提升协作效率。

参数类型与传递机制

参数类型详解

Python中怎样自定义函数时,参数类型决定函数行为,主要分为:

类型 语法特征 使用场景 示例
位置参数 按顺序传递 参数顺序固定且少于5个 add(3, 5)
关键字参数 显式指定参数名 参数顺序不重要或提高可读性 add(b=5, a=3)
可变参数 *args接收元组 处理不定数量的位置参数 sum_all(1, 2, 3)
关键字可变参数 **kwargs接收字典 处理不定数量的关键字参数 print_info(name="Tom", age=20)

参数传递机制:对象引用

Python参数传递本质是对象引用的传递,而非C语言的值传递或指针传递。关键点:

  • 🔹 不可变对象(如int、str、tuple):函数内修改会创建新对象,外部不受影响
  • 🔹 可变对象(如list、dict、set):函数内修改直接影响原始对象

示例:可变对象的副作用

def append_item(lst, item):
    lst.append(item)
    return lst
my_list = [1, 2]
new_list = append_item(my_list, 3)
print(my_list)  # 输出 [1, 2, 3] — 原始列表被修改!
print(new_list) # 输出 [1, 2, 3]

安全做法:若需避免副作用,应在函数内复制对象

def safe_append(lst, item):
    new_lst = lst.copy()  # 创建副本
    new_lst.append(item)
    return new_lst
my_list = [1, 2]
new_list = safe_append(my_list, 3)
print(my_list)  # 输出 [1, 2]
print(new_list) # 输出 [1, 2, 3]

默认参数的陷阱与技巧

默认参数值在函数定义时计算,而非调用时。常见陷阱:使用可变对象作为默认值

def bad_append(new_item, container=[]):
    container.append(new_item)
    return container
print(bad_append('A'))  # ['A']
print(bad_append('B'))  # ['A', 'B'] — 意外共享了同一个列表!

正确做法:使用None作为默认值,内部动态创建

def good_append(new_item, container=None):
    if container is None:
        container = []
    container.append(new_item)
    return container
print(good_append('A'))  # ['A']
print(good_append('B'))  # ['B'] — 独立的列表实例

此模式确保每次调用独立操作,避免隐式状态共享。

关键字参数提升可读性

在参数多或类型相似时,关键字参数显著提升代码可读性:

def create_user(username, email, age=18, is_admin=False):
    return {
        'username': username,
        'email': email,
        'age': age,
        'is_admin': is_admin
    }
# 使用关键字参数
user = create_user(
    email="admin@example.com",
    username="admin",
    age=30
)
print(user)

优势:

  • ✓ 参数顺序可变,降低出错风险
  • ✓ 明确指定参数含义,无需记忆顺序
  • ✓ 与默认参数配合,灵活覆盖部分参数

作用域与命名空间

LEGB规则详解

Python中怎样自定义函数时,变量查找遵循LEGB规则:

  • Local:函数内部局部作用域
  • Enclosing:外层函数的局部作用域(嵌套函数时)
  • Global:模块级全局作用域
  • Built-in:Python内置作用域

示例:作用域查找链

x = "global"  # 全局作用域
def outer():
    x = "enclosing"  # 外层函数作用域
    def inner():
        x = "local"  # 局部作用域
        print(x)     # 输出:local
    inner()
outer()

当inner()中未定义x时,将按local → enclosing → global → built-in顺序查找。

global与nonlocal关键字

修改外层作用域变量需显式声明:

count = 0  # 全局变量
def increment():
    global count
    count += 1  # 修改全局变量
increment()
print(count)  # 输出:1

嵌套函数中修改外层变量需用nonlocal:

def outer():
    count = 0
    def inner():
        nonlocal count
        count += 1
        return count
    return inner
counter = outer()
print(counter())  # 输出:1
print(counter())  # 输出:2

注意:滥用global会破坏函数独立性,应优先通过参数传递与返回值交互状态。

闭包与作用域延伸

当内部函数引用外层函数变量时,形成闭包。闭包使变量在函数返回后仍保持状态:

def make_multiplier(n):
    def multiply(x):
        return x * n
    return multiply
double = make_multiplier(2)
triple = make_multiplier(3)
print(double(5))  # 输出:10
print(triple(5))  # 输出:15

关键机制:

  • 🔹 make_multiplier返回的multiply函数持有n=2/3的引用
  • 🔹 n存储在闭包的__closure__属性中
  • 🔹 实现了类似"带记忆的函数"效果

应用场景:配置生成器、装饰器基础、状态保持(替代全局变量)。

装饰器:函数增强机制

装饰器原理与基础语法

装饰器是接受函数并返回新函数的高阶函数。本质是闭包的应用:

def simple_decorator(func):
    def wrapper():
        print("函数执行前")
        func()
        print("函数执行后")
    return wrapper
@simple_decorator
def greet():
    print("Hello!")
greet()
# 输出:
# 函数执行前
# Hello!
# 函数执行后

语法糖@decorator等价于greet = simple_decorator(greet)。

带参数的装饰器

通过三层嵌套实现装饰器参数化:

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator
@repeat(3)
def say(message):
    print(message)
say("Python!")
# 输出三行:Python!

执行流程:

  1. repeat(3)返回decorator
  2. decorator(say)返回wrapper
  3. say("Python!")实际调用wrapper("Python!")

常用装饰器实例

1. 日志记录装饰器

import logging
logging.basicConfig(level=logging.INFO)
def log_calls(func):
    def wrapper(*args, **kwargs):
        logging.info(f"调用 {func.__name__},参数: {args}, {kwargs}")
        result = func(*args, **kwargs)
        logging.info(f"返回: {result}")
        return result
    return wrapper
@log_calls
def add(a, b):
    return a + b
add(3, 5)

2. 性能计时装饰器

import time
def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} 耗时: {end - start:.4f}秒")
        return result
    return wrapper
@timer
def slow_calc():
    time.sleep(1.2)
    return "完成"
slow_calc()  # 输出:slow_calc 耗时: 1.2001秒

3. 权限验证装饰器

def require_auth(func):
    def wrapper(user):
        if not user.get("is_admin"):
            raise PermissionError("无权限执行此操作")
        return func(user)
    return wrapper
@require_auth
def delete_user(user):
    print(f"用户 {user['name']} 已删除")
admin = {"name": "Alice", "is_admin": True}
user = {"name": "Bob", "is_admin": False}
delete_user(admin)  # 正常执行
delete_user(user)   # 抛出权限错误

匿名函数与lambda表达式

lambda基础语法

lambda是创建小型匿名函数的简洁方式,语法为:

lambda 参数列表: 表达式

等价于:

def 函数名(参数列表):
    return 表达式

示例:平方函数

square = lambda x: x ** 2
print(square(5))  # 输出:25

注意:lambda仅支持单表达式,不能包含多行语句。

典型应用场景

1. 与内置函数配合

numbers = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, numbers))
print(squares)  # [1, 4, 9, 16, 25]

2. 排序自定义规则

students = [
    {"name": "Alice", "score": 88},
    {"name": "Bob", "score": 95},
    {"name": "Charlie", "score": 72}
]
# 按分数降序排序
sorted_students = sorted(students, key=lambda s: s["score"], reverse=True)
print(sorted_students)

3. 事件处理回调

button.on_click(lambda: print("按钮被点击"))

lambda vs def函数对比

特性 lambda表达式 def函数
语法复杂度 单表达式 支持多语句
可读性 适合简单逻辑 适合复杂逻辑
调试便利性 无函数名,栈追踪困难 有函数名,易定位
文档支持 无法添加docstring 可添加完整文档

最佳实践:当逻辑超过一行或需复用时,优先使用def定义命名函数。

递归函数设计

递归核心要素

递归函数必须包含两个关键部分:

  • 🔹 基线条件(Base Case):停止递归的终止条件
  • 🔹 递归步骤(Recursive Step):调用自身缩小问题规模

示例:计算阶乘

def factorial(n):
    if n == 0:  # 基线条件
        return 1
    return n * factorial(n - 1)  # 递归步骤
print(factorial(5))  # 输出:120

调用过程:factorial(5) → 5 * factorial(4) → ... → 5*4*3*2*1

递归的性能陷阱

递归可能导致栈溢出或重复计算,如斐波那契数列的朴素实现:

def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)
print(fib(35))  # 计算耗时明显,因重复计算大量子问题

优化方案:记忆化递归

from functools import lru_cache
@lru_cache(maxsize=None)
def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)
print(fib(35))  # 瞬间完成,因缓存已计算结果

或改用迭代法彻底避免递归:

def fib_iter(n):
    if n <= 1:
        return n
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

递归典型应用场景

1. 树形结构遍历

def traverse_tree(node):
    if node is None:
        return
    print(node.value)
    traverse_tree(node.left)
    traverse_tree(node.right)

2. 分治算法

归并排序的核心递归逻辑:

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

3. 回溯算法

全排列生成:

def permute(nums):
    if not nums:
        return [[]]
    result = []
    for i in range(len(nums)):
        rest = nums[:i] + nums[i+1:]
        for p in permute(rest):
            result.append([nums[i]] + p)
    return result

高频问题解答

Q1:函数可以返回多个值吗?

A:可以!Python通过元组实现多返回值语法糖:

def get_min_max(numbers):
    return min(numbers), max(numbers)
min_val, max_val = get_min_max([3, 1, 4, 1, 5])
print(min_val, max_val)  # 输出:1 5

实际返回的是单个元组(1, 5),但Python自动解包为两个变量。

Q2:如何避免函数参数过多?

A:推荐以下方案:

  • ✓ 将相关参数封装为字典或数据类
  • ✓ 使用可变参数*args与**kwargs
  • ✓ 拆分为多个子函数

示例:配置参数封装

def create_config(**kwargs):
    defaults = {"timeout": 30, "retries": 3}
    defaults.update(kwargs)
    return defaults
config = create_config(timeout=60, host="example.com")

Q3:函数可以递归调用自己吗?

A:可以,这称为递归。但需注意:

  • 🔹 必须定义基线条件避免无限递归
  • 🔹 Python默认递归深度限制为1000(可通过sys.setrecursionlimit调整)
  • 🔹 大规模递归建议用迭代替代

Q4:如何为函数添加类型提示?

A:使用类型注解提升可读性与IDE支持:

def greet(name: str, age: int = 18) -> str:
    return f"{name}的年龄是{age}岁"
# 类型检查工具(如mypy)可检测错误
greet("Alice", 25)  # 正确
greet(123, "age")   # 类型错误

类型提示不改变运行时行为,但极大提升代码可维护性。