Python中的函数
1 函数的定义
在Python中，函数是一段可重复使用的代码块，用于执行特定的任务或操作。函数可以接受输入参数（也称为参数或参数）并返回输出值。函数的主要目的是将一段代码组织成一个逻辑单元，以便在程序中的不同位置多次使用。（提高代码的复用，减少代码的重复编写）
函数有以下几个元素：
- 函数定义：使用
def关键字来定义一个函数，后面跟着函数名和一对圆括号。函数名应该简洁明确，能够描述函数的功能。 - 参数：函数可以接受零个或多个参数，参数是函数的输入。参数放在函数名后面的圆括号内，可以在函数体内使用。
- 函数体：函数体是包含在冒号后面的一段缩进代码块。它包含了函数的具体实现逻辑，定义了函数执行时要执行的操作。
- 返回值：函数可以使用
return语句返回一个值。返回值是函数的输出，可以在函数调用时进行接收和使用。
函数的优点是可以提高代码的可读性和可维护性，避免了重复编写相同的代码块。通过合理地使用函数，可以将程序分解为更小的、可管理的部分，使程序结构更加清晰和模块化。
函数的关键术语：
- 函数的调用：使用函数名（）可以执行一个函数
- 函数的形参：也就是形式参数，在声明一个函数时的小括号中使用使用，
- 函数的实参：在调用函数时使用，将实参赋予形参，完成函数的调用。
- 函数的返回值：返回函数的运算结果，默认为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中的函数变量作用域规则如下：
-
局部作用域（Local scope）：在函数内部定义的变量具有局部作用域，只能在函数内部访问。这些变量在函数调用结束后会被销毁。
-
嵌套作用域（Enclosing scope）：如果函数内包含其他函数，那么内部函数可以访问外部函数的变量。外部函数的变量对于内部函数来说具有嵌套作用域。
-
全局作用域（Global scope）：在函数外部定义的变量具有全局作用域，可以在整个程序中访问。全局变量在程序执行期间一直存在。
-
内置作用域（Built-in scope）：Python内置的函数和变量具有内置作用域，可以在任何地方访问。
当在函数内部引用一个变量时，Python会按照以下顺序查找变量：
- 首先，在当前函数的局部作用域中查找变量。
- 如果在当前函数的局部作用域中找不到变量，则在嵌套作用域中查找。
- 如果还找不到变量，则在全局作用域中查找。
- 如果最终还找不到变量，则抛出
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 递归函数
递归函数是一种在函数定义中调用自身的方式。通过递归函数，可以解决一些问题，特别是那些可以被分解为较小、相似的子问题的问题。
递归函数通常具有以下几个要素：
-
基本情况（Base Case）：递归函数必须包含一个或多个基本情况，即函数可以直接返回结果而不进行递归调用的情况。基本情况通常是针对最简单的输入而言的。
-
递归调用（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)
