python函数

函数特点：将程序模块化，既减少了冗余代码，又让程序结构更为清晰 提高开发人员的编程效率 方便后期的维护与扩展

5.1：定义函数：def

 

#无参函数
def add():
    result = 11 + 22
    print(result)
#有参函数
def add_modify(a, b):
    result = a + b
    print(result)

5.2 调用函数：函数在定义完成后不会立刻执行，直到被程序调用时才会执行

（1)格式：函数名([参数列表])

add()
add_modify(10, 20)

（2）嵌套调用

def add_modify(a, b):
    result = a + b
    add()   #嵌套调用函数add()	
    print(result)
add_modify(10, 20)

（3）函数在定义时可以在其内部嵌套定义另外一个函数，此时嵌套的函数称为外层函数，被嵌套的函数称为内层函数。

def add_modify(a, b):
    result = a + b
    print(result)
    def test(): 
        print("我是内层函数")                  
add_modify(10, 20)
#函数外部无法直接调用内层函数
只能通过外层函数间接调用内层函数

5.3 传递参数：将实际参数传递给形式参数的过程。

（1）位置参数传递：函数在被调用时会将实参按照相应的位置依次传递给形参，将第一个实参传递给第一个形参，将第二个实参传递给第二个形参，以此类推

def get_max(a, b):
    if a > b:
        print(a,"是较大的值！")
    else:
        print(b,"是较大的值！")
get_max(8, 5)
运行结果：
8是较大的值

（2）关键字参数传递：通过“形参=实参”的格式将实参与形参相关联，将实参按照相应的关键字传递给形参。

def connect(ip, port):
    print(f"设备{ip}:{port}连接！")
connect(ip="127.0.0.1", port=8080)

（3）默认参数传递：

#定义
def connect(ip, port=8080):
    print(f"设备{ip}:{port}连接！")
#调用
connect(ip="127.0.0.1")
connect(ip="127.0.0.1", port=3306)
#运行结果
设备127.0.0.1:8080连接！
设备127.0.0.1:3306连接！

5.4 参数的打包和解包

（1）打包

函数在定义时无法确定需要接收多少个数据，可以在定义函数时为形参添加“*”或“**”：

“*” —— 接收以元组形式打包的多个值

#定义
def test(*args):
    print(args)
#调用
test(11, 22, 33, 44, 55)
#结果
(11, 22, 33, 44, 55)

“**”—— 接收以字典形式打包的多个值，但建议使用*args和**kwargs； 若函数没有接收到任何数据，参数*args和**kwargs为空，即它们为空元组或空字典。

#定义
def test(**kwargs):
    print(kwargs)
#调用
test(a=11, b=22, c=33, d=44, e=55)
#结果
{'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 55}

（2）解包

实参是元组   →   可以使用“*”拆分成多个值  →  按位置参数传给形参

def test(a, b, c, d, e):
    print(a, b, c, d, e)
#调用
nums = (11, 22, 33, 44, 55)
test(*nums)
#结果
{'a': 11, 'b': 22, 'c': 311 22 33 44 553, 'd': 44, 'e': 55}

实参是字典   →    可以使用“**” 拆分成多个键值对    →    按关键字参数传给形参

def test(a, b, c, d, e):
    print(a, b, c, d, e)
#调用
nums = {"a":11, "b":22, "c":33, "d":44, "e":55}
test(**nums)
#结果
11 22 33 44 55

5.5 混合传递

规则：

定义函数时： 带有默认值的参数必须位于普通参数之后。

带有“*”标识的参数必须位于带有默认值的参数之后。

带有“**”标识的参数必须位于带有“*”标识的参数之后。

#定义
def test(a, b, c=33, *args, **kwargs):
print(a, b, c, args, kwargs)
#调用
test(1, 2)
test(1, 2, 3)
test(1, 2, 3, 4)
test(1, 2, 3, 4, e=5)
#结果
1 2 33 () {}
1 2 3 () {}
1 2 3 (4,) {}
1 2 3 (4,) {'e': 5}

5.6 函数的返回值

（1）return在函数结束时将数据返回给程序，同时让程序回到函数被调用的位置继续执行。

#定义
def filter_sensitive_words(words):
    if "山寨" in words:
        new_words = words.replace("山寨", "**")
        return new_words
#调用
result = filter_sensitive_words("这个手机是山寨版吧！")
print(result)
#结果
这个手机是**版吧！

（2）如果函数使用return语句返回了多个值，那么这些值将被保存到元组中。

#定义
def move(x, y, step):
    nx = x + step
    ny = y - step
    return nx, ny     # 使用return语句返回多个值
#调用
result = move(100, 100, 60)  	
print(result)
#结果
(160, 40)

5.7 变量作用域

变量的访问权限取决于变量定义的位置，其所处的有效范围称为变量的作用域。根据作用域的不同，变量可以划分为局部变量和全局变量。

（1）局部变量

函数内部定义的变量，只能在函数内部被使用；函数执行结束之后局部变量会被释放，此时无法再进行访问。

不同函数内部可以包含同名的局部变量，这些局部变量的关系类似于不同目录下同名文件的关系，它们相互独立，互不影响。

def test_one():
    number = 10      
    print(number)             # 访问test_one()函数的局部变量number
def test_two():
    number = 20
    print(number)             # 访问test_two()函数的局部变量number
test_one()
test_two()
#结果
10
20

（2）全局变量

在整个程序的范围内起作用，不受到函数范围的影响

在函数内部只能被访问，而无法直接修改

number = 10         	# 全局变量
def test_one():
    print(number)   	# 函数内部访问全局变量
test_one()
print(number)       	# 函数外部访问全局变量
#运行结果
10
10

5.8  global和nonlocal关键字

使用global关键字将局部变量声明为全局变量

number = 10                    # 定义全局变量
def test_one():
    global number              # 使用global声明变量number为全局变量
    number += 1
    print(number)
test_one()
print(number)

使用nonlocal关键字在局部作用域中修改嵌套作用域中定义的变量

def test():
    number = 10
    def test_in():
        nonlocal number
        number = 20
    test_in()
    print(number)
test()

5.9 递归函数

指函数在定义时调用了自身

递归函数在定义时需要满足两个基本条件：一个是递归公式，另一个是边界条件。其中: 递归公式是求解原问题或相似的子问题的结构； 边界条件是最小化的子问题，也是递归终止的条件。

递归函数的执行时的两个阶段： 1.递推：递归本次的执行都基于上一次的运算结果。 2.回溯：遇到终止条件时，则沿着递推往回一级一级地把值返回来。

def函数名([参数列表])：
	if 边界条件：
		rerun 结果
	else:
		return 递归公式

5.10 匿名函数

匿名函数是一类无需定义标识符的函数，用法与普通函数一样

普通函数与匿名函数的主要区别： 前者的函数体中包含有多条语句，在定义时有名称，可实现比较复杂的功能，后者函数体只能是一个表达式，没有名称，可实现的功能简单；  普通函数能被其他程序使用，而匿名函数不能被其他程序使用。

定义好的匿名函数不能直接使用，最好使用一个变量保存它，以便后期可以随时使用这个函数。

# 定义匿名函数，并将它返回的函数对象赋值给变量temp
temp = lambda x : pow(x, 2) 
temp(10)