[Python] 函数详解及技巧分析

文章目录

• 函数的定义与调用
• • 定义函数
  • 调用函数
  • • 示例：计算两个数的和
• 函数参数
• • 位置参数
  • 默认参数
  • 关键字参数
  • • 不定长参数
    • • 接收不定长位置参数
      • 接收不定长关键字参数
• 函数的返回值
• • 返回多个值
  • • [使用 `_` 忽略不需要的返回值](#使用 _ 忽略不需要的返回值)
• 变量的作用域
• • • 修改全局变量
• 嵌套调用和递归
• • • 嵌套调用
    • 递归调用
• 常见函数技巧
• • • 链式调用
    • 默认参数技巧
    • 递归优化
  • 结语

收录专栏：[Python]

在编程中，函数是非常重要的概念。Python 函数不仅使用简单，功能强大，还支持各种高级特性，如递归、默认参数、关键字参数等。在这篇博客中，我们将从基础的函数定义开始，一步步讲解函数的使用，并通过示例教学来帮助你掌握 Python 函数的核心概念和常见技巧。

---

函数的定义与调用

定义函数

在 Python 中，定义一个函数使用 def 关键字，函数可以接受参数，也可以返回值。函数体的代码需要缩进。

def 函数名(形参列表):
    # 函数体
    return 返回值

调用函数

调用函数时，只需要使用函数名并传递必要的参数。

def greet(name):
    print(f"Hello, {name}!")

# 调用函数
greet("Alice")

运行结果：

Hello, Alice!

示例：计算两个数的和

定义一个简单的函数来计算两个数的和并返回结果。

def add(a, b):
    return a + b

result = add(10, 20)
print(result)  # 输出：30

函数参数

Python 函数支持多种参数传递方式，可以根据实际需要传递多个不同类型的参数。

位置参数

这是最常见的参数传递方式，实参会按顺序传递给对应的形参。

def add(a, b):
    return a + b

print(add(3, 5))  # 输出：8

默认参数

在定义函数时，可以为参数设置默认值。调用函数时，如果没有传递该参数，则会使用默认值。

def greet(name, message="Welcome!"):
    print(f"Hello, {name}! {message}")

greet("Alice")            # 输出：Hello, Alice! Welcome!
greet("Bob", "Good job!")  # 输出：Hello, Bob! Good job!

注意：带默认值的参数必须放在没有默认值的参数之后，否则会报错。

关键字参数

关键字参数允许在调用函数时明确指定哪个实参传给哪个形参，且不需要遵循参数的顺序。

def introduce(name, age):
    print(f"My name is {name}, and I am {age} years old.")

introduce(name="Alice", age=25)  # 输出：My name is Alice, and I am 25 years old.
introduce(age=30, name="Bob")    # 输出：My name is Bob, and I am 30 years old.

不定长参数

如果不确定传递给函数的参数数量，可以使用 *args 或 **kwargs 来接收多个位置参数或关键字参数。

接收不定长位置参数

def add(*numbers):
    total = 0
    for num in numbers:
        total += num
    return total

print(add(1, 2, 3, 4))  # 输出：10

接收不定长关键字参数

def show_info(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

show_info(name="Alice", age=25, job="Developer")
# 输出：
# name: Alice
# age: 25
# job: Developer

函数的返回值

函数可以通过 return 返回值给调用者。返回值可以是任意类型的数据，甚至可以返回多个值。

def add(a, b):
    return a + b

result = add(5, 7)
print(result)  # 输出：12

返回多个值

Python 支持一次返回多个值，通过元组来实现。

def get_coordinates():
    x = 10
    y = 20
    return x, y

x, y = get_coordinates()
print(f"x = {x}, y = {y}")  # 输出：x = 10, y = 20

使用 _ 忽略不需要的返回值

如果不需要所有返回值，可以使用 _ 来忽略。

_, y = get_coordinates()
print(f"y = {y}")  # 输出：y = 20

变量的作用域

变量的作用域分为局部变量和全局变量。

• 局部变量：在函数内部定义，只能在函数内部使用。
• 全局变量：在函数外部定义，可以在整个程序中使用。

x = 10  # 全局变量

def test():
    x = 5  # 局部变量
    print(f"函数内部: x = {x}")

test()
print(f"函数外部: x = {x}")

运行结果：

函数内部: x = 5
函数外部: x = 10

修改全局变量

如果需要在函数中修改全局变量，可以使用 global 关键字。

x = 10

def modify_global():
    global x
    x = 5

modify_global()
print(x)  # 输出：5

嵌套调用和递归

嵌套调用

函数内部可以调用其他函数，这称为嵌套调用。

def a():
    print("函数 a")

def b():
    print("函数 b")
    a()

b()

运行结果：

函数 b
函数 a

递归调用

递归是函数自己调用自己，适合解决具有递归性质的问题，如阶乘、斐波那契数列等。

def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))  # 输出：120

递归必须有结束条件，否则会进入无限递归，导致程序崩溃。

常见函数技巧

链式调用

链式调用是指将一个函数的返回值作为另一个函数的参数，常见于数据处理的场景。

def add(a, b):
    return a + b

def multiply(c, d):
    return c * d

result = multiply(add(1, 2), 3)
print(result)  # 输出：9

默认参数技巧

使用默认参数可以简化函数调用。在不需要调试时可以忽略调试信息输出，而在需要调试时传递 debug=True。

def add(x, y, debug=False):
    if debug:
        print(f"调试信息: x={x}, y={y}")
    return x + y

print(add(10, 20))         # 输出：30
print(add(10, 20, True))   # 输出：调试信息: x=10, y=20，结果：30

递归优化

递归虽然简洁，但性能不一定好。可以通过缓存（Memoization）优化递归的性能。

def fib(n, cache={}):
    if n in cache:
        return cache[n]
    if n <= 2:
        return 1
    result = fib(n-1) + fib(n-2)
    cache[n] = result
    return result

print(fib(10))  # 输出：55

---

结语

通过本文的讲解，我们深入学习了 Python 中函数的定义、调用、参数传递、返回值、作用域以及递归等常见功能。Python 的函数非常灵活和强大，能够支持从简单的计算到复杂的递归逻辑，希望你能在编写函数时更加得心应手。