Python数学建模-2.3函数（上）

在Python中，函数是一段可重用的代码块，它执行特定的任务。函数可以接受输入（称为参数）并可能返回输出（称为返回值）。通过定义和使用函数，你可以将代码分解为更小、更易于管理和理解的部分，从而提高代码的可读性和可维护性。通常函数分为：内置函数、第三方模块函数和自定义函数。

2.3.1自定义函数

在Python中，自定义函数是一种强大的工具，允许你根据自己的需求编写可重用的代码块。通过定义函数，你可以将复杂的逻辑封装在一个名字下，并在程序的多个位置调用它，从而提高代码的可读性和可维护性。

1.定义自定义函数

要定义一个自定义函数，你需要使用def关键字，后面跟着函数名、括号内的参数列表以及一个冒号。函数体（即函数要执行的代码）需要缩进，通常使用四个空格或一个制表符。

下面是一个简单的自定义函数示例，它接受两个数字作为参数并返回它们的和：

def add_two_numbers(num1, num2):  
    """  
    这个函数接受两个数字作为参数，并返回它们的和。  
    """  
    result = num1 + num2  
    return result

2.调用自定义函数

一旦你定义了自定义函数，你就可以在程序的任何地方调用它。调用函数时，需要使用函数名，后面跟着括号和必要的参数。

def add_two_numbers(num1, num2):
    """
    这个函数接受两个数字作为参数，并返回它们的和。
    """
    result = num1 + num2
    return result

# 调用自定义函数
sum_result = add_two_numbers(3, 4)
print(sum_result)  # 输出: 7

输出结果：

7

3.函数参数

函数可以没有任何参数，也可以有一个或多个参数。参数是传递给函数的值，函数内部使用这些值来执行计算或操作。

（1）位置参数

位置参数是按照它们在函数定义中出现的顺序来传递的。

def greet(name, age):  
    print(f"Hello, {name}. You are {age} years old.")  
  
greet("Alice", 30)  # 输出: Hello, Alice. You are 30 years old.

输出结果：

Hello, Alice. You are 30 years old.

（2）关键字参数

在调用函数时，我们可以使用关键字参数，通过参数名来指定每个参数的值。这可以使代码更具可读性，并且参数的顺序不再重要。

greet(age=30, name="Alice")  # 输出: Hello, Alice. You are 30 years old.

（3）默认参数

可以在函数定义中为参数指定默认值。如果在调用函数时没有提供该参数的值，那么就会使用默认值。

def greet(name, age=None):  
    if age is not None:  
        print(f"Hello, {name}. You are {age} years old.")  
    else:  
        print(f"Hello, {name}. Nice to meet you!")  
  
greet("Bob")  # 输出: Hello, Bob. Nice to meet you!  
greet("Eve", 25)  # 输出: Hello, Eve. You are 25 years old.

（4）可变参数

Python还支持可变数量的参数，使用*args和**kwargs。

• *args允许你传递任意数量的非关键字参数。
• **kwargs允许你传递任意数量的关键字参数。

def func_with_args(*args):  
    for arg in args:  
        print(arg)  
  
def func_with_kwargs(**kwargs):  
    for key, value in kwargs.items():  
        print(f"{key} = {value}")  
  
func_with_args(1, 2, 3, 4)  # 输出: 1 2 3 4（每个数字一行）  
func_with_kwargs(name="Alice", age=30)  # 输出: name = Alice 和 age = 30（每行一个键值对）

4.函数返回值

函数可以使用return语句返回一个或多个值。如果没有return语句，或者return后面没有跟任何值，那么函数将返回None。

def get_square(num):  
    return num ** 2  
  
result = get_square(5)  
print(result)  # 输出: 25

5.局部变量和全局变量

在函数内部定义的变量是局部变量，它们只在函数内部可见。在函数外部定义的变量是全局变量，它们在整个程序中都是可见的。在函数内部，你可以读取全局变量，但如果要修改它，你需要使用global关键字来声明。

global_var = 10  
  
def change_global_var():  
    global global_var  
    global_var = 20  
  
change_global_var()  
print(global_var)  # 输出: 20

6.嵌套函数

嵌套函数是Python中一种非常有用的特性，它允许你在一个函数内部定义另一个函数。内部函数（或称为嵌套函数）可以访问其外部函数（或称为包含函数）的作用域中的变量，包括外部函数的参数和局部变量。这种能力使得嵌套函数在处理复杂逻辑和封装数据时特别有用。

def outer_function(x):
    def inner_function(y):
        return x + y

    return inner_function


# 调用外部函数，它返回内部函数
added_five = outer_function(5)

# 调用返回的内部函数
result = added_five(3)
print(result)  # 输出: 8

在这个例子中，outer_function接受一个参数x，并定义了一个嵌套函数inner_function，它接受另一个参数y。inner_function返回x和y的和。当outer_function被调用时，它返回inner_function而不是执行它。因此，added_five实际上是inner_function的一个实例，其中x已经被绑定为5。然后，我们可以调用added_five并传入另一个参数来得到结果。

下面给大家举一个闭包的示例，用于计算移动平均值：

def make_averager():  
    series = []  
      
    def averager(new_value):  
        series.append(new_value)  
        total = sum(series)  
        return total / len(series)  
      
    return averager  
  
# 创建一个计算平均值的函数  
avg = make_averager()  
  
# 使用这个函数来计算平均值  
print(avg(10))       # 输出: 10.0  
print(avg(11))       # 输出: 10.5  
print(avg(12))       # 输出: 11.0

在这个例子中，make_averager是一个创建闭包的工厂函数。它返回一个averager函数，这个函数可以持续地累加新的值并计算平均值。averager函数记住了series列表，即使make_averager已经执行完毕并返回了。这就是闭包的力量所在：它们可以“记住”其定义时的环境。

7.Lambda

Lambda 函数是一种简洁的定义单行函数的方式。它们通常用于需要小函数的地方，而不需要完整的def语句。

# 定义一个lambda函数，接受两个参数并返回它们的和  
add = lambda x, y: x + y  
  
result = add(3, 4)  
print(result)  # 输出: 7

Lambda 函数特别适用于map(), filter(), 和reduce()等内置函数，这些函数通常需要一个函数作为参数。

8.生成器函数

生成器函数是一种特殊的函数，它使用yield语句而不是return来返回值。每次调用生成器函数时，它都会记住上一次离开时的状态，并在下一次调用时从该点继续执行。这使得生成器函数非常适合处理大量数据或无限序列，因为它们不需要一次性加载所有数据到内存中。

def my_generator():  
    n = 1  
    while True:  
        yield n  
        n += 1  
  
gen = my_generator()  
print(next(gen))  # 输出: 1  
print(next(gen))  # 输出: 2  
# 可以继续调用next(gen)来获取更多的值

9.装饰器

装饰器是一个接受函数作为参数并返回一个新函数的函数。它们通常用于在不修改原始函数代码的情况下给函数添加额外的功能，比如日志记录、性能分析或权限检查。

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")

    return wrapper


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


say_hello()
# 输出:
# Something is happening before the function is called.
# Hello!
# Something is happening after the function is called.

在上面的例子中，@my_decorator是一个装饰器，它接受say_hello函数作为参数，并返回一个新的函数wrapper。当调用say_hello()时，实际上调用的是wrapper函数，它在调用say_hello之前和之后添加了一些额外的输出。

自定义函数是Python编程中的核心概念之一，它们允许你编写可重用的代码块，从而简化复杂任务并提高代码的可维护性。通过理解并掌握这些概念，你可以编写出更加高效和灵活的Python程序。