一、创建函数和使用函数

1、创建函数和使用函数

定义函数不会执行
函数的输入叫做参数，函数的输出叫返回值
形参：形式参数，不是真实的值（定义函数时的时的参数，例如num1，num2）
实参：实际存在的参数，是真实的值（调用函数时的参数，例如30，80）
1
2
3
4

def get_max(num1,num2):                            定义函数
    result = num1 if num1 > num2 else num2
    return result

max_num = get_max(30,80)                           使用函数
print(max_num)

#结果
80
1
2
3
4
5
6
7
8
9

二、函数的作用域

(1)、全局变量

全局都生效的变量

name = 'admin'
def login():
    print(name)
login()
#结果
admin
1
2
3
4
5
6

(2)、局部变量

1、局部变量
局部生效的变量，函数内部的变量

def logout():
    age = 19             这里的age变量是局部的
logout()
print(age)               没法输出
#结果
NameError: name 'age' is not defined
1
2
3
4
5
6

2、 函数内部修改全局变量

这里的mongey是全局变量
如果要在函数中修改全局的变量，不能直接修改。
如果要修改全局变量，需要使用global声明修改的变量
1
2
3

def hello():
	global money                    声明全局变量
    money +=1
    print(money)
money = 100
hello()
#结果
101
1
2
3
4
5
6
7
8

3、补充
针对可变数据类型：不用在定义函数里面进行全局变量声明
针对不可变数据类型：需要在函数里面进行全局变量声明

def hello():
    global money                  可变数据需要全局声明
    money +=1
    users.append('user1')
    print(money,users)
money = 100                       不可变数据类型
users = []                        可变数据类型
hello()
#结果
101 ['user1']
1
2
3
4
5
6
7
8
9
10

三、参数传递
1、形参和实参
2、参数检查
设置提示

def get_max(num1:int,num2:int)->int:
    return num1 if num1 > num2 else num2
result = get_max('hello',1)
print(result)
1
2
3
4

设定好参数后这样会有检查提示

3、三个引号之间的会作为解释说明，help可以展示说明

def get_max(num1:int,num2:int) -> int:
    """
    求两个数的最大值
    param num1:整型数1
    param num2:整型数2
    """
    return num1 if num1 > num2 else num2
result = get_max(2,1)
print(result)
print(help(get_max))
#结果
2
Help on function get_max in module __main__:
get_max(num1: int, num2: int) -> int
    求两个数的最大值
    param num1:整型数1
    param num2:整型数2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4、真正判断参数类型

def get_max(num1:int,num2:int) -> int:
    """
    求两个数的最大值
    param num1:整型数1
    param num2:整型数2
    """
    if isinstance(num1, int) and isinstance(num2,int):      这里是对参数进行判断，是否为整型
        return num1 if num1 > num2 else num2
    else:
        return 0
    
result = get_max(2,30.1)
print(result)
#结果
0                   不是整型，因此返还为else的值0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

三、常见的四类参数

1、必选参数
代码中的必选参数是实参2，30

def get_max(num1: int, num2: int) -> int:
    return num1 if num1 > num2 else num2

result = get_max(2, 30)
print(result)
print(help(get_max))
def pow(x, y=2):
    return x ** y
1
2
3
4
5
6
7
8

2、默认参数
这里默认参数是形参y=2

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

result = pow(3)                #这里x=3，y使用默认参数y=2
print(result)
result = pow(2,4)              #这里x=2，改变默认参数使得y=4
print(result)
#结果
9
16
1
2
3
4
5
6
7
8
9
10

3、可变参数
参数的可数会变化，可以传0，1，2，3，…n个参数
args=arguments
其类型是元组

def my_sum(*args):
    print(args)

my_sum(1,2,3)
my_sum(1,2,4,5,6,)
my_sum(1)
my_sum()
#结果
(1, 2, 3)
(1, 2, 4, 5, 6)
(1,)
()
1
2
3
4
5
6
7
8
9
10
11
12

利用这种方式即可进行多个参数的计算

def my_sum(*args):
    return sum(args)

result=my_sum(1,2,3)
print(result)
#结果
6
1
2
3
4
5
6
7

4、关键字参数：
可以传递key和value
**kwargs可以存贮在字典中

def enroll(name,age=18,**kwargs):
    print(f"""
        入学信息
    1. 姓名：{name}
    2. 年龄：{age}
    3.其他：{kwargs}
    """
    )
enroll('张三',country='china',english='GRE',sport=['篮球'])
#结果
        入学信息
    1. 姓名：张三
    2. 年龄：18
    3.其他：{'country': 'china', 'english': 'GRE', 'sport': ['篮球']}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

四、匿名函数

匿名函数指一类无须定义标识符的函数或子程序。Python用lambda语法定义匿名函数，只需用表达式而无需申明。(省略了用def声明函数的标准步骤)
示例1

get_max = lambda num1,num2:num1 if num1 > num2 else num2
result=get_max(1,10)
print(result)  
#结果
10
1
2
3
4
5

示例2

get_max = lambda x,y=2:x ** y
    result=get_max(4)
print(result)
#结果
16
1
2
3
4
5

五、练习题

将数组[0,7,0,2]输出为[1，2，0，0]
采用算法和匿名函数结合的方式
解题思路

"""
0 7 0 2   排序前
1 0 1 0   指定规则：（1 if num==0 else 0)
0 0 1 1
7 2 0 0   排序后
"""
1
2
3
4
5
6

nums = [0,7,0,2]
nums.sort(key=lambda  num: 1 if num==0 else 0)
print(nums)
#结果
[7, 2, 0, 0]
1
2
3
4
5

将所有的偶数排前面，奇数排后面

nums = [1,10,2,4,8,17]
nums.sort(key = lambda num: 1 if num%2==1 else 0)
print(nums)
#结果
[10, 2, 4, 8, 1, 17]
1
2
3
4
5

六、递归函数

1、递归的使用
需求：求n的阶乘
方法1：for循环

res = 1
n = 3 #3!=3*2*1
    for i in range(1,n+1):
        res = res * i
    print(res)
1
2
3
4
5

方法2：递归
n! = n*(n-1)!=n*(n-1)*(n-2)!

def f(n): 
    return 1 if n==1 else n*f(n-1)
print(f(5))
#结果
120
1
2
3
4
5

2、递归实现斐波那契数列

def fib(n):
    if n ==1 or n==2:              这里设定n=1，n=2时的值
        return 1
    else:
        return fib(n-1)+fib(n-2)
print(fib(7))
1
2
3
4
5
6