Python 函数传参(实参与形参)

1. 引言

在编程中，函数是一个独立、封装好的代码块，用于执行特定的任务。函数有时需要接收外部传入的数据，以完成更加灵活的操作。Python 中的函数传参包括实参与形参的概念，本文将详细解释它们的含义和使用方法。

2. 什么是实参和形参

实参（Arguments）和形参（Parameters）是函数传参的重要概念。

2.1 形参

形参是函数定义时括号中的变量名，用于接收外部传入的数据。它相当于函数内部的局部变量，在函数内部可以通过形参来引用传入的数据。

下面是一个函数定义的示例，其中 x 就是一个形参：

def square(x):
    return x * x

2.2 实参

实参是函数调用时传入的具体值或变量，它可以是常量、变量、表达式等等。实参传递给对应的形参，函数内部可以使用这些实参进行计算等操作。

下面是一个函数调用的示例，其中 3 是一个实参：

result = square(3)

3. 传参的方式

在 Python 中，我们可以使用以下几种方式传递参数：

3.1 位置参数

位置参数是指按照参数定义的顺序来传递参数的方式。它是默认的传参方式，当我们不指定传入参数的形参名时，默认按照定义的参数顺序进行传参。

下面是一个接收两个位置参数的函数定义的示例：

def add(x, y):
    return x + y

我们可以通过以下方式调用该函数：

result = add(3, 5)

在上述调用中，传入的 3 对应 x，传入的 5 对应 y，函数执行后返回结果 8。

3.2 关键字参数

关键字参数是指根据形参名称来传递参数的方式。使用关键字参数时，可以不按照参数定义的位置顺序进行传参，而是直接指定参数名字和对应的值。

下面是一个接收两个关键字参数的函数定义的示例：

def subtract(a, b):
    return a - b

我们可以通过以下方式调用该函数：

result = subtract(b=5, a=3)

在上述调用中，通过指定形参名字和对应的值，我们可以实现更加灵活的参数传递。

3.3 默认参数

默认参数是在函数定义时给形参一个默认值，如果调用函数时没有传入该参数的值，那么将使用默认值。

以下是一个接收一个位置参数和一个默认参数的函数定义的示例：

def exponentiation(x, n=2):
    return x ** n

我们可以通过以下方式调用该函数：

result1 = exponentation(3)  # n 使用默认值 2
result2 = exponentation(3, 4)  # n 被赋值为 4

在上述调用中，第一种调用方式中，只传入一个实参 3，形参 x 接收到这个实参，而形参 n 没有传入具体值，所以使用了默认值 2 进行计算，结果为 9；在第二种调用方式中，传入的实参 3 对应形参 x，传入的实参 4 对应形参 n，所以计算结果为 3 ** 4 = 81。

3.4 可变参数

有时我们在定义函数时可能会需要传递不定数量的实参，这时可以使用可变参数。可变参数使用 * 表示，可以接收多个实参，将它们封装成一个元组或列表传递给形参。

以下是一个接收可变参数的函数定义的示例：

def multiply(*numbers):
    result = 1
    for number in numbers:
        result *= number
    return result

我们可以通过以下方式调用该函数：

result1 = multiply(2, 3)  # 2 * 3 = 6
result2 = multiply(4, 5, 6)  # 4 * 5 * 6 = 120

在上述示例中，multiply() 函数的形参 *numbers 可以接收多个实参，这些实参将被封装成一个元组（或列表），然后可以在函数体内进行遍历操作。

3.5 关键字可变参数

关键字可变参数是指能够接收不定数量的关键字参数，这些参数会被封装成字典形式，在函数体内可以通过字典的方式进行访问。

以下是一个接收关键字可变参数的函数定义的示例：

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

我们可以通过以下方式调用该函数：

print_info(name="John", age=25, gender="male")

在上述示例中，print_info() 函数的形参 **info 可以接收多个关键字参数，这些参数将被封装成一个字典，然后可以在函数体内进行遍历操作。

4. 实参与形参的传递规则

在Python中，实参传递给形参有以下几种方式：

4.1 位置参数传递

位置参数传递是指按照形参定义的顺序，逐个将实参传递给对应的形参。

例如，对于下面这个函数定义：

def add(x, y):
    return x + y

我们调用该函数时可以这样传递实参：

result = add(3, 5)

其中，3 对应形参 x，5 对应形参 y。

4.2 关键字参数传递

关键字参数传递是指根据形参名称直接指定对应的实参。

例如，对于下面这个函数定义：

def subtract(a, b):
    return a - b

我们调用该函数时可以这样传递实参：

result = subtract(b=3, a=5)

其中，5 对应形参 a，3 对应形参 b。

4.3 混合参数传递

在函数调用时，可以混合使用位置参数和关键字参数进行实参传递，但需要注意以下几点：
– 位置参数必须在关键字参数之前传递；
– 关键字参数可以按任意顺序传递。

以下是一个混合参数传递的示例

def multiply(x, y, z):
    return x * y * z

result = multiply(2, z=3, y=4)

在上述示例中，实参 2 对应形参 x，实参 4 对应形参 y，实参 3 对应形参 z。

4.4 默认参数传递

默认参数传递是指在函数定义时为形参指定默认值，如果调用函数时没有传入对应参数的值，将使用默认值。

以下是一个使用默认参数的示例：

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

greet("John")  # 输出: Hello, John!
greet("Emma", greeting="Hi")  # 输出: Hi, Emma!

在上述示例中，函数 greet() 的形参 greeting 被赋予了默认值 "Hello"。在第一次函数调用中，只传入了一个实参 "John"，对应形参 name，而未传入具体值的 greeting 将使用默认值 "Hello"，所以输出结果为 "Hello, John!"。在第二次函数调用中，传入了两个实参 "Emma" 和 greeting="Hi"，分别对应形参 name 和 greeting，所以输出结果为 "Hi, Emma!"。

4.5 可变参数传递

可变参数传递是指可以传递不定数量的实参给函数，它将这些实参封装成一个元组或列表，供函数使用。

以下是一个接收可变参数的函数定义示例：

def average(*numbers):
    total = sum(numbers)
    return total / len(numbers)

result = average(2, 4, 6, 8)
print(result)  # 输出: 5.0

在上述示例中，average() 函数的形参 *numbers 可以接收任意数量的实参，并将它们封装成一个元组。在函数体内，我们可以使用 sum() 函数计算元组中所有元素的和，然后除以元素的数量，得到平均值。

4.6 关键字可变参数传递

关键字可变参数传递是指可以传递不定数量的关键字参数给函数，它将这些参数封装成一个字典，供函数使用。

以下是一个接收关键字可变参数的函数定义示例：

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

print_info(name="John", age=25, gender="male")

在上述示例中，print_info() 函数的形参 **info 可以接收任意数量的关键字参数，并将它们封装成一个字典。我们可以使用 .items() 方法遍历字典中的键值对，并进行相应的操作。

5. 函数传参的注意事项

5.1 可变类型和不可变类型

在函数传参过程中，需要注意可变类型和不可变类型的区别。

不可变类型的对象在传递时，其值不会改变，而是在函数内部创建一个新的变量名，并将传入的对象赋值给这个新变量名。也就是说，在函数内部修改这个新变量名的值并不会改变原始对象的值。

可变类型的对象在传递时，其值可以被修改，并且在函数内部修改后，原始对象的值也会改变。

以下是一个示例来说明不可变和可变类型的区别：

def modify_immutable_type(x):
    x += " World"
    return x

def modify_mutable_type(lst):
    lst.append(4)

string = "Hello"
new_string = modify_immutable_type(string)
print(string)  # 输出: Hello
print(new_string)  # 输出: Hello World

list_1 = [1, 2, 3]
modify_mutable_type(list_1)
print(list_1)  # 输出: [1, 2, 3, 4]

在上述示例中，modify_immutable_type() 函数接收一个字符串类型的不可变对象 x，进行拼接操作后返回新的字符串对象。在函数调用后，原始字符串对象的值并未改变，而是返回了一个新的字符串对象。

modify_mutable_type() 函数接收一个列表类型的可变对象 lst，在函数内部使用 .append() 方法对列表进行修改。在函数调用后，原始列表对象的值也被修改了。

5.2 参数的传递顺序

在函数调用时，实参的传递顺序应该与形参的位置顺序一致，或者通过关键字参数指定形参的值。

以下是一个示例来说明参数传递顺序的重要性：

def calculate_area(width, height):
    return width * height

calculate_area(height=8, width=4)

在上述示例中，我们通过关键字参数指定了形参 width 和 height 的值，并不需要按照形参定义的顺序进行传参。

如果我们调换了关键字参数的顺序，结果将是相同的：

calculate_area(width=4, height=8)

6. 总结

本文详细介绍了Python函数传参中的实参和形参的概念，并讨论了不同的传参方式，包括位置参数、关键字参数、默认参数、可变参数和关键字可变参数。此外，还提供了一些注意事项，如可变类型和不可变类型的区别以及参数传递顺序的重要性。掌握了这些知识，你将能够更好地理解和运用Python中的函数传参。