4、python中函数、匿名函数、递归函数

如果在编写程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以将具有独立功能的代码块组织为一个小模块，这就是函数。

函数的创建和调用

• 形参就是定义函数时的参数
• 实参就是调用函数时的参数

#如何定义一个函数
#定义函数，如果不调用函数，那么函数的内容不会执行
def get_max(num1,num2):
    result = num1 if num1>num2 else num2
    return result
# 调用函数
max_num=get_max(89,20)
print(max_num)
1
2
3
4
5
6
7
8

空函数

如果要定义一个函数，但是还没想好怎么些函数的代码，就可以先放一个pass语句，让代码运行起来。

• pass只是一个占位符，不做任何操作

def login(username: str, password: str):
    pass
1
2

变量的作用域

• 可变数值类型：列表、字典、集合
• 不可变数据类型：数值型、字符串、元组

全局变量

全局变量是全局生效的变量【函数外部定义的变量，在任何地方都能访问到】

def login():
    print(name)

name = "root"  #全局变量
login()
1
2
3
4
5

局部变量

局部变量只能局部生效的变量 【函数内部定义的变量，只能在函数内部访问】

def login():
    name = "root"  #局部变量
    print(name)
login()
1
2
3
4

不同的函数，可以定义相同名字的局部变量，而且各个函数里的局部变量互不影响

def savemoney(money):
    allmoney = 100
    print("存钱前:", allmoney)
    allmoney += money
    print("存钱后:", allmoney)

def viewmoney():
    allmoney = 500
    print("查询金额:", allmoney)

savemoney(50)
viewmoney()
1
2
3
4
5
6
7
8
9
10
11
12

函数内部修改全局变量

• 如果要在函数内修改全局变量，不能直接修改，需要先使用global关键字声明修改的变量是全局变量
• 如果全局变量是可变数据类型，那么在函数内部对该变量修改就不用global关键字声明
• 如果全局变量是不可变数据类型，那么在函数内部对该变量修改就需要global关键字声明

def fun():
    global money
    money += 1
    print(money)
    li.append('user2')
    print(li)

money = 100  # 全局变量，不可变数据类型
li=['user1'] #全局变量，可变数据类型
fun()
1
2
3
4
5
6
7
8
9
10

函数参数传递

参数检查

isinstance(var,int) 判断变量var是否为int

#在定义函数时，写上函数的类型说明
def get_max(num1: int, num2: int) -> int:  # 提示输入的实参应该为整型，且该函数的返回值也为整型
    """
    求两数的最大值 （函数的说明）
    :param num1:整数1
    :param num2: 整数2
    :return: 最大值
    """
    if isinstance(num1,int) and isinstance(num2,int):
        return num1 if num1 > num2 else num2
    else:
        return 0

result=get_max(30, 20)
print(result)
#print(help(get_max))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

常见的4类形参

必选参数

必须要传递的参数

#num1和num2是必选参数，必须要传递
def get_max(num1: int, num2: int) -> int:
    return num1 if num1 > num2 else num2

result=get_max(40, 20)
print(result)
1
2
3
4
5
6

默认参数

默认参数，可传可不传的参数

def pow(x, y=2):
    return x ** y

result = pow(4)  # x=4,y=2 result=16
print(result)
result = pow(3, 3)  # x=3,y=3 result=27
print(result)

1
2
3
4
5
6
7
8

可变参数–*args接收的是一个元组

可变参数，参数的个数会变化，可以传0，1，2，3，4…n个参数
形参使用args，把传入的n个值都保存在元组中

# 可变参数，参数的个数会变化，可以传0，1，2，3，4...n个参数
#args是元组，把传入的n个值都保存在一个元组中
#args==arguments
def my_sum(*args):
    print(f"args为{args}")
    print(f"各个元素和为:{sum(args)}")

my_sum(1,2,3,4)
my_sum(1,2,4,76,9,65)
my_sum()
1
2
3
4
5
6
7
8
9
10

关键字参数–**kwargs接收的是一个字典

可以传递key和value
形参使用**kwargs，把传入的参数存放在字典中

def enroll(name,age=18,**kwargs):
    print(f"""
         入学信息登记
    1.姓名：{name}
    2.年龄:{age}
    3.其他信息:{kwargs}   
    """)

enroll('lee',country='china',english='cet-6',sports=['篮球','羽毛球'])
1
2
3
4
5
6
7
8
9

如果一个函数形式为 fun(*args,**kwargs)，则表示该函数能接收任意的参数

匿名函数

匿名函数是指一类无需定义标识符的函数或子程序。python中使用lambda语法定义匿名函数。

# 一般函数的写法：
# def get_max(num1,num2):
#    return num1 if num1>num2 else num2
#匿名函数的写法
get_max = lambda num1, num2: num1 if num1 > num2 else num2
print(get_max(29, 2))

#def pow(x,y=2):
#    return x**y
get_pow=lambda x,y=2: x**y
print(get_pow(2))
print(get_pow(3,3))

1
2
3
4
5
6
7
8
9
10
11
12
13

练习题，将整型数组的0移动到末尾

给定一个整型数组，将数组中的所有0移动到末尾，非0项保持不变；
在原始数组上进行移动操作，勿创建新的数组；
输入：数组的记录；0702
输出：调整后数组的内容；7200

在匿名函数中自定义数组的排序规则，思路为：
0 7 0 2 -数组，before sorted
1 0 1 0 -排序规则( 1 if number==0 else 0)
0 0 1 1
7 2 0 0 -after sorted

nums=[0,7,0,2]
result=sorted(nums,key=lambda num:1 if num==0 else 0)   
print(result)  #[7, 2, 0, 0]

#由于题目要求是在原数组上修改
nums.sort(key=lambda num:1 if num==0 else 0)
print(nums)
1
2
3
4
5
6
7

sorted（）函数的参数key是函数类型，用来支持自定义的排序方式。
传递给key参数的是一个函数，它指定可迭代对象中的每一个元素来按照该函数进行排序。
带入上述实例：
匿名函数定义了规则： 1 if num==0 else 0
key参数接收到的是匿名函数，然后使用该匿名函数对数组中的每个元素进行排序

类似的思路也能实现将数组中偶数往前排，奇数往后排：

"""
自己定义数组排序规则：
0 7 0 2 -数组，before sorted
1 0 1 0 -排序规则( 1 if number%2==0 else 0)
0 0 1 1
7 2 0 0  -after sorted
"""
#实现将数组中偶数排在前面，奇数排在后面，
nums=[0,7,0,2]
result=sorted(nums,reverse=True,key=lambda num:1 if num%2==0 else 0)
print(result)

#由于题目要求是在原数组上修改
nums.sort(reverse=True,key=lambda num:1 if num%2==0 else 0)
print(nums)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

递归函数

函数可以在内部调用其他函数。
如果一个函数在内部调用自己本身，那么这个函数就是递归函数

求n的阶乘

n!=n*(n-1)!=n*(n-1)(n-2)!=n(n-1)(n-2)(n-3)!=…

# 求数值的阶乘
# res = 1
# n = 3
# for i in range(1, n + 1):
#     res = res * i
# print(res)
def fac(n):
    if n == 1:
        return 1
    else:
        return n * fac(n - 1)
print(fac(3))
print(fac(5))
1
2
3
4
5
6
7
8
9
10
11
12
13

求斐波那契数列

def fib(n):
    if n == 1 or n == 2:
        return 1
    else:
        return fib(n - 1) + fib(n - 2)
# 1 1 2 3 5 8
print(fib(6))
1
2
3
4
5
6
7

汉诺塔游戏
如果有n个盘子，那么总共需要移动2^n-1次