python函数
什么是函数？
函数相当于具备某一功能的工具
函数使用原则：先定义，后调用
为什么要使用函数？
- 组织结构不清晰，可读性差
- 代码冗余
- 可维护性，扩展性差
函数使用
函数定义
# 定义函数发生的事情
# 1、申请内存空间保存函数体代码
# 2、将上述内存地址绑定函数名
# 3、定义函数不会执行函数体代码，但是会检测函数体语法
def 函数名(参数1，参数2，...):
"""文档描述"""
函数体
return 值
- 无参函数
def func():
"""文档描述"""
### 函数体
- 有参函数
def func(x,y):
"""文档描述"""
### 函数体
func(1,2)
- 空函数
def func(x,y):
pass
函数调用
调用函数发生的事情
1、通过函数名找到函数的内存地址
2、然后加口号就是在触发函数体代码的执行
# 1、语句的形式:只加括号调用函数
# interactive()
# add(1,2)
# 2、表达式形式：
# def add(x,y): # 参数-》原材料
# res=x + y
# return res # 返回值-》产品
# 赋值表达式
# res=add(1,2)
# print(res)
# 数学表达式
# res=add(1,2)*10
# print(res)
# 3、函数调用可以当做参数
# res=add(add(1,2),10)
# print(res)
函数返回值
return是函数结束的标志，即函数体代码一旦运行到return会立刻终止函数的运行，并且会将return后的值当做本次运行的结果返回
- 返回
None:return None或 return - 返回单个值：
return 值 - 返回多个值：
return 值1，值2，值3得到一个tulp元组类型（值1，值2，值3）
函数参数
-
形参
- 位置形参
- 默认形参：在定义阶段中被赋值内存地址，规范-赋值类型为不可变类型
混用时，位置形参必须在默认形参左边
- 可变位置参数：
*argsargs是一个元组 - 可变关键字参数：
**kwargskwargs是一个字典
-
实参
- 位置实参
- 关键字实参
混合使用是，位置实参必须在关键字实参前，并且不能为同一个参数重复赋值
- 实参中带
*:func(*[11,2,3])会将参数与形参一一对应func(11,2,3) - 实参中带
**:func(**{"a":1,"b":4})func(a=1,b=4)
混用
*和**，*args必须在**kwargs之前
- 命名关键字参数（了解）：
func(a,b,*,c,d)，*号后定义的参数，c/d称为关键字参数，必须按照key=value为其传参 - 组合使用（了解）：
func(a,y=111,*args,z,**kwargs)
函数对象
函数可以当成一个变量
func=内存地址
# 1、可以赋值
f=func
print(f,func)
f()
# 2、可以当做函数当做参数传给另外一个函数
def foo(x): # x = func的内存地址
# print(x)
x()
foo(func) # foo(func的内存地址)
# 3、可以当做函数当做另外一个函数的返回值
def foo(x): # x=func的内存地址
return x # return func的内存地址
res=foo(func) # foo（func的内存地址）
print(res) # res=func的内存地址
res()
# 4、可以当做容器类型的一个元素
l=[func,]
# print(l)
l[0]()
函数嵌套
# 1、函数的嵌套调用：在调用一个函数的过程中又调用其他函数
def max2(x,y):
if x > y:
return x
else:
return y
def max4(a,b,c,d):
# 第一步：比较a，b得到res1
res1=max2(a,b)
# 第二步：比较res1，c得到res2
res2=max2(res1,c)
# 第三步：比较res2，d得到res3
res3=max2(res2,d)
return res3
res=max4(1,2,3,4)
print(res)
# 2、函数的嵌套定义:在函数内定义其他函数
def f1():
def f2():
pass
函数闭包
"闭"函数指的该函数是内嵌函数,"包"函数指的该函数包含对外层函数作用域名字的引用（不是对全局作用域）
def f1():
x = 111
def f2():
print(x)
f2()
x=11111
def bar():
x=444444
f1()
def foo():
x=2222
bar()
foo()
装饰器
什么是装饰器
器指的是工具，可以定义成成函数
装饰指的是为其他事物添加额外的东西点缀
合到一起的解释：
装饰器指的定义一个函数，该函数是用来为其他函数添加额外的功能
为何要用装饰器
开放封闭原则
开放：指的是对拓展功能是开放的
封闭：指的是对修改源代码是封闭的
装饰器就是在不修改被装饰器对象源代码以及调用方式的前提下为被装饰对象添加新功能
如何用
需求：在不修改index函数的源代码以及调用方式的前提下为其添加统计运行时间的功能
def index(x,y):
time.sleep(3)
print('index %s %s' %(x,y))
index(111,222)
# index(y=111,x=222)
# index(111,y=222)
解决方案一：失败
问题：没有修改被装饰对象的调用方式，但是修改了其源代码
import time
def index(x,y):
start=time.time()
time.sleep(3)
print('index %s %s' %(x,y))
stop = time.time()
print(stop - start)
index(111,222)
解决方案二：失败
问题：没有修改被装饰对象的调用方式，也没有修改了其源代码，并且加上了新功能但是代码冗余
import time
def index(x,y):
time.sleep(3)
print('index %s %s' %(x,y))
start=time.time()
index(111,222)
stop=time.time()
print(stop - start)
start=time.time()
index(111,222)
stop=time.time()
print(stop - start)
start=time.time()
index(111,222)
stop=time.time()
print(stop - start)
解决方案三：失败
问题：解决了方案二代码冗余问题，但带来一个新问题即函数的调用方式改变了
import time
def index(x,y):
time.sleep(3)
print('index %s %s' %(x,y))
def wrapper():
start=time.time()
index(111,222)
stop=time.time()
print(stop - start)
wrapper()
方案三的优化一：将index的参数写活了
import time
def index(x,y,z):
time.sleep(3)
print('index %s %s %s' %(x,y,z))
def wrapper(*args,**kwargs):
start=time.time()
index(*args,**kwargs) # index(3333,z=5555,y=44444)
stop=time.time()
print(stop - start)
# wrapper(3333,4444,5555)
# wrapper(3333,z=5555,y=44444)
方案三的优化二：在优化一的基础上把被装饰对象写活了，原来只能装饰index
import time
def index(x,y,z):
time.sleep(3)
print('index %s %s %s' %(x,y,z))
def home(name):
time.sleep(2)
print('welcome %s to home page' %name)
def outter(func):
# func = index的内存地址
def wrapper(*args,**kwargs):
start=time.time()
func(*args,**kwargs) # index的内存地址()
stop=time.time()
print(stop - start)
return wrapper
index=outter(index) # index=wrapper的内存地址
home=outter(home) # home=wrapper的内存地址
home('egon')
# home(name='egon')
方案三的优化三：将wrapper做的跟被装饰对象一模一样，以假乱真
import time
def index(x,y,z):
time.sleep(3)
print('index %s %s %s' %(x,y,z))
def home(name):
time.sleep(2)
print('welcome %s to home page' %name)
def outter(func):
def wrapper(*args,**kwargs):
start=time.time()
res=func(*args,**kwargs)
stop=time.time()
print(stop - start)
return res
return wrapper
偷梁换柱：home这个名字指向的wrapper函数的内存地址
home=outter(home)
res=home('egon') # res=wrapper('egon')
print('返回值--》',res)
大方向：如何在方案三的基础上不改变函数的调用方式
语法糖：让你开心的语法
import time
# 装饰器
def timmer(func):
def wrapper(*args,**kwargs):
start=time.time()
res=func(*args,**kwargs)
stop=time.time()
print(stop - start)
return res
return wrapper
# 在被装饰对象正上方的单独一行写@装饰器名字
# @timmer # index=timmer(index)
def index(x,y,z):
time.sleep(3)
print('index %s %s %s' %(x,y,z))
# @timmer # home=timmer(ome)
def home(name):
time.sleep(2)
print('welcome %s to home page' %name)
index(x=1,y=2,z=3)
home('egon')
总结无参装饰器模板
def outter(func):
def wrapper(*args,**kwargs):
# 1、调用原函数
# 2、为其增加新功能
res=func(*args,**kwargs)
return res
return wrapper
偷梁换柱，即将原函数名指向的内存地址偷梁换柱成wrapper函数所以应该将wrapper做的跟原函数一样才行
from functools import wraps
def outter(func):
@wraps(func)
def wrapper(*args, **kwargs):
"""这个是主页功能"""
res = func(*args, **kwargs) # res=index(1,2)
return res
# 手动将原函数的属性赋值给wrapper函数
# 1、函数wrapper.__name__ = 原函数.__name__
# 2、函数wrapper.__doc__ = 原函数.__doc__
# wrapper.__name__ = func.__name__
# wrapper.__doc__ = func.__doc__
return wrapper
@outter # index=outter(index)
def index(x,y):
"""这个是主页功能"""
print(x,y)
print(index.__name__)
print(index.__doc__) #help(index)
有参装饰器：三层函数
@语法糖只接收一个参数，要想传参需要在外包裹一层函数，
def auth(db_type):
def deco(func):
def wrapper(*args, **kwargs):
name = input('your name>>>: ').strip()
pwd = input('your password>>>: ').strip()
if db_type == 'file':
print('基于文件的验证')
if name == 'egon' and pwd == '123':
res = func(*args, **kwargs) # index(1,2)
return res
else:
print('user or password error')
elif db_type == 'mysql':
print('基于mysql的验证')
elif db_type == 'ldap':
print('基于ldap的验证')
else:
print('不支持该db_type')
return wrapper
return deco
@auth(db_type='file') # @deco # index=deco(index) # index=wrapper
def index(x, y):
print('index->>%s:%s' % (x, y))
@auth(db_type='mysql') # @deco # home=deco(home) # home=wrapper
def home(name):
print('home->>%s' % name)
@auth(db_type='ldap') # 账号密码的来源是ldap
def transfer():
print('transfer')
# index(1, 2)
# home('egon')
# transfer()
有参装饰器模板
def 有参装饰器(x,y,z):
def outter(func):
def wrapper(*args, **kwargs):
res = func(*args, **kwargs)
return res
return wrapper
return outter
@有参装饰器(1,y=2,z=3)
def 被装饰对象():
pass
多个装饰器
# 一、叠加多个装饰器的加载、运行分析（了解***）
def deco1(func1): # func1 = wrapper2的内存地址
def wrapper1(*args,**kwargs):
print('正在运行===>deco1.wrapper1')
res1=func1(*args,**kwargs)
return res1
return wrapper1
def deco2(func2): # func2 = wrapper3的内存地址
def wrapper2(*args,**kwargs):
print('正在运行===>deco2.wrapper2')
res2=func2(*args,**kwargs)
return res2
return wrapper2
def deco3(x):
def outter3(func3): # func3=被装饰对象index函数的内存地址
def wrapper3(*args,**kwargs):
print('正在运行===>deco3.outter3.wrapper3')
res3=func3(*args,**kwargs)
return res3
return wrapper3
return outter3
# 加载顺序自下而上(了解)
@deco1 # index=deco1(wrapper2的内存地址) ===> index=wrapper1的内存地址
@deco2 # index=deco2(wrapper3的内存地址) ===> index=wrapper2的内存地址
@deco3(111) # ===>@outter3===> index=outter3(index) ===> index=wrapper3的内存地址
def index(x,y):
print('from index %s:%s' %(x,y))
# 执行顺序自上而下的，即wraper1-》wrapper2-》wrapper3
index(1,2) # wrapper1(1,2)
