10函数

Posted 2020-09-19

一 为何使用函数

没有函数会有什么问题？

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：
没有return
return 什么都不写
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()