函 数 篇

函数

在 Python 中，函数是一段组织好的、可重复使用的代码块，用于执行特定的任务。你可以给函数起一个名字，并通过这个名字来调用它执行相关任务。函数也可以接收输入（称为参数）并可能返回输出（称为返回值）。

以下是一个简单的 Python 函数示例，它定义了一个名为 greet 的函数，该函数接受一个名字作为参数，并打印出问候语：

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

# 调用函数
greet("Alice")

当你运行上面的代码时，它会输出：

Hello, Alice!

函数的定义使用 def 关键字开始，后面跟着函数名、括号中的参数列表以及冒号。函数体（即函数实际执行的代码）需要缩进。

函数可以有零个或多个参数。例如，下面是一个没有参数的函数：

def say_hello():
    print("Hello!")

# 调用函数
say_hello()

输出：

Hello!

函数也可以返回一个值，使用 return 关键字：

def add_numbers(a, b):
    result = a + b
    return result

# 调用函数并存储返回值
sum = add_numbers(3, 5)
print(sum)

输出：

8

在这个例子中，add_numbers 函数接收两个参数 a 和 b，计算它们的和，并通过 return 语句返回结果。调用该函数时，返回的值可以被存储在变量中（在这里是 sum），然后可以像处理任何其他值一样处理它。

函数是编程中非常重要的概念，它们可以帮助你组织代码、减少重复、提高可读性，并使得代码更易于测试和重用。

函数的参数

在 Python 中，函数参数是用来向函数传递信息的。当你调用一个函数时，你可以为这些参数提供值，这些值在函数内部被使用。Python 函数支持多种类型的参数，包括位置参数、关键字参数、默认参数、可变参数和关键字可变参数。

1. 位置参数

位置参数是最简单的参数类型，它们在函数定义时按照顺序排列，并在调用函数时按照同样的顺序传递。

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

# 调用函数
greet("John", "Doe")

2. 关键字参数

关键字参数允许你明确指定每个参数的值，而不需要按照定义的顺序来传递。在调用函数时，你可以使用参数名来指定每个参数的值。

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

# 使用关键字参数调用函数
greet(last_name="Doe", first_name="John")

3. 默认参数

默认参数在函数定义时指定默认值，如果在调用函数时没有提供该参数的值，则使用默认值。

def greet(first_name, last_name, middle_name=""):
    print(f"Hello, {first_name} {middle_name} {last_name}!")

# 调用函数，不提供中间名
greet("John", "Doe")

# 调用函数，提供中间名
greet("Jane", "Doe", "A.")

4. 可变参数

可变参数允许你传递任意数量的参数给一个函数，这些参数在函数内部被收集到一个元组中。

def sum_numbers(*args):
    return sum(args)

# 调用函数，传递任意数量的参数
print(sum_numbers(1, 2, 3, 4, 5))  # 输出 15

5. 关键字可变参数

关键字可变参数允许你传递任意数量的关键字参数给一个函数，这些参数在函数内部被收集到一个字典中。

def greet_people(**kwargs):
    for name, message in kwargs.items():
        print(f"{name}: {message}")

# 调用函数，传递任意数量的关键字参数
greet_people(John="Hello!", Alice="Hi!", Bob="Good day!")

6. 参数解包

有时，你可能有一个列表或元组，你想要将其内容作为位置参数传递给一个函数，或者有一个字典，你想要将其内容作为关键字参数传递给一个函数。这可以通过参数解包来实现。

# 参数解包示例
def greet(first_name, last_name):
    print(f"Hello, {first_name} {last_name}!")

names = ["John", "Doe"]
# 使用 * 进行参数解包
greet(*names)

# 关键字参数解包示例
def introduce(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

info = {"name": "Alice", "age": 30}
# 使用 ** 进行关键字参数解包
introduce(**info)

通过使用不同类型的参数，Python 函数可以变得非常灵活和强大，能够适应多种不同的使用场景。

函数 参数 *

在 Python 中，使用 * 符号作为函数参数时，它表示可变位置参数（variable positional arguments）。这意味着你可以向该函数传递任意数量的位置参数，这些参数在函数内部会被收集到一个元组（tuple）中。这种机制允许你编写更加通用和灵活的函数。

下面是一个简单的例子，展示了如何使用 * 来定义和调用一个接受可变位置参数的函数：

def my_function(*args):
    for arg in args:
        print(arg)

# 调用函数，传递不同数量的参数
my_function(1, 2, 3)
my_function("hello", "world")
my_function(42)

在这个例子中，my_function 函数定义了一个名为 args 的可变位置参数。当我们调用这个函数时，可以传递任意数量的参数，这些参数会被收集到 args 元组中。在函数内部，我们可以通过遍历 args 来处理这些参数。

此外，你还可以使用 * 来在函数调用时进行参数解包（unpacking）。这意味着你可以将一个列表或元组中的元素作为单独的位置参数传递给函数。例如：

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

names = ["Alice", "Smith"]
# 使用 * 进行参数解包
greet(*names)  # 输出: Hello, Alice Smith!

在这个例子中，*names 会将 names 列表中的元素解包为单独的位置参数，并传递给 greet 函数。

总结一下，* 在 Python 函数参数中扮演了两种角色：

• 作为函数定义的一部分，它表示该函数可以接受任意数量的位置参数，这些参数会被收集到一个元组中。
• 作为函数调用的一部分（使用 * 前缀），它可以将一个列表或元组中的元素解包为单独的位置参数。

函数 参数 **

在Python中，** 在函数参数中有两种常见的用法：

关键字参数解包：当你调用一个函数时，可以使用 ** 来解包一个字典，并将其键值对作为关键字参数传递给函数。

def greet(name, age):
    print(f"Hello, my name is {name} and I am {age} years old.")

params = {'name': 'Alice', 'age': 30}
greet(**params)  # 输出: Hello, my name is Alice and I am 30 years old.

收集额外关键字参数：在函数定义中，**kwargs 用于收集所有未被显式定义的关键字参数，并将它们存储在一个字典中。

def func(**kwargs):
    for key, value in kwargs.items():
        print(f"{key} = {value}")

func(a=1, b=2, c=3)  # 输出:
                     # a = 1
                     # b = 2
                     # c = 3

在这个例子中，**kwargs 允许函数接受任意数量的关键字参数，并将它们存储在一个名为 kwargs 的字典中。这个字典的键是参数名，值是传递给参数的值。

这两种用法使得 ** 在Python函数参数中非常灵活和强大，它们允许你以编程的方式处理可变数量的参数，以及从字典中解包参数。

/和*都出现在函数参数中

在 Python 函数参数中，/ 和 * 有特定的含义，它们分别用于指定位置参数和关键字参数。

/（正斜杠）:
从 Python 3.8 开始，/ 可以用于函数参数中，以指示在该符号之前的所有参数都必须是位置参数，也就是说，它们不能以关键字的形式传递。如果尝试以关键字的形式传递这些参数，Python 会抛出一个 TypeError。

def func(a, b, /, c):
    print(a, b, c)

func(1, 2, c=3)  # 正确：a=1, b=2, c=3
func(a=1, b=2, c=3)  # 错误：a 和 b 必须是位置参数

这个特性在需要强制某些参数为位置参数时非常有用，特别是在重载函数或想要明确指定某些参数的位置时。

*（星号）:
* 在函数参数中有两种常见的用法：

    作为位置参数和关键字参数的分隔符：在函数定义中，* 可以用来指示所有后续参数都必须是关键字参数。这通常与 / 一起使用，来区分位置参数和关键字参数。

def func(a, b, /, *args, **kwargs):
    print(a, b, args, kwargs)

func(1, 2, 3, 4, x=5, y=6)  # 正确：a=1, b=2, args=(3, 4), kwargs={'x': 5, 'y': 6}

作为收集额外位置参数的参数：在函数定义中，单独的 *args 用于收集所有额外的位置参数，并将它们放入一个元组中。

python
def func(*args):
    for arg in args:
        print(arg)

func(1, 2, 3)  # 输出 1, 2, 3

请注意，* 作为收集额外位置参数的参数时，不能同时用作分隔符。它们是不同的用法，并且不能在同一函数定义中混淆。

在编写函数时，理解这些符号的用法非常重要，以确保你的函数按照预期的方式接收参数。