七、Python-python基础（一）-- 装饰器

一、普通装饰器

装饰器原理

1： 执行outer函数，将@下面的函数名称，当做参数
2： 将outer函数的返回值重新赋值给f1

def outer(func):
    def inner():
        return 'aa'
    return inner

@outer
def f1():
    return 'f1'

a = f1()
print(a)

C:\Python35\python.exe D:/python/decode.py
aa

二、带参数装饰器

1：带2个参数

def outer(func):
    def inner(a1,a2):
        print('123')
        ret = func(a1,a2)
        print('456')
        return ret
    return inner

@outer
def index(a1,a2):
    print('非常复杂')
    return a1 + a2

index(1,2)

C:\Python35\python.exe D:/python/decode.py
123
非常复杂
456

2：多个变量，使用 *args **kwargs

def outer(func):
    def inner(*args,**kwargs):
        print('123')
        ret = func(*args,**kwargs)
        print('456')
        return ret
    return inner

@outer
def index1(a1,a2):
    print('2个函数')
    return a1 + a2


@outer
def index2(a1,a2,a3):
    print('3个函数')
    return a1 + a2

index1(1,2)
index2(1,2,3)



C:\Python35\python.exe D:/python/decode.py
123
2个函数
456
123
3个函数
456

 

三、多个装饰器

举例：

def outer_0(func):
 2     def inner(*args, **kwargs):
 3         print('最外出层装饰器')
 4         ret = func(*args, **kwargs)
 5         print('执行完外层装饰器')
 6         return ret
 7     return inner
 8 
 9 
10 def outer(func):
11     def inner(*args, **kwargs):
12         print('里层装饰器')
13         ret = func(*args, **kwargs)
14         print('执行完里层装饰器')
15         return ret
16     return inner
17 
18 
19 @outer_0
20 @outer
21 def index(a,b):
22     print('我是原函数')
23     return a + b
24 
25 t = index(1,2)
26 print(t)
27 
28 C:\Python35\python.exe D:/python/decode.py
29 最外出层装饰器
30 里层装饰器
31 我是原函数
32 执行完里层装饰器
33 执行完外层装饰器
34 3

流程：

def outer(func):
    def inner(*args,**kwargs):
        print('123')
        ret = func(*args,**kwargs)
        print('456')
        return ret
    return inner

@outer
def index1(a1,a2):
    print('2个函数')
    return a1 + a2


# @outer
# def index2(a1,a2,a3):
#     print('3个函数')
#     return a1 + a2

index1(1,2)
index2(1,2,3)

"""
1:  解释器从上向下执行。在内存先创建outer函数。 函数内部未执行。
2： 创建index函数。
3： 执行index 和outer的联合。
4： 执行outer函数，将index作为参数传递给outer。
5： 在传递参数给outer的时候，创建func函数。所以outer 也指向index 。
6:  执行outer内的inner。创建inner函数。
7： 在函数inner内部，func 指向原来的index函数。
8： inner函数是新的index函数。

执行步骤：
1：执行index（）
2：执行outer 内部函数的inner。
3：在inner 内部，执行print（123）调。用原来index。
4：执行原来的index。
5：执行完毕原来的index 后，返回inner 内部。
6：执行inner 剩下的步骤。
7：inner 执行完毕，返回相关的返回值。

执行index（）的时候，执行的是新的index，也就是outer 内部的inner
"""

#
def outer_0(func):
    def inner(*args, **kwargs):
        print('最外出层装饰器')
        ret = func(*args, **kwargs)
        print('执行完外层装饰器')
        return ret
    return inner


def outer(func):
    def inner(*args, **kwargs):
        print('里层装饰器')
        ret = func(*args, **kwargs)
        print('执行完里层装饰器')
        return ret
    return inner


@outer_0
@outer
def index(a,b):
    print('我是原函数')
    return a + b

t = index(1,2)
print(t)

"""
内部流程：
1: 解释器从上向下执行，将outer_0，outer 均在内存中创建函数。
2：创建index函数。
3：绑定@outer和index 作为@outer_0的参数。传递给outer_0 。 outer_0 会把inner 重新赋值给绑定的@outer 和index
4: 所以outer_0 内部的inner = @outer的inner的合并
5：@outer和inner的合并，本质上是 ouer内部 inenr函数重新赋值给index。
6：所以相当于给outer内部的inner 添加上了@outer_0的装饰器。或者说 将 outer_0 的inner 重新赋给 outer 的inner
 也就重新赋值给了index


执行步骤：
1：在执行index(),先执行最外层装饰器的inner函数。
2：执行outer_0 的 inner函数内部的func函数。
3：上步骤的func指的是内层装饰器的iner函数。
4：执行outer的inner函数内部的 func函数。
5：步骤4的func 指的是原函数index
6：执行原函数index
7：执行完原源函数index后，回到步骤4，执行outer 的inner 函数 剩下的步骤。print 和return操作。
8：执行完outer 的inner函数后，回到步骤4，执行outer_0 的inner函数，剩下的步骤。print 和return 操作。
9：执行完毕
"""

"""

 

 

练习

# # # f1 = open('a.txt', 'w+')
# # # a = f1.tell()
# # # #f1.write('22')
# # # print(a)
# # # data = f1.read()
# # # #f1.write('北京')
# # #
# # # a = f1.tell()
# # # print(a)
# # # f1.close()
# # # print(data)
# #
# # import copy
# # dict1 = {'k1':123}
# # li = [11,22,33,44,dict1]
# #
# # # print(id(li))
# # cpli1 = li
# # cpli2 = copy.copy(li)
# # cpli3 = copy.deepcopy(li)
# #
# # # print(id(cpli1))
# # # print(id(cpli2))
# # # print(id(cpli3))
# #
# # print(id(li[0]))
# # print(id(li[4]))
# #
# # print(id(cpli2[0]))
# # print(id(cpli2[4]))
# #
# #
# # print(id(cpli3[0]))
# # print(id(cpli3[4]))
#
#
#
# #lambda
#
# # a =  print('2') if 1 < 2 else print('1')
#
# def fun1(a,b): #普通函数
#     return a > b
#
# t = lambda a,b: a > b #lambda表达式
#
# print(t(1,2)) #调用lambda表达式
#
#
# bin



#
# print(int('0b110',base = 2))
# print(int('0o110',base = 8))
# print(int('0x11',base = 16))

# print(chr(80))
#
# li = []
# print(dir(li))


# print(divmod(22,7))
# print(eval('1 + 4'))
# exec('print(2) if 1 >2  else print(1)')
#
# a = 'i am {0}, {1}'
# print(a.format('yan',10))

# a = 'a'
#
# print(help(list))

# a = [11]
# print(isinstance(a,list))




# a = locals()
# print(a)


# a = 'strings'
#
# next(a)
# dict1 = {'asdasfdsfas':1}
# i = hash('asdasfdsfas')
# print(i)


# a = iter([11,22,33,44])
# print(next(a))
# print(next(a))


# a = ['11','22','abc','ABC', 'db','中文']
# li = sorted(a)
#
# for item in li:
#     print(item)

# import random
# temp = ''
#
# for i in range(6):
#      a = random.randrange(0,4)
#      if a==2 or a ==4:
#          rad1 = random.randrange(65,91)
#          c1 = chr(rad1)
#          temp = temp + c1
#      else:
#          rad2 = random.randrange(0,9)
#          c1 = str(rad2)
#          temp = temp + c1
# print(temp)

# #只读
# f = open('a.txt','r')
# data = f.read()
# print(data)
#
# #只写
# f = open('a.txt','w')
# f.write('aaa')
# print(data)



#x模式
# f = open('b.txt','x')
# f.write('aaa')


#a模式

# f = open('a.txt','r')
# data = f.read()
# print(type(data))
#
#
# f = open('a.txt','rb')
# data = f.read()
# print(type(data))


# f = open('b.txt','wb')
# f.write(bytes('aaa',encoding = 'utf-8'))



#r+
#
# f = open('a.txt','r+')
# print(f.tell()) #得到当前指针位置
# data = f.read()
# print(type(data))
# print(data)
# print(f.tell()) # 得到读取后的指针位置
# f.write('中国人')
# print(f.tell()) # 得到write后的指针位置
# f.seek(2)  # 调整指针位置到2个字节。
# data1 = f.read(5) #读取5个字符
# print(data1)


#w+
# f = open('a.txt','a+')
# print(f.tell()) #得到当前指针位置
# data = f.read() #此处读不到任何内容，因为r+ open的时候指针到最后
# f.seek(0)  # #调整指针位置到0
# f.write('add') #但是追加还是在文件末尾
# f.seek(0)
# data1 = f.read()
# print(data1)
# f.close()


# f = open('a.txt','r+')
# data = f.readline()
# print(data)
# data1 = f.readline()
# print(data1)
# data1 = f.readline()
# print(data1)




# f = open('a.txt','r+')
# print(f.tell())
# print(f.seek(2))
# f.truncate()
# data = f.read()
# print(data)

#
#
# f = open('a.txt','r+')
# for line in f:
#     print(line)
#
#
# f = open('a.txt','r+')
# for line in f:
#     print(line)
# f.readline
#
#
# with open('a.txt','r+') as f:
#     f.read()
#
#
# with open('a.txt','r+') as f1, open('b.txt','a+') as f2:
#     for lines in f1:
#         f2.write(lines)


# li = [11,22,9,5,44,39]
# count1 = 0
# count2 = 0
# for i in range(len(li)-1):
#     count2 = count2 +1
#     for j in range(len(li)-1):
#         temp = li[j]
#         count1 = count1 +1
#         if li[j] > li[j+1]:
#             li[j] = li[j+1]
#             li[j+1] = temp
#
# for item in li:
#     print(item)
#
# print('循环 %d 趟，排序 %d 次'%(count2,count1))


#
# def fib(a,b):
#     if a > 100 :
#         return
#     print(a)
#     print(b)
#     c = a + b
#     fib(b,c)
#
# fib(1,2)
#
#
#
# def fe(i):
#     if i == 5:
#         return 10
#
#     r = fe(i+1)
#
#     return r
#
# t = fe(1)
# print(t)



# def outer(func):
#     def inner():
#         return 'aa'
#     return inner
#
# @outer
# def f1():
#     return 'f1'
#
# a = f1()
# print(a)


def outer(func):
    def inner(*args,**kwargs):
        print('123')
        ret = func(*args,**kwargs)
        print('456')
        return ret
    return inner

@outer
def index1(a1,a2):
    print('2个函数')
    return a1 + a2


# @outer
# def index2(a1,a2,a3):
#     print('3个函数')
#     return a1 + a2

index1(1,2)
index2(1,2,3)

"""
1:  解释器从上向下执行。在内存先创建outer函数。 函数内部未执行。
2： 创建index函数。
3： 执行index 和outer的联合。
4： 执行outer函数，将index作为参数传递给outer。
5： 在传递参数给outer的时候，创建func函数。所以outer 也指向index 。
6:  执行outer内的inner。创建inner函数。
7： 在函数inner内部，func 指向原来的index函数。
8： inner函数是新的index函数。

执行步骤：
1：执行index（）
2：执行outer 内部函数的inner。
3：在inner 内部，执行print（123）调。用原来index。
4：执行原来的index。
5：执行完毕原来的index 后，返回inner 内部。
6：执行inner 剩下的步骤。
7：inner 执行完毕，返回相关的返回值。

执行index（）的时候，执行的是新的index，也就是outer 内部的inner
"""

#
def outer_0(func):
    def inner(*args, **kwargs):
        print('最外出层装饰器')
        ret = func(*args, **kwargs)
        print('执行完外层装饰器')
        return ret
    return inner


def outer(func):
    def inner(*args, **kwargs):
        print('里层装饰器')
        ret = func(*args, **kwargs)
        print('执行完里层装饰器')
        return ret
    return inner


@outer_0
@outer
def index(a,b):
    print('我是原函数')
    return a + b

t = index(1,2)
print(t)

"""
内部流程：
1: 解释器从上向下执行，将outer_0，outer 均在内存中创建函数。
2：创建index函数。
3：绑定@outer和index 作为@outer_0的参数。传递给outer_0 。 outer_0 会把inner 重新赋值给绑定的@outer 和index
4: 所以outer_0 内部的inner = @outer的inner的合并
5：@outer和inner的合并，本质上是 ouer内部 inenr函数重新赋值给index。
6：所以相当于给outer内部的inner 添加上了@outer_0的装饰器。或者说 将 outer_0 的inner 重新赋给 outer 的inner
 也就重新赋值给了index


执行步骤：
1：在执行index(),先执行最外层装饰器的inner函数。
2：执行outer_0 的 inner函数内部的func函数。
3：上步骤的func指的是内层装饰器的iner函数。
4：执行outer的inner函数内部的 func函数。
5：步骤4的func 指的是原函数index
6：执行原函数index
7：执行完原源函数index后，回到步骤4，执行outer 的inner 函数 剩下的步骤。print 和return操作。
8：执行完outer 的inner函数后，回到步骤4，执行outer_0 的inner函数，剩下的步骤。print 和return 操作。
9：执行完毕
"""