函数总结

面向对象编程：类class
面向过程编程：过程def
函数式编程：函数def

函数：

1 def func1():
2     'The function definition'
3     print('func1')

面向过程，没有返回值的函数：

 1 def func2():
 2     'The function definition'
 3     print('func2')
 4     return 0
 5 
 6 def func3():
 7     'The function definition'
 8     print('func3')
 9     return 1,['sada'],{'asd':'asda'}
10 
11 x=func1()#执行了函数并把返回值赋给x
12 y=func2()
13 z=func3()
14 
15 
16 print('from func1 return is ',x)#在python中过程被当作返回值为None的函数
17 print('from func1 return is ',y)
18 print('from func1 return is ',z)
19 
20 
21 print(func1())#执行了函数并显示返回值
22 print(func2())
23 print(func3())

结论：

当没有返回值时，返回None
当有一个返回值时，返回object
当有多个返回值时，返回tuple

运行结果：

参数：

 1 def funcp(x,y):#x,y形参
 2     print(x)
 3     print(y)
 4 
 5 x=1
 6 y=2
 7 
 8 funcp(y=y,x=x)#关键字调用
 9 funcp(3,4)#位置调用，一一对应
10 funcp(5,y=6)#关键字参数不能写在位置参数前，而且必须一一对应
11 
12 
13 #默认参数
14 def funcmp(x,y=2):
15     print(x)
16     print(y)
17 
18 funcmp(1,3)
19 #特点：调用参数时默认参数可有可无
20 
21 
22 #参数组*args：接收N个位置参数转换成元组,注意*args只接收位置参数
23 def funcnp(*args):
24     print(args)
25 
26 funcnp(1,2,3,4,5)
27 funcnp(*[1,2,3,4,5])#args=tuple([1,2,3,4,5])
28 
29 def funcmnp(x,*args):
30     print(x)
31     print(args)
32 
33 funcmnp(1,2,3,4,5)
34 
35 #参数组**kwargs：把N个关键字参数转换成字典,注意kwargs只接收关键字参数
36 def funcdict(**kwargs):
37     print(kwargs)
38     print(kwargs['name'])
39     print(kwargs['age'])
40 
41 
42 funcdict(name='Tao',age='23')
43 funcdict(**{'name':'Tao','age':'23'})
44 
45 
46 def funcmndict(name,age=23,*args,**kwargs):#参数组放在最后
47     print(name)
48     print(age)
49     print(args)
50     print(kwargs),
51 
52 funcmndict('Tao',sex='m',hoppy='Basketball',age=24)#默认参数赋值有两种方式，1位置参数2关键字参数
53 
54 def funcmndict(name,age=23,*args,**kwargs):#参数组放在最后
55     print(name)
56     print(age)
57     print(args)
58     print(kwargs)
59 #*args：接收N个位置参数转换成元组,注意*args只接收位置参数
60 #**kwargs：#把N个关键字参数转换成字典,注意**kwargs只接收关键字参数
61 funcmndict('Tao',1,2,3,4,sex='m',hoppy='Basketball')

函数内部调用函数：

 1 ef call(source):
 2     print('from ',source)
 3 
 4 def funccall(name,age=23,*args,**kwargs):#参数组放在最后
 5     print(name)
 6     print(age)
 7     print(args)
 8     print(kwargs)
 9     call('call')
10 funccall('Tao',1,2,3,4,sex='m',hoppy='Basketball')

递归：函数自己调用自己

特性：

必须有一个明确的结束条件
每次进入更深一层的递归时，问题规模相比上一次递归都应有所减少
递归效率不高

1 def calc(n):
2     print(n)
3     if int(n/2):
4         return calc(int(n/2))
5     print('-->',n)
6 calc(10)

高阶函数：函数接收另一个函数作为参数

1 def add(a,b,f): 2 return f(a+b) 3 print(add(3,-6,abs))