文成小盆友python-num4 装饰器，内置函数

一 .python 内置函数补充

• chr()  -- 返回所给参数对应的 ASCII 对应的字符，与ord()相反

# -*- coding:utf-8 -*-
# Author:wencheng.zhao

a = chr(65)
print(a)

b = chr(66)
print(b)

##输出如下:
A
B

Process finished with exit code 0

• ord --返回所给的值在ASCII中对应的数字，与chr()作用相反

# -*- coding:utf-8 -*-
# Author:wencheng.zhao

a = ord("A")
b = ord("B")
print(a)
print(b)
##显示如下：
65
66

Process finished with exit code 0

　ascii表对应如下：

　　　　　　ASCII:

　　应用如上两个内置函数编写一个自动生成验证码的小程序：

　　要求： 随机产生8为验证码

　　　　　 验证码包含数字和字母，代码实现如下

# -*- coding:utf-8 -*-
# Author:wencheng.zhao
import random

li = []   ##定义一个空列表用于存放结果

for i in range(8):       #每次生成一个字母or数字,生成8次
    r = random.randrange(0,8)   ##当r为此范围内的数字时就让次位置上的验证码为纯数字
    if r == 2 or r == 4:        ##随便等于 等于的值越多 产生纯数字的可能行就也越大
        num = random.randrange(0,10)   ##num为0-9的任意随机数字
        li.append(str(num))            ##将数字结果存如空列表中
    else:                              ##如果没有为纯数字的情况
        temp = random.randrange(65,91)  ##根据ascii表可得 65 - 90 为应为字母
        c = chr(temp)                   ##将得到的随机数字转换成对应的字母
        li.append(c)                    ##将结果存放到最终列表里

result = " ".join(li)                    #将结果排列

print(result)                           #打印结果

＃＃＃最终现实如下：

D 9 F 3 1 O X 4

Process finished with exit code 0

• compile()    将source编译成代码或者对象，代码或者对象能够通过语句exec（）执行或者通过eval（）来求值
• exec()         执行python的代码 －－ 执行完毕后无返回值。
• eval()          执行python表达式 －－执行完毕后有返回值。对比如下：

code = "print(123)"
aa = compile(code,"<string>","exec")  ##编译

ss = exec(aa)  # 执行
print(ss)      #无返回值

num = "8*8"    
bb = eval(num)
print(bb)      #有返回值,返回值为计算结果

##现实结果如下：
123
None
64

Process finished with exit code 0

• dir()  --用来快速获取＊＊所提供的功能

a = dir(list)
print(a)
##显示结果如下：
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Process finished with exit code 0

• help() --- 查看帮助 ，比较详细

help(list)

＃显示如下：
class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      L.__reversed__() -- return a reverse iterator over the list
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      L.__sizeof__() -- size of L in memory, in bytes
 |  
 |  append(...)
 |      L.append(object) -> None -- append object to end
 |  
 |  clear(...)
 |      L.clear() -> None -- remove all items from L
 |  
 |  copy(...)
 |      L.copy() -> list -- a shallow copy of L
 |  
 |  count(...)
 |      L.count(value) -> integer -- return number of occurrences of value
 |  
 |  extend(...)
 |      L.extend(iterable) -> None -- extend list by appending elements from the iterable
 |  
 |  index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.
 |  
 |  insert(...)
 |      L.insert(index, object) -- insert object before index
 |  
 |  pop(...)
 |      L.pop([index]) -> item -- remove and return item at index (default last).
 |      Raises IndexError if list is empty or index is out of range.
 |  
 |  remove(...)
 |      L.remove(value) -> None -- remove first occurrence of value.
 |      Raises ValueError if the value is not present.
 |  
 |  reverse(...)
 |      L.reverse() -- reverse *IN PLACE*
 |  
 |  sort(...)
 |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None


Process finished with exit code 0

• divmod() －－返回值和余数

res = divmod(100,9)    ## 100 除以 9
print(res)             #值为11 余数为1

print(eval("100/9"))   #直接相除的结果

＃＃显示如下：
(11, 1)
11.11111111111111

Process finished with exit code 0

• enumerate() －－自动遍历对象，返回一个enumetate类型，参数是可以遍历的类型，如字典，列表等，如下：

product_list = [
    ('aaa', 88),
    ('bbb', 800),
    ('ccc', 123),
    ('ddd', 22222),
    ('eee',12),
]



for item,tup in enumerate(product_list):
    print(item,tup)

# 输入如下：
0 ('aaa', 88)        ＃前面的数子 0 ， 1 ，2等为自动添加的
1 ('bbb', 800)
2 ('ccc', 123)
3 ('ddd', 22222)
4 ('eee', 12)

Process finished with exit code 0

•  isinstence() -- 用来判断某个对象是否为某个类的实例－－ 返回true or false

s = "hellp 赵文成"
li = [1,2,3,4,5]

print(isinstance(s, str))   
print(isinstance(li, str))
print(isinstance(li,list))
print(isinstance(s,list))

＃显示结果如下：
True
False
True
False

Process finished with exit code 0

• filter() -- 用法：filter(函数名，可迭代对象)，循环可迭代的对象作为参数传递到函数中，如果函数的返回值true则视为此参数为符合筛选条件。使用场景为筛选如下：

要求为将列表中的数值中大于22的值快速筛选出来：

def fun(a):
    if  a > 22:        ＃定义返回true的条件   
        return True

li = [11,22,33,44,55,66]
rest = filter(fun,li)
print(list(rest))

＃显示如下：
[33, 44, 55, 66]

Process finished with exit code 0    

对于如上比较简单的函数可以用lambda表达式来代替，实现上面的功能可以用如下简单语句：

def fun(a):                             ＃不采用lambda表达式
    if  a > 22:
        return True

li = [11,22,33,44,55,66]
rest = filter(fun,li)
print(list(rest))

rest2 = filter(lambda a:a>22,li)  ＃采用lambda表达式
print(list(rest2))

＃显示结果如下：
[33, 44, 55, 66]
[33, 44, 55, 66]

Process finished with exit code 0

• map() --跟filter相比，map是在执行，而不是在筛选。如下

将上面的列表中的各个元素的值在加1，如下：

def fun(a):
    a += 1
    return a

li = [11,22,33,44,55,66]
rest = map(fun,li)
print(list(rest))

＃显示结果如下：
[12, 23, 34, 45, 56, 67]    ＃每个值在原先的基础上增加了1

Process finished with exit code 0

• locals -- 获取当前的局部变量（只读）
• globals -- 获取全局变量（非只读）

当引用一个变量时按照 局部 －》全局 －》内置的顺序来查找，如果还找不到的话，则会抛出NameError。 如下为获取结果值：

NAME = "zhaowencheng"
def test():
    a = 1
    b = 2
    c = "sss"
    print("ceshi")

    print(globals())
    print(locals())

test()

＃分别显示如下：
ceshi    
{'NAME': 'zhaowencheng', '__package__': None, '__name__': '__main__', '__spec__': None, '__cached__': None, '__doc__': None, 'test': <function test at 0x10137b6a8>, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x1007a5cc0>, '__file__': '/Users/wenchengzhao/PycharmProjects/s13/day4/test.py', '__builtins__': <module 'builtins' (built-in)>}
{'b': 2, 'a': 1, 'c': 'sss'}   ＃局部

Process finished with exit code 0

• hash（） －－ 返回hash后的结果如下：

s = "zhaowencheng"
print(hash(s))

#显示如下：
4279979865803674610

Process finished with exit code 0

• sum()   - 求和
• max()　－取最大值
• min()　－取最小值

li = [1,2,3]
print(max(li))
print(min(li))
print(sum(li))
＃显示如下
3
1
6

Process finished with exit code 0

• len（） －长度

name = "赵文成"
print(len(name))   ＃数值按字符计算

name_b = bytes(name,encoding="utf8")
print(len(name_b))    ＃数值按照字节计算

#显示如下：
3
9

• pow() 

rest1 = pow(2,10)
rest2 = 2 ** 10
print(rest1)
print(rest2)

# 显示如下：
1024
1024

• range（） － 生成一个数值序列

for i in range(5):
    print(i)

 ＃显示结果如下：
0
1
2
3
4

Process finished with exit code 0

当对某个对象进行循环是一半结合了len（）很常用如下：

a = [1,2,3,4,5,6,7,"a","b","c"]
for i in range(len(a)):
    print(a[i])

#显示结果如下：
1
2
3
4
5
6
7
a
b
c

Process finished with exit code 0

• reversed() -  反转

a = [1,2,3,4,5,6,7,"a","b","c"]
b = reversed(a)
print(list(b))

＃显示如下：
['c', 'b', 'a', 7, 6, 5, 4, 3, 2, 1]

Process finished with exit code 0

• round()  － 四舍五入

a = 13.6
b = 13.4
print(round(a))
print(round(b))
＃显示如下：
14
13

Process finished with exit code 0

• zip() - 他接受一系列可迭代的对象作为参数，然后将对象中对应的元素打包成一个个tuple（元组），并统一放倒一个列表中：

q1 = ["李明",11,22,33]
q2 = ["李雷",11,22,33]
q3 = ["王梅梅",11,22,33]

r = zip(q1,q2,q3)
temp = list(r)
print(temp)

＃显示如下
[('李明', '李雷', '王梅梅'), (11, 11, 11), (22, 22, 22), (33, 33, 33)]

Process finished with exit code 0

二.装饰器

装饰器其实就是函数，只不过该函数可以具有特殊的含义，装饰器用来装饰函数或类，使用装饰器可以在函数执行前和执行后添加相应操作（如判断某个条件是否满足）。

简单的来说在不修改原函数的情况下，在对原函数进行包装！

模拟应用场景如下：

初创公司有N个业务部门，1个基础平台部门，基础平台负责提供底层的功能，如：数据库操作、redis调用、监控API等功能。业务部门使用基础功能时，只需调用基础平台提供的功能即可。如下：

###########基础平台提供的功能############
def f1():
    print ("f1")

def f2():
    print ("f2")

def f3():
    print ("f3")

def f4():
    print ("f4")

###业务部门A调用基础平台的功能###
f1()
f2()
f3()
f4()

###业务部门B调用基础平台的功能###
f1()
f2()
f3()
f4()

变动需求来了：由于基础平台的提供的功能可以被任何人使用，现在需要对基础平台的所有功能进行重构，为平台提供的所有功能添加验证机制，即：执行功能前，先进行验证。

解决方法：

• 1.跟所有的业务部门沟通，让它们在调用时先进行验证，这样基础平台这边就不用进行代码的调整，结果可想而之。。。。（逃避问题，并没有解决）
• 2.逐个在基础平台的功能代码里添加验证代码代码如下，费时费力－解决太low

###########基础平台提供的功能############
def f1():
    #验证1
    #验证2
    #验证3
    print ("f1")

def f2():
    #验证1
    #验证2
    #验证3
    print ("f2")

def f3():
    #验证1
    #验证2
    #验证3
    print ("f3")

def f4():
    #验证1
    #验证2
    #验证3
    print ("f4")

##其他业务部门调用不变

• 3.单独写一个用于校验的函数，然后再吧check的功能添加到各个基础功能的函数中   －能够解决但是这样做同样违反了 封闭和开放的原则：

　　　　开放：对扩展开放

　　      封闭：对意境实现的代码功能封闭

　　第三种代码实现如下：

###########基础平台提供的功能############
def check_login ():
    #验证1
    #验证2
    #验证3

def f1():
    check_login()
    print ("f1")

def f2():
    check_login()
    print ("f2")

def f3():
    check_login()
    print ("f3")

def f4():
    check_login()
    print ("f4")

##其他业务部门调用不变

• 4.请－－－ 装饰器登场 ！！！－－ 根据上面的原则 不能再修改基础平台原先的已经实现了的功能了。

###########基础平台提供的功能############
def w1(func):
    def inner():
        print("#验证1")
        print("#验证2")
        print("#验证3")
        return func()
    return inner

@w1
def f1():
    print ("f1")

@w1
def f2():
    print ("f2")

@w1
def f3():
    print ("f3")
    
@w1
def f4():
    print ("f4")

##其他业务部门调用不变
###业务部门A调用基础平台的功能###
f1()
f2()
f3()
f4()

##
print(" "*3)
###业务部门B调用基础平台的功能###
f1()
f2()
f3()
f4()

####################################
##执行结果如：
#验证1
#验证2
#验证3
f1
#验证1
#验证2
#验证3
f2
#验证1
#验证2
#验证3
f3
#验证1
#验证2
#验证3
f4
   
#验证1
#验证2
#验证3
f1
#验证1
#验证2
#验证3
f2
#验证1
#验证2
#验证3
f3
#验证1
#验证2
#验证3
f4

Process finished with exit code 0

完美！！－－ 对于第四总方法，也是仅仅对基础平台的代码进行了修改，就玩去能够实现其他部门在调用这些函数时都先进行验证，并且其他调用部门是完全不用修改任何代码。

对于详细的实现过程，和实现方法如下：

单独以f1为例说明如下：

###########基础平台提供的功能############
def w1(func):
    def inner():
        print("#验证1")
        print("#验证2")
        print("#验证3")
        func()
        print("end")
    return inner

@w1
def f1():
    print ("f1")

@w1
def f2():
    print ("f2")

@w1
def f3():
    print ("f3")

@w1
def f4():
    print ("f4")

##其他业务部门调用不变
###业务部门A调用基础平台的功能###
f1()

从这段代码的执行顺序看：

1.def w1(func):  将w1函数加载到内存中

2.@w1  －－－ python 中语法糖 具体会执行如下操作：

• 执行w1函数，并将@下面的函数的函数名作为w1函数的参数 ，相当于 w1（f1）

　　　　所以，内部就会去执行：
    　　　　def inner:
        　　　　#验证
        　　　　return f1()   # func是参数，此时 func 等于 f1
    　　　　return inner     # 返回的 inner，inner代表的是函数，非执行函数
　　　　其实就是将原来的 f1 函数塞进另外一个函数中

• 将执行完的w1函数返回值赋值给@w1下面的函数的函数名

　　　　w1函数的返回值是：
   　　　　def inner:
        　　　　#验证
        　　　　return 原来f1()  # 此处的 f1 表示原来的f1函数
　　　　然后，将此返回值再重新赋值给 f1，即：
　　　　新f1 = def inner:
            　　　　#验证
            　　　　return 原来f1() 
所以，以后业务部门想要执行 f1 函数时，就会执行 新f1 函数，在 新f1 函数内部先执行验证，再执行原来的f1函数，然后将 原来f1 函数的返回值 返回给了业务调用者。
如此一来， 即执行了验证的功能，又执行了原来f1函数的内容，并将原f1函数返回值 返回给业务调用着

进阶：带参数的装饰器

• 1个参数：

def w1(func):
    def inner(arg1):
        print("#验证1")
        print("#验证2")
        print("#验证3")
        func(arg1)
        print("end")
    return inner

@w1
def f1(arg1):
    print ("f1","-->",arg1)



f1("这是一个参数的")

• 2个参数：

###########基础平台提供的功能############
def w1(func):
    def inner(arg1,arg2):
        print("#验证1")
        print("#验证2")
        print("#验证3")
        func(arg1,arg2)
        print("end")
    return inner

@w1
def f1(arg1,arg2):
    print ("f1","-->",arg1,arg2)



f1("这是一个参数的","增加了第二个参数")

• 3.三个参数的：

###########基础平台提供的功能############
def w1(func):
    def inner(arg1,arg2,arg3):
        print("#验证1")
        print("#验证2")
        print("#验证3")
        func(arg1,arg2,arg3)
        print("end")
    return inner

@w1
def f1(arg1,arg2,arg3):
    print ("f1","-->",arg1,arg2,arg3)



f1("这是一个参数的","增加了第二个参数","增加了第三个参数")

• 4.？？n个参数？？如何处理 －－－ “万能参数”装饰器

###########基础平台提供的功能############
def w1(func):
    def inner(*args,**kwargs):
        print("#验证1")
        print("#验证2")
        print("#验证3")
        func(*args,**kwargs)
        print("end")
    return inner

@w1
def f1(*args,**kwargs):
    print ("f1","-->",args)
    print(kwargs)



f1("一个参数的","二个参数","第三个参数","....","n个参数的",key="value")

####输出如下

#验证1
#验证2
#验证3
f1 --> ('一个参数的', '二个参数', '第三个参数', '....', 'n个参数的')
{'key': 'value'}
end