第五章：函数

1.概述

组织好、实现单一功能或相关联动的代码段

未使用函数的程序                                             使用函数的程序

结构清晰，代码精简 

函数式编程优点：

（1） 将程序模块化，既减少了冗余代码，又让程序结构更为清晰

（2）提高开发人员的编程效率

（3）方便后期的维护与扩展

2.定义

def（）

def 函数名（[参数列表]）;
    ["""文档字符串"""]
    函数体
    [return语句]

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

3.调用

函数名([参数列表])

add()
add_modify(10, 20)

1. 程序在调用函数的位置暂停执行。

2. 将数据传递给函数参数。

3. 执行函数体中的语句。

4. 程序回到暂停处继续执行。

嵌套调用

def add_modify(a, b):
    result = a + b
    add()   	
    print(result)
add_modify(10, 20)

 

 内部嵌套定义另外一个函数，此时嵌套的函数称为外层函数，被嵌套的函数称为内层函数

def add_modify(a, b):
    result = a + b
    print(result)
    def test(): 
        print("我是内层函数")                  
add_modify(10, 20)

函数外部无法直接调用内层函数

只能通过外层函数间接调用内层函数

4.参数的传递

 定义函数时设置的参数称为形式参数（简称为形参），将调用函数时传入的参数称为实际参数（简称为实参）。函数的参数传递是指将实际参数传递给形式参数的过程。

（1）位置传参

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

（2）关键字传参

“形参=实参”的格式将实参与形参相关联

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

使用符号“/”来限定部分形参只接收采用位置传递方式的实参

def func(a, b, /, c):
    print(a, b, c)
# 错误的调用方式
# func(a=10, 20, 30)   
# func(10, b=20, 30)
# 正确的调用方式
func(10, 20, c=30)

（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连接！

（4）打包

在定义函数时为形参添加“*”或“**”：

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

def test(*args): #定义
    print(args)

test(11, 22, 33, 44, 55) #调用

(11, 22, 33, 44, 55) #结果

“**”—— 接收以字典形式打包的多个值

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} #结果

 虽然函数中添加“*”或“**”的形参可以是符合命名规范的任意名称，但这里建议使用*args和**kwargs。

若函数没有接收到任何数据，参数*args和**kwargs为空，即它们为空元组或空字典

（5）解包

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

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

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': 33, '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 #结果

（6）混合传递

优先按位置参数传递的方式

 然后按关键字参数传递的方式

之后按默认参数传递的方式

最后按打包传递的方式

定义时：

带有默认值的参数必须位于普通参数之后。

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

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

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.返回值

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

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

这个手机是**版吧！ #结果

返回多个值则被保存到元组

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

(160, 40) #结果

6.变量作用域

访问权限取决于变量定义的位置，有效范围称为变量的作用域

（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 #结果

只能访问全局变量，而无法直接修改全局变量

7.global和nonlocal关键字

（1）global

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

（2）nonlocal

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

8.递归函数

函数内部调用了自身

（1）基本条件：

递归公式是求解原问题或相似的子问题的结构

边界条件是最小化的子问题，也是递归终止的条件

（2）阶段：

递推：递归本次的执行都基于上一次的运算结果

回溯：遇到终止条件时，则沿着递推往回一级一级地把值返回来

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

9.匿名函数

lambda <形式参数列表> :<表达式>

区别：

（1）普通有名称，匿名无名称

（2）普通包含多条语句，匿名只能是一个表达式

（3）普通可实现较复杂功能，匿名可实现较简单功能

（4）普通可被其他程序使用，匿名不能

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