python 培训第三章 ，函数，装饰器，模块，内置函数之一函数

Posted 2020-11-03

目录：

函数示例
装饰器
模块
内置函数
一、函数示例：

　1、定义函数：
　　　　def fun(args):
　　　　　　‘描述信息‘
　　　　　　函数体
　　　　return 返回值

　　定义函数的三种形式：
　　　　无参函数
def foo():
print(‘in the foo‘)

                        foo()　
                        有参函数：
                        def bar(x,y):
                        print(‘in the bar‘)

                        bar(1,2)
                        空函数：
                        def func():
                        pass
        空函数的应用示例：

def put():
pass

def get():
pass

def cd():
pass

def ls():
pass

def auth():
pass
3、调用函数：
三种形式：
语句形式：

def foo():
print(‘in the foo‘)

foo()
表达式形式：

def my_max(x,y)
if x>y:
return x
else:
return y

res = my_max(1,2)
res = 10 * my_max(1,2)
作为另外一个函数的参数：my_max(1,my_max(2,3)):
#先比较2与3的最大值，再与1作比较；

4、函数的返回值三种形式：
不返回函数：

def foo():
print(‘in the foo‘)

res = foo()
print(res)

返回一个函数：

def foo():
return 1
res = foo()
print(res)

返回多个：

def foo():
return 1,‘s‘,[1,2,3]
res = foo()
print(res)

5、函数的参数：

def func(x,y): #形参在调用时才真正占用内存空间，调用结束则释放内存空间；
print(x)
print(y)

func(1,2) #实参真实占用内存空间；

def func(x,y):
if type(x) is int and type(y) is int:
return x+y

func(1,‘a‘)

def func(x,y): #使用文档注释来提醒用户输入参数类型；
‘‘‘
‘‘‘
return x+y

func(1,‘a‘)

def func(x:int,y:int)->int: #只是一个提示作用；
pass
print(func.annotations)

从实参的角度，
按位置传值：
def foo(x,y):
print(x,y)
foo(1,2)

按关键字传参：key = value
def foo(x,y):
print(x,y)
foo(y=2,x=1) #优点：不用按位置来输入参数；

针对同一个形参，要么按照位置要么按照关键字为形参传值；关键字参数必须写到位置参数的右边；
如：foo(1,x=1,y=2) 此方法会报错；

从形参的角度：位置参数，默认参数，
可变长参数*args；**kwargs;
按位置定义的形参：
def foo(x,y,z): #位置参数；也就是必传值参数；
print(x)
print(y)
print(z)

foo(1,2,3)
foo(y=2,x=1,z=3)

按默认参数的形参：
def foo(x,y=1): #y就是默认参数；但也可以去赋值；默认参数建议不要使用列表或字典等可变类型；必须放在默认参数之后；
print(x)
print(y)
foo(1)

按可变长参数的形参：
def foo(x,y=1,*args): #可变长参数必须放在位置参数与默认参数的后面；此情况一般不使用位置参数；
print(x)
print(y)
print(args)

foo(1,2,3,4,54,6,3,y=2) #错
foo(1,2,3,4,54,y=2,3,5) #错
foo(1,2,3,4,54,6,3) #对

def foo(x,y,args):
print(x)
print(y)
print(args)

l=[‘a‘,‘b‘]
foo(1,2,1) #args的形式就等于1,2,3,4,5 解包；

(‘a‘,‘b‘)

def foo(x,y,z):
print(x)
print(y)
print(z)

foo(1,2,3)

l=[1,2,3]
foo(*l)

def foo(x,**kwargs):
print(x)
print(kwargs)

foo(1,y=3,z=2)
dic = {‘a‘:1,‘b‘:2}
foo(1,**dic) #foo(1,a=1,b=2)

def foo(x,y,z):
print(x,y,z)

foo({‘a‘:1,‘b‘:2,‘c‘:3}) #foo(a=1,b=2,c=3),要把a,b,c改成x,y,z
foo({‘x‘:1,‘y‘:2,‘z‘:3})

注：位置参数 -> 默认参数，*args, *kwargs
1、args 相当于展开按照位置的方式去写；
2、**kwargs 相当于把kwargs按照关键字的方式去写；

函数可以被当做数据来传递

def func()
print(‘in the fun‘)

fl = fun
fl()

函数可作为参数：高阶函数：
def foo(x):
x()
foo(func)

返回值可以是函数：
##########################################

可以作为容器类型的元素：
func_dic={
‘func‘:func
}

func_dic[‘func‘]()

可以作函数的返回值
"""
函数接受一个或多个函数作为输入或者函数输出（返回）的值是函数时，我们称这样的函数为高阶函数
"""
def foo():
print("返回值")

def bar(func):
return func
f = bar(foo)
f()
bar(foo())
函数嵌套
1、嵌套调用
#嵌套函数的意义相当于把一个大需求拆成多个小需求然后组合一起，以如下为例
max2函数式做两个值得大小比如如果要做多个如10 100个就需要在max4中组合
def max2(x,y):
return x if x > y else y

def max4(a,b,c,d):
res1=max2(a,b)
res2=max2(res1,c)
res3=max2(res2,d)
return res3

print(max4(10,99,31,22))

2、函数嵌套定义
#函数的嵌套定义
def f1():#第一步进入f1函数
def f2():#第二部f1函数体中有f2函数声明
print(‘from f2‘)
def f3():#第四部f2函数体中有f3函数声明
print(‘from f3‘)
f3()#第五部f2函数体中运行f3函数
f2()#第三部f1函数体重运行f2内容

f1()