1.函数对象
def func1():
print('run')
#a=func1()
#a=func1
def func2(func):
func()
func2(func1)
def func3():
return func1
f=func3()
print(f)
print(func1)
a = 10
b = 1
c = 2
li = [a,b,c]
def func5():
print('func5 run')
li2=[func5]
li2[0]()
def login():
print('登录')
def register():
print('注册')
def shopping():
print('购物')
res=input('请选择功能名称：')
#if res == 'login':
# login()
#elif res == 'register':
# register()
#elif res == 'shopping':
# shopping()
#else:
# print('输入有误')
funcdic = {'login':login,'register':register,'shopping':shopping}
if res in funcdic:
funcdic[res]()
else:
print('输入有误！')
2.函数的嵌套
def func1():
print('func1')
func1()
def func2():
print('func2')
func2()
def login():
print('登录')
def show_money():
print('余额充足')
def get_money:
login()
show_money()
嵌套定义
def func1():
print('func1')
def func2():
print('func2')
fun2()
func1()
a=100
print(a)
b=200
def func():
c=1
if a >100:
p=1
while True:
s=10
age = 18
def func():
age=19
print(age)
func()
print(len)
len = 100
def func2():
len =1
func2()
print(len)
4.作用域
a = 'aasasasasaas'
print()
查看全局作用域中的内容
print(dir(globals()['__builtins__']))
查看局部作用域中的内容。注意，你在全局中使用locals看到的就是全局的内容，与globals没有区别
print(locals())
print(globals())
def func():
a = 100
print(locals())
func()
age=18
def func2():
明确声明，要使用全局中的age
global age
age =19
print(age)
func2()
print(age)
a =1
def func3():
a = 10
def inner():
明确声明，要使用上一中的a如果上一层没有，则找上上层，但是注意不能找到全局中的
nonlocal a
a = 100
print(a)
inner()
print('这是func3中a',a)
func3()
print(a)
5.闭包函数
age = 20
如下就是一个闭包函数
def fun1():
age = 18
def inner():
print('hello')
print(age)
在返回这个内部的函数时，不是单纯的返回函数，还把函数中访问到的局部名称一起打包了
相当于将内部函数与访问的数据打包在一起了，闭包这个名字就是这么得来的
return inner
f = fun1() f 就是inner
f()
函数的作用域在定义时就固定了，与调用的位置没有关系
c = 1000
闭包函数的模板
def func2():
a = 1
b = 10
def inner():
print(a)
print(b)
print(c)
return inner
f = func2()
__closure__用于访问闭包时打包的数据
print(f.__closure__[0].cell_contents)
print(f.__closure__[1].cell_contents)
什么时候闭包函数
1.定义在另一个函数内的函数
2.内部的函数访问了外部的名称（数据，注意不包含全局的）
6.装饰器
import time
请你统计下载耗时
start_time = time.time()
download()
end_time = time.time()
print('下载耗时',(end_time-start_time))
def download2():
start_time = time.time()
print('开始下载xxx.mp4')
time.sleep(2)
print('xxx.mp4下载完成!')
end_time = time.time()
print('下载耗时',(end_time-start_time))
download2()
def upload():
print('开始上传xxx.mp4')
time.sleep(2)
print('xxx.mp4 上传完成！')
def func(func):
start_time = time.time()
func()
end_time = time.time()
print(end_time-start_time)
def download():
print('开始下载xxx.mp4')
time.sleep(2)
print('xxx.mp4下载完成!')
def outter(func):
a = 1
print(locals(),'xxxxx')
def inner():
在调用原始函数前 增加新功能
func()
print(inner)
return inner
download = outter(download)
download()
既遵守了开闭原则，又添加了新功能
如此方式，违反了一个设计原则 开闭原则
指的是，对扩展开放，对修改封闭（可以添加新功能，但不能修改原代码和调用方式）
装饰器和闭包函数的关系：装饰器是一种设计代码的套路（在不修改原代码和调用方式的情况下，增加新功能）
要完成装饰器，就需要使用闭包函数
装饰模式
print(time.time()) 返回一个时间戳，它是指从1970年1月1日0点0分（unix元年）到现在一共经历过的秒数
time.sleep(1)
print(time.time())
start_time = time.time()
time.sleep(3)
end_time = time.time()
print(end_time-start_time)
