python函数

python函数

如何定义函数：

#无参函数

def printc():
	print('printc function invoke')
if __name__ == '__main__':
printc()
#输出结果：printc function invoke

#有参无返回值函数

def printc_args(name,age):
	print('name=%s,age=%d'%(name,age))
if __name__ == '__main__':
printc_args('python',20)
#输出结果：name=python,age=20

#有参数有返回值函数

def printc_args_value(name):
	return name
print(printc_args_value('ZangzzzzZ'))
#输出结果：ZangzzzzZ

#不定长参数如何定义

def func(*args):
	print('min=%d'%min(args))
	print('max=%d'%min(args))
if __name__=='__main__'
func(1,2,3)
#输出结果：
#min=1
#max=3

def func(*args,**kwargs)：
	print(type(args))
	print(type(kwargs))#字典类型
	print(kwargs)#输出参数内的字典
if __name__=='__main__':
	func(1,2,3,m=1,n='abc')
#输出结果：
#<class 'tuple'>
#<class 'dict'>
#{'m': 1, 'n': 'abc'}

用函数赋值给变量，此时变量具有函数的功能

def func(*args,**kwargs):
	print(kwargs)#输出参数内的字典
if __name__=='__main__:
	func(1,2,3,4,m=1,n='abc')
x=func
x(m=1,n='bcd')#字典
#输出：
#{'m': 1, 'n': 'abc'}
#{'m': 1, 'n': 'bcd'}

def cleanWork():
	print('already clean')
#函数参数是function类型
def func(name,callback):#参数命名无类型
	print('name=%s'%name)
	callback()#call function
if __name__=='__main__':
	func('connect database',cleanWork)
#输出：
#name=connect databas
#already clean

def releaseDataBaseConnection():
    print('close a database')
#函数参数是function类型
def func(callback=releaseDataBaseConnection):
    print('open a connetion')
if __name__=='__main__':
    func()
    releaseDataBaseConnection()
#输出：
#open a connetion
#close a database

函数体局部变量生命周期仅限于函数体内部，函数体执行完毕随之销毁

x=10#全局变量
#在函数内部定义变量不会影响全局变量
def modify_data(y):
    global x
    x+=10
print(modify_data(x))
print(x)
#输出：
#None
#20

Global关键字的使用（改变全局变量）

x=10#全局变量
def modify_data():
    global x
    x+=10
modify_data()
print(x)
#输出：
#20

函数嵌套

def outer():
    x=1
    def inner():
        y=2*x
        print('y=%d'%y)
    inner()
outer()
print()
#输出：
#y=2

nonlocal

def outer():
    x=1
    def inner():
        nonlocal x#闭包函数引用上层函数中的局部变量
        x+=10
        print('x=%d'%x)
    return inner#返回一个内部函数的应用
x=outer()#outer函数调用
print(type(x))
x()
outer()()
#输出：
#<class'function'>
#x=11
#x=11

*闭包

1、嵌套函数

2、在内部函数引用了外部函数变量

3、函数外层返回内部函数的引用

闭包的应用场景（装饰器）

#定义一个列表
l=[1,2,3,4]
ln=[]
for e in l:
    ln.append(e*e)
print(ln)
def cheng(x):
    return x*x
for item in map(lambda x:x*x,l):
    print(item)
print("*"*50)
for item in map(cheng,l):
    print(item)
#输出：
#[1, 4, 9, 16]
#1
#4
#9
#16
#**************************************************
#1
#4
#9
#16

filter结合lamda表达式

l=['abc','a','bcd','efg']
#匿名函数作用是过滤长度大于等于2的表达式
for i in filter(lambda x:len(x)>=2 , l):
    print(i)
#输出：
#abc
#bcd
#efg

reduce结合lamda表达式

from functools import reduce
l=[1,2,3,4,5]
print(reduce(lambda x,y:x+y ,l,10))
#输出：
#25

递归函数：

#递归函数

def Jiecheng(n):
    '''
    :param n: 整数变量
    :return:
    '''
    #所有的递归函数都要有边界条件
    if n==1:
        return 1
    else:
        return Jiecheng(n-1)*(1/n)

if __name__=='__main__':
    print(Jiecheng(6))
    print(2<<128)
#输出：
#0.0013888888888888887
#680564733841876926926749214863536422912