目录

一、函数的定义

二、函数的参数

位置参数

默认参数

关键字参数

可变长度参数

三、函数的返回值

四、函数的作用域

五、函数的嵌套

六、匿名函数（lambda 函数）

七、递归函数

八、函数装饰器

九、函数式编程概念与 Python 函数

---

一、函数的定义

在 Python 中，函数是一段可重复使用的代码块，用于执行特定的任务。通过定义函数，可以将程序分解为更小的、易于管理的部分。

函数的基本语法如下：

def function_name(parameters):
    """函数文档字符串，用于描述函数功能等信息"""
    # 函数体，包含执行特定任务的代码
    return [expression]

• def是定义函数的关键字。
• function_name是函数的名称，命名规则遵循 Python 变量命名规则，通常采用小写字母加下划线的方式（例如my_function）。
• parameters是函数的参数列表，参数可以有一个或多个，也可以没有参数。参数用于向函数内部传递数据。
• 函数体是函数执行具体操作的代码部分。
• return语句用于返回函数的结果。如果没有return语句，函数默认返回None。

例如，下面是一个简单的函数，用于计算两个数的和：

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

二、函数的参数

1. 位置参数

   • 位置参数是最常见的参数类型。在调用函数时，按照参数定义的顺序传递实参。例如：

def greet(name, greeting):
    print(greeting + ", " + name)
greet("Alice", "Hello")

在这个例子中，"Alice"被传递给name参数，"Hello"被传递给greeting参数。

1. 默认参数

   • 可以为函数的参数指定默认值。这样在调用函数时，如果没有为该参数提供值，将使用默认值。例如：

def greet(name, greeting = "Hi"):
    print(greeting + ", " + name)
greet("Bob")

这里greeting参数有一个默认值"Hi"，当只传递一个参数"Bob"时，greeting使用默认值"Hi"。

1. 关键字参数

   • 关键字参数允许在调用函数时通过参数名来指定实参的值，而不依赖于参数的位置。例如：

def greet(name, greeting):
    print(greeting + ", " + name)
greet(greeting = "Good morning", name = "Charlie")

这种方式可以使代码更加清晰，尤其是在函数有多个参数的情况下。

1. 可变长度参数

   • *args和**kwargs用于处理可变长度的参数。*args用于接收任意数量的位置参数，它将这些参数收集为一个元组。例如：

def sum_numbers(*args):
    return sum(args)
print(sum_numbers(1, 2, 3))

• **kwargs用于接收任意数量的关键字参数，它将这些参数收集为一个字典。例如：

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(key + ": " + str(value))
print_info(name = "David", age = 30)

三、函数的返回值

• 函数可以返回一个或多个值。返回一个值时，如前面的add_numbers函数，使用return语句返回计算结果。如果要返回多个值，可以将多个值封装在一个数据结构（如元组、列表等）中返回。例如：

def get_name_and_age():
    name = "Eve"
    age = 25
    return (name, age)
result = get_name_and_age()
print(result[0])  
print(result[1])

也可以直接对返回的元组进行解包：

name, age = get_name_and_age()
print(name)
print(age)

四、函数的作用域

• 在 Python 中，变量有不同的作用域。函数内部定义的变量（局部变量）只能在函数内部访问。例如：

def my_function():
    x = 10
    print(x)
my_function()
# 尝试在函数外部访问x会导致错误
# print(x)

• 如果要在函数内部修改全局变量，需要使用global关键字。例如：

x = 5
def modify_global_variable():
    global x
    x = 10
modify_global_variable()
print(x)

五、函数的嵌套

• Python 允许在一个函数内部定义另一个函数。内部函数可以访问外部函数的变量。例如：

def outer_function():
    y = 20
    def inner_function():
        print(y)
    inner_function()
outer_function()

这种嵌套结构可以用于实现一些复杂的功能，比如闭包等高级概念。

六、匿名函数（lambda 函数）

匿名函数是一种不需要使用def关键字定义的函数，它使用lambda表达式来创建。匿名函数通常用于简单的、一次性的函数操作，特别是在需要将函数作为参数传递给其他函数的场景中，如map()、filter()和sorted()等内置函数。

语法格式为：lambda arguments: expression

例如：

# 定义一个匿名函数，计算一个数的平方
square = lambda x: x ** 2
print(square(5))

# 使用匿名函数与 map 函数结合，对列表中的每个元素求平方
numbers = [1, 2, 3, 4, 5]
squared_numbers = list(map(lambda x: x ** 2, numbers))
print(squared_numbers)

七、递归函数

递归函数是在函数内部调用自身的函数。递归通常用于解决可以分解为相似子问题的问题，例如计算阶乘、斐波那契数列等。

例如，计算阶乘的递归函数：

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

print(factorial(5))

需要注意的是，在使用递归函数时，必须确保有一个终止条件，否则函数会无限递归调用，导致栈溢出错误。

八、函数装饰器

函数装饰器是一种特殊的函数，它可以在不修改原函数代码的基础上，对函数进行功能扩展或修改函数的行为。装饰器本质上是一个返回函数的高阶函数，它接受一个函数作为参数，并返回一个新的函数。

例如，定义一个简单的装饰器，用于在函数调用前后打印日志：

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling function {func.__name__}")
        result = func(*args, **kwargs)
        print(f"Function {func.__name__} completed")
        return result
    return wrapper

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

print(add(3, 5))

在这个例子中，@log_decorator语法将add函数作为参数传递给log_decorator装饰器函数，log_decorator返回wrapper函数，实际上add函数被替换成了wrapper函数，从而实现了在add函数调用前后打印日志的功能。

九、函数式编程概念与 Python 函数

Python 虽然不是纯粹的函数式编程语言，但也支持一些函数式编程的特性。除了前面提到的匿名函数、高阶函数（如函数作为参数和返回值）外，还有一些内置函数和模块体现了函数式编程思想。

例如，reduce()函数从functools模块导入，它可以对一个序列进行累积计算。

from functools import reduce

# 计算列表中所有元素的乘积
numbers = [2, 3, 4, 5]
product = reduce(lambda x, y: x * y, numbers)
print(product)

此外，列表推导式和生成器表达式也可以看作是函数式编程风格的体现，它们可以简洁地创建列表或生成器对象，基于已有的序列或条件进行转换和筛选。

例如，使用列表推导式创建一个包含 1 到 10 中偶数平方的列表：

even_squares = [x ** 2 for x in range(1, 11) if x % 2 == 0]
print(even_squares)

通过这些内容，可以更全面地了解 Python 函数的丰富特性和应用场景，无论是在简单的脚本编写还是复杂的程序设计中，都能更加灵活地运用函数来提高代码的质量和效率。