六、函数

1、函数概述

 2、语法格式：

         

 def：标记函数的开始

 3、定义函数

## 例1    无参函数
def add():
    result = 11 + 22
    print(result)

## 例2   有参函数
def add_modify(a, b):
    result = a + b
    print(result)

4、调用函数

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

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

函数的嵌套定义。函数外部无法直接调用内层函数，只能通过外层函数间接调用内层函数

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

5、函数参数的传递。函数的参数传递是指将实际参数传递给形式参数的过程。

## 例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连接！

6、参数的打包与解压

（1）打包：

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

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

## 例1   “ * ”
def test(*args):
    print(args)
test(11, 22, 33, 44, 55)

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

## 例2 “ ** ”
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）解压：

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

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

## 例1  “ * ”
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}

## 例2 “ ** ”
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

混合传递：

规则：优先按位置参数传递的方式；然后按关键字参数传递的方式；之后按默认参数传递的方式；最后按打包传递的方式。

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

## 例
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}

7、函数的返回值

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

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

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

##结果
(160, 40)

8、函数的作用域

（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

（3）global关键字

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

（4）nonlocal关键字

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

9、递归函数格式：

def函数名([参数列表])：

             if 边界条件：

                         rerun 结果

             else:

                         return 递归公式

## 例
def func(num):
     if num == 1: 
         return 1
     else:
         return num * func(num - 1)
num = int(input("请输入一个整数："))
result = func(num)
print("5!=%d"%result)

10、匿名函数

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