Python -- 函数-CSDN博客

本文链接：https://blog.csdn.net/qq_24805129/article/details/124456983

本文详细介绍了Python函数的使用，包括语法、返回值、参数传递（位置参数、关键字参数、默认参数）、收集参数、变量作用域（局部变量与全局变量）、`global`关键字的使用、函数嵌套以及局部变量的`nonlocal`关键字。通过实例解析了LEGB命名查找规则，并简要提及了闭包的概念。

摘要由CSDN通过智能技术生成

函数

此篇博客作为python学习笔记，可能出现内容不全，解释不规范的情况。欢迎指正，此篇博客也会持续进行更新改进，谢谢！

语法

def 函数名(参数表):
    函数体
    return 返回值

返回值

如果返回值为空，则默认位None

python可以返回元组、字典、列表等数据类型实现返回多个值的效果。

参数传递

在python中，函数的参数传入时,每一个非默认参数都需要被赋值,其传参规则如下:

位置参数

位置参数必须按与声明一致的顺序和个数传入函数,否则会报错

def sum(a, b, c):
    return a + b + c


print(sum(1, 2, 3))

#输出
6

关键字参数

使用关键字参数进行传递时,允许函数调用时参数的顺序与声明不一致,因为Python解释器可以用参数名匹配参数值

注意：在关键字参数与位置参数同时存在时，必须要让位置参数位于关键字参数之前，此时会先按顺序赋完位置参数再赋关键字参数，因此要保证同一参数不会被重复赋值。

def sum(a, b, c, d):
    print("a=", a, ',', 'b=', b, ',', 'c=', c, ',', 'd=', d, sep='')
    return a + b + c + d


print(sum(3, 2, d=2, c=3))


# 输出
a=3,b=2,c=3,d=2
10

默认参数

在函数声明时,给参数赋一个默认值。如果该参数没有被传入，则会被认为是默认值。

**注意：**在函数声明时，要保证非默认参数在默认参数之前，即第一个默认参数之后不能是非默认参数。

def sum(a, b, c, d=1000000):
    print("a=", a, ',', 'b=', b, ',', 'c=', c, ',', 'd=', d, sep='')
    return a + b + c + d


print(sum(3, 2, d=2, c=3))
print(sum(a=1, b=2, c=2)) # 不给b赋值

# 输出
a=3,b=2,c=3,d=2 # d的值被覆盖
10
a=1,b=2,c=2,d=1000000 # d为默认值
1000005

收集参数

当传入参数不定长时，可以时候收集参数进行储存。其会被函数以元组或字典的形式打包起来。

注意：如果在收集参数之后还要指定其他参数，那么必须使用关键字参数进行传参，否则会被收集参数吸收，赋值失败。

def sum(*arge, **jj):  # *arge表示收集参数，打包成元组  **jj表示打包成字典
    i = 0
    for x in range(len(arge)):
        i += arge[x]
    print(jj)
    print("sum of the 'arge' is:", i)
    return arge


print(sum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, c=2, d=3)) # *jj传入是需要符合字典的规则


# 输出
{'c': 2, 'd': 3}  # **jj是字典
sum of the 'arge' is: 55
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  #返回值是一个元组，说明参数传入是被打包成一个元组

当我们希望前面的参数只能是位置参数（不支持关键字参数），后边参数无限制，我们可以使用/。

def sum(a, b, c, /, e, f, g): 
    pass

当我们希望左侧是任意参数，后面只能使用关键字参数传参时，我们可以通过匿名的收集参数实现。

def sum(a, b, c, *, e, f, g): 
    pass

变量的作用域

局部变量

在某个代码块、函数中定义的变量，生存周期仅限于该代码块，函数被调用的时间，退出时即被销毁，外部无法访问。

当局部变量与全局变量重名时，该变量的值在块内为局部变量，外部为全局变量。（同名不用样，id不同）

全局变量

在函数外部定义的变量，函数可以直接对其进行访问，但进行修改。

a = 100000


def f():
    print(a, id(a)) #可以直接访问
    # a+=1    错误，无法对全局变量进行修改


f()
print(a, id(a))

# 输出
100000 17371904
100000 17371904

global

如果真的希望在函数内部修改全局变量的值，我们需要使用global语句进行修改。

a = 100000


def f():
    global a
    print("f()访问a:", a, id(a))  # 可以直接访问
    a = 999  # 错误，无法对全局变量进行修改


print("f()修改前：", a, id(a))
f()
print("f()修改后：", a, id(a))

# 输出
f()修改前： 100000 20648704
f()访问a: 100000 20648704
f()修改后： 999 20652016

函数嵌套

我们可以在函数中嵌套另一个函数，只能在外部函数调用内部函数，但在外面无法直接调用内部函数。同时，内部函数无法修改外部函数的变量。

def A():
    x = 100

    def B():
        x = 100
        print("B: x=", x)

    B()
    print("A: x=", x)


A()
# B()   错误

# 输出
B: x= 100
A: x= 100

local语句

如果希望内部函数可以调用外部函数的变量，那么可以通过local语句。

def A():
    x = 100

    def B():
        nonlocal x
        x = 100
        print("B: x=", x)

    B()
    print("A: x=", x)


A()
def A():
    x = 100

    def B():
        nonlocal x
        x = 100
        print("B: x=", x)

    B()
    print("A: x=", x)


A()

# 输出
B: x= 100
A: x= 100