一 为何使用函数
没有函数会有什么问题？ 1.无组织无结构，代码冗余2.可读性差3.无法统一管理且维护成本高
总结使用函数的好处：
1.代码重用
2.保持一致性，易维护
3.可扩展性
二 函数的分类
在python中函数分两类：内置函数，自定义函数
1 #内置函数 2 # sum 3 # max 4 # min 5 # 6 # a=len(‘hello‘) 7 # print(a) 8 # 9 # b=max([1,2,3]) 10 # print(b)
1 #自定义函数 2 3 # # ****** 4 # # ****** 5 # # ****** 6 # # hello world 7 # # ****** 8 # # ****** 9 # # ****** 10 # 11 def print_star(): 12 print(‘#‘*6) 13 14 def print_msg(): 15 print(‘hello world‘) 16 17 print_star() 18 print_star() 19 print_star() 20 print_msg() 21 print_star() 22 print_star() 23 print_star()
三 函数的返回值
3.1 返回值的定义
1 def foo(): 2 print(‘from foo‘) 3 return None 4 res=foo() 5 print(res)
PS‘‘‘以三种情况返回值都为None：没有returnreturn 什么都不写return None‘‘‘
1 def foo(): 2 print(‘from foo‘) 3 x=1 4 return x 5 res=foo() 6 print(res)
3.2 return 一个值 函数调用返回的结果就是这个值
1 def foo():
2 print(‘from foo‘)
3 x=1
4 return 1,[2,3],(4,5),{}
5 res=foo()
6 print(res) #打印结果：(1,[2,3],(4,5),{})
7 a,b,c,d=foo()
8 print(d)
3.3 return 值1,值2，值3,... 返回结果:(值1,值2，值3,...)
1 t=(1,2,3) 2 a,_,_=t 3 print(a) 4 5 t=(1,2,3,4,5,6,7,8,9) 6 a,*_,c=t 7 print(a) 8 print(c)
四 自定义函数详解
4.1 为什么要定义函数？:先定义后使用，如果没有定义而直接使用，就相当于引用了一个不存在的变量名
1 foo() 2 def foo(): 3 print(‘from foo‘) 4 print(foo) 5 6 #错误的方式
4.2 函数的使用包含两个阶段：定义阶段和使用阶段
1 # 语法 2 # def 函数名(参数1，参数2，...): 3 # """文档注释""" 4 # 函数体 5 # return 值 6 7 # x=len(‘hello‘) 8 # print(x)
4.3 定义函数的三种形式
1、无参数函数：如果函数的功能仅仅只是执行一些操作而已，就定义成无参函数，无参函数通常都有返回值 1 def print_star(): 2 print(‘#‘*6) 2、定义有参函数:函数的功能的执行依赖于外部传入的参数，有参函数通常都有返回值 1 def my_max(x,y): 2 res=x if x >y else y 3 return res
1 # 三元表达式 2 x=10 3 y=2 4 # if x > y: 5 # print(x) 6 # else: 7 # print(y) 8 # 9 # res=x if x > y else y 10 # print(res)
3、空函数
1 # def auth(): 2 # """认证功能""" 3 # pass 4 # auth() 5 def insert(): 6 """插入功能""" 7 pass 8 def select(): 9 """查询功能""" 10 pass 11 def delete(): 12 """删除功能""" 13 pass 14 def update(): 15 """更新功能""" 16 pass
五 调用函数
1 def foo(): 2 print(‘from foo‘) 3 4 def bar(name): 5 print(‘bar===>‘,name) 6 7 #按照有参和无参可以将函数调用分两种 8 foo() #定义时无参，调用时也无需传入参数 9 bar(‘egon‘) #定义时有参，调用时也必须有参数 10 11 12 #按照函数的调用形式和出现的位置，分三种 13 14 foo() #调用函数的语句形式 15 16 def my_max(x,y): 17 res=x if x >y else y 18 return res 19 20 # res=my_max(1,2)*10000000 #调用函数的表达式形式 21 # print(res) 22 23 24 res=my_max(my_max(10,20),30) #把函数调用当中另外一个函数的参数 25 print(res)
六 函数参数
6.1 从大的角度去看，函数的参数分两种：形参(变量名)，实参（值）
1 #定义阶段 2 # def foo(x,y): #x=1,y=2 3 # print(x) 4 # print(y) 5 6 #调用阶段 7 # foo(1,2)
6.2 详细的区分函数的参数分为五种：
# 位置参数，关键字参数，默认参数，可变长参数（*args，**kwargs）,命名关键字参数1）位置参数
1 # def foo(x,y,z):#位置形参:必须被传值的参数 2 # print(x,y,z) 3 # 4 # # foo(1,2,3) 5 # foo(1,2,3) #位置实参数：与形参一一对应
2）关键字参数：key=value
1 def foo(x,y,z): 2 print(x,y,z) 3 4 # foo(z=3,x=1,y=2) 5 6 #关键字参数需要注意的问题： 7 # 1：关键字实参必须在位置实参后面 8 # 2: 不能重复对一个形参数传值 9 # foo(1,z=3,y=2) #正确 10 # foo(x=1,2,z=3) #错误 11 12 # foo(1,x=1,y=2,z=3)
3）默认参数
1 # def register(name,age,sex=‘male‘): #形参：默认参数 2 # print(name,age,sex) 3 # 4 # register(‘asb‘,age=40) 5 # register(‘a1sb‘,39) 6 # register(‘a2sb‘,30) 7 # register(‘a3sb‘,29) 8 # 9 # register(‘钢蛋‘,20,‘female‘) 10 # register(‘钢蛋‘,sex=‘female‘,age=19) 11 12 #默认参数需要注意的问题： 13 #一：默认参数必须跟在非默认参数后 14 # def register(sex=‘male‘,name,age): #在定义阶段就会报错 15 # print(name,age,sex) 16 17 #（了解）二：默认参数在定义阶段就已经赋值了，而且只在定义阶段赋值一次 18 # a=100000000 19 # def foo(x,y=a): 20 # print(x,y) 21 # a=0 22 # foo(1) 23 24 #三：默认参数的值通常定义成不可变类型
4）可变长参数
1 def foo(x,y,*args): #*会把溢出的按位置定义的实参都接收，以元组的形式赋值给args 2 print(x,y) 3 print(args) 4 # 5 # foo(1,2,3,4,5) 6 7 8 # def add(*args): 9 # res=0 10 # for i in args: 11 # res+=i 12 # return res 13 # print(add(1,2,3,4)) 14 # print(add(1,2)) 15 16 17 18 # def foo(x, y, **kwargs): # **会把溢出的按关键字定义的实参都接收，以字典的形式赋值给kwargs 19 # print(x, y) 20 # print(kwargs) 21 # foo(1,2,a=1,name=‘egon‘,age=18)
示例：
1 def foo(name,age,**kwargs):
2 print(name,age)
3 if ‘sex‘ in kwargs:
4 print(kwargs[‘sex‘])
5 if ‘height‘ in kwargs:
6 print(kwargs[‘height‘])
7
8 foo(‘egon‘,18,sex=‘male‘,height=‘185‘)
9 foo(‘egon‘,18,sex=‘male‘)
10
11
12 命名关键字参数(了解)
13
14 def foo(name,age,*,sex=‘male‘,height):
15 print(name,age)
16 print(sex)
17 print(height)
18 #*后定义的参数为命名关键字参数，这类参数，必须被传值，而且必须以关键字实参的形式去传值
19 foo(‘egon‘,17,height=‘185‘)
20
21
22
23 def foo(name,age=10,*args,sex=‘male‘,height,**kwargs):
24 def foo(name,age=10,*args,sex=‘male‘,height,**kwargs):
25 print(name)
26 print(age)
27 print(args)
28 print(sex)
29 print(height)
30 print(kwargs)
31
32 foo(‘alex‘,1,2,3,4,5,sex=‘female‘,height=‘150‘,a=1,b=2,c=3)
33
34
35 def foo(*args):
36 print(args)
37
38 foo(1,2,3,4) # 1,2,3,4 <=====>*(1,2,3,4)
39
40 *[‘A‘,‘B‘,‘C‘,‘D‘],=====>‘A‘,‘B‘,‘C‘,‘D‘
41 foo(*[‘A‘,‘B‘,‘C‘,‘D‘]) #foo(‘A‘,‘B‘,‘C‘,‘D‘)
42 foo([‘A‘,‘B‘,‘C‘,‘D‘]) #
43
44 def foo(x,y,z):
45 print(x,y,z)
46
47 # foo(*[1,2,3]) #foo(1,2,3)
48 foo(*[1,2]) #foo(1,2)
49
50
51 def foo(**kwargs):
52 print(kwargs)
53
54 #x=1,y=2 <====>**{‘y‘: 2, ‘x‘: 1}
55 # foo(x=1,y=2)
56
57 foo(**{‘y‘: 2, ‘x‘: 1,‘a‘:1}) #foo(a=1,y=2,x=1)
58
59 def foo(x,y,z):
60 print(x,y,z)
61
62 # foo(**{‘z‘:3,‘x‘:1,‘y‘:2}) #foo(x=1,z=3,y=2)
63 foo(**{‘z‘:3,‘x‘:1}) #foo(x=1,z=3)
64
65
66 def foo(x,y,z):
67 print(‘from foo‘,x,y,z)
68
69 def wrapper(*args,**kwargs):
70 print(args)
71 print(kwargs)
72
73
74 wrapper(1,2,3,a=1,b=2)
75
76
77
78 def foo(x,y,z):
79 print(‘from foo‘,x,y,z)
80 def wrapper(*args,**kwargs):
81 print(args) #args=(1,2,3)
82 print(kwargs) #kwargs={‘a‘:1,‘b‘:2}
83 foo(*args,**kwargs) #foo(*(1,2,3),**{‘a‘:1,‘b‘:2}) #foo(1,2,3,b=2,a=1)
84 # wrapper(1,2,3,a=1,b=2)
85 wrapper(1,z=2,y=3)
86
87
88
89 def foo(x,y,z):
90 print(‘from foo‘,x,y,z)
91 def wrapper(*args,**kwargs):
92 # print(args) #args=(1,)
93 # print(kwargs) #kwargs={‘y‘:3,‘z‘:2}
94 foo(*args,**kwargs) #foo(*(1,),**{‘y‘:3,‘z‘:2}) #foo(1,z=2,y=3)
95 # wrapper(1,2,3,a=1,b=2)
96 wrapper(1,z=2,y=3)
PS:注意
1 #补充：函数定义阶段到底干了什么事情：只检测函数体的语法，并不会执行 2 # def bar(): 3 # x 4 # if 1 >2: 5 # print(‘====>‘) 6 # 7 # bar()
时间： 2024-12-12 22:57:45