一、函数对象
一、函数对象：把函数的内存地址当作一种变量值去使用
1、引用
def func1():
print('from func')
#func1=函数的内址
func2=func1
func2()
2、可以当作参数传给另外的函数
3、可以当作一个函数的返回值
4、可以当作容器类型的元素
二、名称空间与作用域
1. 什么是名称空间namespaces
存放名字与值内存地址绑定关系的地方
2. 为何要有名称空间
3. 如何用名称空间
内置名称空间
全局名称空间
局部名称空间
4. 总结结论:
1. 查找名字的顺序是从当前位置往外查找
2. 名称空间的嵌套关系是在函数定义阶段就固定死的,与调用位置无关
二、闭包
1. 什么是闭包函数
闭函数: 该函数一定是定义在函数内的函数
包函数: 该内部函数包含对外层函数作用域名字的引用
def outter():
x=111
def inner():
print(x)
return inner
f=outter()
x=22222
f()
2. 为何要用闭包函数
3. 如何用
4、为函数体传值的方案一: 直接以参数的形式传入
为函数体传值的方案二：闭包传值
三、装饰器
1. 什么是装饰器
装饰器指的是为被装饰对象添加新功能的工具
装饰器本身可以是任意可调用对象
被装饰对象本身也可以是任意可调用对象
2. 为何要用装饰器
开放封闭原则:对修改封闭,对扩展开发
装饰器的实现原则:
1. 不能修改被装饰对象的源代码
2. 不能修改被装饰对象的调用方式
装饰器的目的:
就是在遵循原则1和2的前提为被装饰对象添加新功能
3. 如何用
eg:
def outter(func):
# func=index
def wrapper(*args, **kwargs): # 被装饰的函数可带参
start_time = time.time()
func(*args, **kwargs)
stop_time = time.time()
res = stop_time - start_time
return res
return wrapper
@outter # index=outter(index) #outter(index) = wrapper #wrapper = 添加的功能 + index
def index():
time.sleep(1)
print('welcome index page')
@outter
def home(name):
time.sleep(2)
print('welcome home page')
print(name)
res1 = index() # index=outter(index)=wrapper的内存地址 res1=wrapper()
print(res1) # 获取wrapper()函数的返回值是res
res2 = home('egon')
print(res2)
4、叠加多个装饰器
1. 加载顺序(outter函数的调用顺序):自下而上
2. 执行顺序(wrapper函数的执行顺序):自上而下
def outter1(func1): #func1=wrapper2的内存地址
print('加载了outter1')
def wrapper1(*args,**kwargs):
print('执行了wrapper1')
res1=func1(*args,**kwargs)
return res1
return wrapper1
def outter2(func2): #func2=wrapper3的内存地址
print('加载了outter2')
def wrapper2(*args,**kwargs):
print('执行了wrapper2')
res2=func2(*args,**kwargs)
return res2
return wrapper2
def outter3(func3): # func3=最原始的那个index的内存地址
print('加载了outter3')
def wrapper3(*args,**kwargs):
print('执行了wrapper3')
res3=func3(*args,**kwargs)
return res3
return wrapper3
@outter1 # outter1(wrapper2的内存地址)======>index=wrapper1的内存地址
@outter2 # outter2(wrapper3的内存地址)======>wrapper2的内存地址
@outter3 # outter3(最原始的那个index的内存地址)===>wrapper3的内存地址
def index():
print('from index')
print('======================================================')
index()
5、有参装饰器
import time
current_user={'user':None}
def outter(func):
def wrapper(*args,**kwargs):
if current_user['user'] is not None:
res=func(*args,**kwargs)
return res
user=input('username>>>: ').strip()
pwd=input('password>>>: ').strip()
if user == 'egon' and pwd == '123':
print('login successfull')
current_user['user']=user
res=func(*args,**kwargs)
return res
else:
print('user or password error')
return wrapper
@outter
def index():
time.sleep(1)
print('from index')
@outter
def home(name):
print('welcome %s' %name)
index()
home('egon')
6、三元表达式
def max2(x,y):
if x > y:
return x
else:
return y
res=max2(10,20)
x=10
y=20
# res=x if x > y else y
# print(res)
res='OK' if False else 'No'
print(res)
7、生成式
列表生成式
l=[]
for i in range(10):
if i > 4:
l.append(i**2)
l=[i**2 for i in range(10) if i > 4]
print(l)
names=['egon','alex_sb','kevin_sb','hxx_sb','cxx_sb']
sbs=[]
for name in names:
if name.endswith('sb'):
sbs.append(name)
sbs=[name.upper() for name in names if name.endswith('sb')]
print([name.upper() for name in names])
print([name for name in names if name.endswith('sb')])
字典生成式
res={i:i**2 for i in range(10) if i > 3}
print(res)
print({i for i in 'hello'})
8、匿名函数
# def func():
# print('from func')
#
#
# func()
# func()
# func()
# 匿名函数就是只定义了一个函数的内存地址,主要用于临时使用一次的场景
# func=lambda x,y:x+y
# print(func)
# print(func(1,2))
# res=(lambda x,y:x+y)(1,2)
# print(res)
# print(max([10,11,-3,23]))
salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}
# def func(k):
# return salaries[k]
# print(max(salaries,key=lambda k:salaries[k]))
# print(min(salaries,key=func))
# for循环的结果 比较依据
# 'egon' 3000
# 'alex' 100000000
# 'wupeiqi' 10000
# 'yuanhao' 2000
# l=[4,2,3]
# l_new=sorted(l,reverse=True)
# print(l_new)
print(sorted(salaries,key=lambda k:salaries[k],reverse=True))