Python中的函数

1 函数的定义

在Python中，函数是一段可重复使用的代码块，用于执行特定的任务或操作。函数可以接受输入参数（也称为参数或参数）并返回输出值。函数的主要目的是将一段代码组织成一个逻辑单元，以便在程序中的不同位置多次使用。（提高代码的复用，减少代码的重复编写）

函数有以下几个元素：

1. 函数定义：使用?def?关键字来定义一个函数，后面跟着函数名和一对圆括号。函数名应该简洁明确，能够描述函数的功能。
2. 参数：函数可以接受零个或多个参数，参数是函数的输入。参数放在函数名后面的圆括号内，可以在函数体内使用。
3. 函数体：函数体是包含在冒号后面的一段缩进代码块。它包含了函数的具体实现逻辑，定义了函数执行时要执行的操作。
4. 返回值：函数可以使用?return?语句返回一个值。返回值是函数的输出，可以在函数调用时进行接收和使用。

函数的优点是可以提高代码的可读性和可维护性，避免了重复编写相同的代码块。通过合理地使用函数，可以将程序分解为更小的、可管理的部分，使程序结构更加清晰和模块化。

函数的关键术语：

1. 函数的调用：使用函数名（）可以执行一个函数
2. 函数的形参：也就是形式参数，在声明一个函数时的小括号中使用使用，
3. 函数的实参：在调用函数时使用，将实参赋予形参，完成函数的调用。
4. 函数的返回值：返回函数的运算结果，默认为None，也就是没有返回值，可以通过return将结果返回，return后续代码不会执行，也就是直接终止函数；return也可以有多个返回值，返回值赋予一个变量时为元组形式输出；赋予多个变量时，分别赋予。如下图所示代码。

# 返回值
def func():
    return 100, 50


r = func()
print(r)
r1, r2 = func()
print(r1)
print(r2)

2 函数的调用

def func():
    """
    这是一个函数
    :return:
    """
    print("醒醒啦")


# 函数的调用
func()

def wakeup(name, num):
    for i in range(num):
        print(f"醒醒啦{name}")


wakeup("小美", 5)

小练习：封装一个函数 求从start到stop之间相差为step的质数对

def prime(start, stop, step):
    for i in range(start, stop + 1 - step):
        for j in range(2, i):
            if i % j == 0:
                break
        else:
            for k in range(2, i + step):
                if (i + step) % k == 0:
                    break
            else:
                print(f"({i}, {i + step})")


prime(500, 1000, 6)

3 函数变量作用域

在Python中，函数变量的作用域是指可以访问和使用该变量的代码范围。

Python中的函数变量作用域规则如下：

1. 局部作用域（Local scope）：在函数内部定义的变量具有局部作用域，只能在函数内部访问。这些变量在函数调用结束后会被销毁。

2. 嵌套作用域（Enclosing scope）：如果函数内包含其他函数，那么内部函数可以访问外部函数的变量。外部函数的变量对于内部函数来说具有嵌套作用域。

3. 全局作用域（Global scope）：在函数外部定义的变量具有全局作用域，可以在整个程序中访问。全局变量在程序执行期间一直存在。

4. 内置作用域（Built-in scope）：Python内置的函数和变量具有内置作用域，可以在任何地方访问。

当在函数内部引用一个变量时，Python会按照以下顺序查找变量：

1. 首先，在当前函数的局部作用域中查找变量。
2. 如果在当前函数的局部作用域中找不到变量，则在嵌套作用域中查找。
3. 如果还找不到变量，则在全局作用域中查找。
4. 如果最终还找不到变量，则抛出NameError异常。

如果要在函数内部修改全局变量的值，需要使用global关键字进行声明，需要注意的是：在函数内部使用global关键字声明变量时，应该谨慎使用，以避免对全局命名空间造成混乱。通常情况下，推荐在函数内部使用局部变量，而不是直接修改全局变量。

如下所示代码，i为函数内部定义的代码，是局部变量，函数外部不能使用。

def f1(m):
    # i 是函数内部定义的局部变量，函数外部不能使用
    i = 10
    print(i, m)


f1(20)
print(f1(20))

（1）认为a是外部变量 可以获取

a = 10

def f2():
    # 第一种 认为a是外部变量 可以获取
    print(a)


f2()
print(a)

（2）第二种 因为后续有a的赋值，所以认为a尚未定义就直接使用，此时报错

a = 10

def f2():
#    因为后续有a的赋值，所以认为a尚未定义就直接使用
    print(a)
    a = 20

f2()
print(a)

（3）如果是设置a，相当于函数内部重新定义局部变量a

此时调用函数结果a = 20，打印a，并没有调用函数，a取值不变

a = 10

def f2():
    # 如果是设置
    # 相当于函数内部重新定义局部变量a
    a = 20
    print(a)


f2()
print(a)

（4）第三种情况：使用global声明，此时再使用的就是外部变量，也可修改此变量

可以看到，调用函数时，函数内部打印语句在赋值语句上方，此时打印的是还未修改的a

当调用过函数后，再打印a，此时a修改为20了

a = 10

def f2():
    # 第三种情况
    # 使用global声明使用的就是外部变量
    global a
    print(a)
    a = 20



f2()
print(a)

4 函数参数

4.1 位置参数

如下方所示代码，调用函数时的实参一次赋予对应位置的形参

def f1(a, b):
    print(a, b)


f1(10, 20)


def f1(a, b, c):
    print(a, b, c)


f1(10, 20, 100)

4.2 默认参数

如下方所示代码，c，d有默认参数，c=100，d=50，当没有赋予其实参时，cd等于默认参数值；

当赋予其实参时，等于实参。

# 默认参数
def f2(a, b, c=100, d=50):
    print(a, b, c, d)


f2(10, 20)
f2(10, 20, 30)
f2(10, 20, 30, 40)

4.3 关键字参数

需要注意的是，要想赋予d参数而非赋予c，应在定义函数的位置将参数d的位置放于形参c前方。

另一种方法就是可以使用关键字，直接定位该参数。此时，虽然参数d排在参数c后面，仍然可以越过c向参数d赋值

# 关键字参数
def f3(a, b, c=10, d=20):
    print(a, b, c, d)


f3(100, 200, d=400)

4.4 可变参数

在Python中，函数参数可以接受可变数量的参数。这些参数被称为可变参数，可以是任意数量、任意类型的参数。可变参数可以使函数更加通用和灵活。

Python提供了两种方式来定义可变参数：*args和**kwargs。

• *args：用于传递任意数量的位置参数，它将所有的位置参数打包成一个元组(tuple)。在函数内部，可以使用这个元组来访问这些参数。

def f4(a, b, *args):
    print(a, b, args)


f4(10, 50, 3, 8, 4, 6, 8, 905, 656, 65, 2, 65, 2, 65, 2, 65)

• **kwargs：用于传递任意数量的关键字参数，它将所有的关键字参数打包成一个字典(dict)。在函数内部，可以使用这个字典来访问这些参数。

def f5(a, b, *args, **kwargs):
    print(a, b, args, kwargs)


f5(10, 20, 30, 40, 50, 80, 90, c=60, d=70)

def f6(a, b, c=100, *args, **kwargs):
    print(a, b, c, args, kwargs)


f6(10, 20, 30, 40, 50, 60, 70, 80, e=90, d=100)

5 匿名函数lambda

在Python中，可以使用lambda表达式来创建匿名函数。Lambda表达式是一种简洁的语法，可以用来定义简单的函数，通常只包含一个表达式。.

Lambda表达式的语法如下：

lambda arguments: expression

其中，arguments是函数参数，可以是零个或多个，使用逗号分隔。expression是一个表达式，作为函数的返回值。

需要注意的是，lambda表达式创建的函数通常只包含一个表达式，这个表达式的计算结果就是函数的返回值。如果需要编写复杂的函数，应该使用def语句来定义普通函数。

f2 = lambda: print("醒醒啦")
print(type(f2))
f2()

f3 = lambda: 100

print(f3())

f4 = lambda x, y: x+y
print(f4(5, 10))

小应用：按照“age”键排序

l = [{"name": "a", "age": 50}, {"name": "b", "age": 20}]

l.sort(key=lambda e: e["age"])
print(l)

6 递归函数?

递归函数是一种在函数定义中调用自身的方式。通过递归函数，可以解决一些问题，特别是那些可以被分解为较小、相似的子问题的问题。

递归函数通常具有以下几个要素：

1. 基本情况（Base Case）：递归函数必须包含一个或多个基本情况，即函数可以直接返回结果而不进行递归调用的情况。基本情况通常是针对最简单的输入而言的。

2. 递归调用（Recursive Call）：递归函数会调用自身来解决较小的子问题。通过将问题分解为更小的子问题，递归函数可以逐步解决整个问题。

需要注意的是，在编写递归函数时，必须确保递归调用能够趋近于基本情况，否则可能会导致无限递归而导致栈溢出。同时，递归函数也可能存在效率较低的问题，因为它会重复计算一些子问题。

使用递归计算1+2+3+4+....+100

def f(n):
    if n == 1:
        return 1
    else:
        return n+f(n-1)


r = f(100)
print(r)

使用递归计算n的阶乘

def f1(n):
    if n == 1:
        return 1
    else:
        return n * f1(n-1)


r = f1(5)
print(r)

使用递归求斐波那契数列第n个数

def fibonacci(n):
    if n < 3:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)


r = fibonacci(6)
print(r)