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)

Python中的函数_第1张图片

2 函数的调用

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


# 函数的调用
func()

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


wakeup("小美", 5)

Python中的函数_第2张图片

小练习:封装一个函数 求从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)

Python中的函数_第3张图片

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))

Python中的函数_第4张图片

(1)认为a是外部变量 可以获取

a = 10

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


f2()
print(a)

Python中的函数_第5张图片

(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)

Python中的函数_第6张图片

(4)第三种情况:使用global声明,此时再使用的就是外部变量,也可修改此变量

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

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

a = 10

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



f2()
print(a)

Python中的函数_第7张图片

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)

Python中的函数_第8张图片

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)

Python中的函数_第9张图片

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())

Python中的函数_第10张图片

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)

Python中的函数_第11张图片

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)

Python中的函数_第12张图片

你可能感兴趣的:(python,开发语言)