# -*- coding:utf-8 -*-
def outter():print("outter()函数里面")def inner1():return "现在在inner1()函数里面"def inner2():return "现在在inner2()里面"print (inner1())print (inner2())print ("outter执行结束")
# outter()
# outter()函数里面
# 现在在inner1()函数里面
# 现在在inner2()里面
# outter执行结束

# -*- coding:utf-8 -*-
def outter(name="inner1"):print("outter()函数里面")def inner1():return "现在在inner1()函数里面"def inner2():return "现在在inner2()里面"if name == "inner1":return inner1else:return inner2inner = outter()print(inner())
# outter()函数里面
# 现在在inner1()函数里面

# -*- coding:utf-8 -*-
def inner():return "现在在inner()函数里面"
def outter(func): print("outter()函数里面")print(func())
outter(inner)
# outter()函数里面
# 现在在inner()函数里面

def outter(num):def inner(a):print(a + num)return innerfun = outter(100)  # fun == inner
fun(1)  # 101
fun2 = outter(200)
fun2(1)  # 201
fun(2)  # 102

def line_slope(a, b):def line(x):return a * x + breturn lineline1 = line_slope(1, 1)
line2 = line_slope(4, 5)
print(line1(2))
print(line1(-1))
print(line2(-3))
print(line2(6))
# 3
# 0
# -7
# 29# 这个例子中，函数line与变量a,b构成闭包。在创建闭包的时候，
# 我们通过line_slope的参数a,b说明了这两个变量的取值，这样，
# 我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。
# 我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，
# 我们可以看到，闭包也具有提高代码可复用性的作用。
# 如果没有闭包，我们需要每次创建直线函数的时候同时说明a,b,x。
# 这样，我们就需要更多的参数传递，也减少了代码的可移植性。
# 1.闭包似优化了变量，原来需要类对象完成的工作，闭包也可以完成
# 2.由于闭包引用了外部函数的局部变量，则外部函数的局部变量没有及时释放，消耗内存

def outter(start=0):def inner():nonlocal startstart += 1return startreturn innero1 = outter(5)
print(o1())
print(o1())o2 = outter(20)
print(o2())
print(o2())print(o1())
print(o1())print(o2())
print(o2())# 6
# 7
# 21
# 22
# 8
# 9
# 23
# 24

def outter(start=0):list1 = [start]def inner():nonlocal startlist1[0] += 1return list1[0]return innero1 = outter(5)
print(o1())
print(o1())o2 = outter(20)
print(o2())
print(o2())print(o1())
print(o1())print(o2())
print(o2())# 6
# 7
# 21
# 22
# 8
# 9
# 23
# 24

# locals -> enclosing function -> globals -> builtins
a = 1  # 全局变量 globalsdef outter():a = 2  # 闭包变量 enclosingdef inner():a = 3  # 局部变量 localsprint("a=%d" % a)return innero = outter()
o()  # a=3# locals，当前所在命名空间（如函数、模块），函数的参数也属于命名空间内的变量
# enclosing，外部嵌套函数的命名空间（闭包中常见）
# globals，全局变量，函数定义所在模块的命名空间
# builtins，内建模块的命名空间。
# 在Python中，有一个内建模块，该模块中有一些常用函数;在Python启动后，
# 且没有执行程序员所写的任何代码前，Python会首先加载该内建模块到内存。
# 另外，该内建模块中的功能可以直接使用，不用在其前添加内建模块前缀，
# 其原因是对函数、变量、类等标识符的查找是按LEGB法则，其中B即代表内建模块

import time# 定义装饰器
def log(fun):def inner():print(time.time())fun()print(time.time())return inner# 使用装饰器  @加函数名   是一种语法糖，即简写
# 真正的执行过程:send_mail = log(send_mail)  =>  send_mail = inner
@log
def send_mail():print("发送邮件")send_mail()# 1503492456.2909923
# 发送邮件
# 1503492456.2909923

def outter(fun):def inner(a, b):fun(a, b)return inner@outter
def add(a, b):print("a+b:%d" % (a + b))add(1, 2)
add(3, 4)
# a+b:3
# a+b:7

def outter(fun):def inner(*args, **kwargs):fun(*args, **kwargs)return inner@outter
def add(a, b, c):print("a+b+c:%d" % (a + b + c))t = (1, 2, 3)
add(*t)  # a+b+c:6
d = {"a": 1, "b": 2, "c": 10}
add(**d)  # a+b+c:13

def outter(fun):def inner(*args, **kwargs):temp = fun(*args, **kwargs)return tempreturn inner@outter
def add(a, b, c):return a + b + ct = (1, 2, 3)
ret = add(*t)
print(ret)  # 6
ret = d = {"a": 1, "b": 2, "c": 10}
print(add(**d))  # 13

def arg_outter(arg):def outter(fun):def inner():print("装饰器的参数是：%s" % arg)if arg:fun()print("我是True,我会唱歌")else:fun()return innerreturn outter@arg_outter(True)
def song():print("song")@arg_outter(False)
def listen():print("listen")song()
listen()

def tag1(fun):def inner():print("<li>", end="")fun()print("</li>", end="")return innerdef tag2(f):def inner():print("<a>", end="")f()print("</a>", end="")return inner# 多层装饰器的使用
@tag1  # link_a = tag1( tag2(link_a) )
@tag2
def link_a():print("我是一个超链接", end="")link_a()  # tag1->inner()# <li><a>我是一个超链接</a></li>

import timeclass log(object):def __init__(self, fun):self.fun = fundef __call__(self):"""当把对象当作函数进行调用时，被调用"""print(time.time())self.fun()print(time.time())@log
def say_hello():print("say_hello")say_hello()
# 1503495467.9418454
# say_hello
# 1503495467.9418454