python学习 day12 (3月18日)----(装饰器内置函数）

读时间函数：

# import time
# def func():
#     start_time = time.time()  # 代码运行之前的时间
#     print('这是一个func函数')
#     time.sleep(3)  # 阻塞,睡一下, 1 是睡一秒
#     print(time.time() - start_time)  # 代码运行后的时间
# func()

嵌套函数 ： （判断每个函数执行空间）

# import time
# def func():
#     print('这是func函数')
#     time.sleep(1)
#
# def func1():
#     print('这是func1函数')
#     time.sleep(2)
#
# def func2():
#     print('这是func2函数')
#     time.sleep(3)
#
# def times():
#     start_time = time.time()  # 代码运行之前的时间
#     func2()
#     print(time.time() - start_time)  # 代码运行后的时间
# times()

改变了原func()函数体， 第一步执行旧函数的同时，赋值给新函数，然后新函数括号执行

# import time
# def func():
#     def inner():
#         time.sleep(2)
#         print('这是inner函数')
#     return inner
# inner = func()
# inner()

把上面的两个函数嵌套和返回混合起来使用就组成了装饰器的雏形

 

# def warpper():
#     print('这是新功能!')
#     func()
#
# def func():
#     print(1)
#
# warpper()

# def func():
#     print('这是主功能')
#
# def warpper(f):
#     print('这是新功能!')
#     return f
# func = warpper(func)
# func()

以上，皆为了满足 以下要求（为了便于维护不破坏原来功能，增加新功能） 

开放封闭原则：

对扩展开放

对修改封闭

不改变调用方式

装饰器

# 装饰器  接受被装饰的函数内存地址
def warpper1(f):  # 这里 有 f=func1 之后执行 func1()主功能
    #  闭包  f = func
    def inner(*args , **kwargs):   #接受被装饰函数的参数
        start_time = time.time()
        ret  =  f(*args,**kwargs)         #调用被装饰函数 可以返回值
        # time.sleep(*args)
        print('这是一个新功能')
        end_time = time.time()
        print('%s函数的运行时间是:%s' % (f.__name__, end_time - start_time))
        return ret           #被装饰的函数返回值
    return inner  # func1 = inner 之后执行 inner()新功能

被装饰函数（内含语法糖）

@warpper1  #语法糖   不改变函数调用方式  原函数是什么只能用什么
# func1 = warpper1(func1)  # 传出函数内存地址  调用给wrapper1
# func1()  # 被装饰
def func1(*args,**kwargs):  # 源代码也没变
    print(args)
    # print(kwargs)
    # time.sleep(args)
    print('这是主功能')
    return '大妈'
r = func1(5)
print(r)

 

一层往一层进 ，一层往一层出   包起来  

（# 执行的时候 从最上层装饰器开始执行  中间执行被装饰的函数  返回的时候是从下往上走）

def login_auot(f): # 接受一个被装饰的函数内存地址  # f == <function func at 0x0000023D5CE31E18>
    def inner(a):  # 接受一个被装饰的函数的参数 a = 1
        start_time = time.time()
        print('这是2')  # func
        f(a)  # 调用被装饰的函数   f(1) == func(1)
        print('这是2')
    return inner
def auto(f): # 接受一个被装饰的函数内存地址  # f == <function func at 0x0000023D5CE31E18>
    def inner(a):  # 接受一个被装饰的函数的参数 a = 1
        start_time = time.time()
        print('这是3')  # func
        f(a)  # 调用被装饰的函数   f(1) == func(1)
        print('这是3')
    return inner
# @warpper      # func = warpper(func)
@login_auot   # func = login_auto(func)
@auto
def func(a):
    print(1)

func(1)

使用规范

# @warpper        # 使用规范,装饰放在被装饰的函数离它最近正上方

显示被装饰的函数

# from functools import wraps
#
# def warpper(f):
#     @wraps(f)   #显示被装饰的函数
#     def inner(*args,**kwargs):
#         # print(f.__name__)
#         print(f)
#     return inner  #
#

# def aa():
#     print(1)
# aa = warpper(aa)
# print(aa.__name__)  # 显示被装饰的函数名

# 有参装饰器   咱们不讲  自己研究

1

# def warpper(f): # 接受一个被装饰的函数内存地址  # f == <function func at 0x0000023D5CE31E18>
#     def inner(a):  # 接受一个被装饰的函数的参数 a = 1
#         start_time = time.time()
#         print('这是warpper')  # func
#         f(a)  # 调用被装饰的函数   f(1) == func(1)
#         print('这是warpper')
#     return inner

# @warpper
# def func():
#     print(1)
# func()


# def func():
#     print(1)
# func = warpper(func)
# func()

第二节

内置函数

# 1.记住怎么用

# print(abs(-98))          # 求绝对值  正的负的 出来后全都是正的  **

# print(all([1,0,3,4]))    # all 判断元素中都为真的才是真  *

# print(any([1,False,0]))  # any 判断元素中只要有一个为真就是真 *

# print(ascii('你'))       #  查看元素对应的内容

# print(bin(10))           # 将10进制转行2进制       **

# print(bool([1]))         # 将内容转换成布尔值

# b = bytearray('meet'.encode('utf-8'))
# # 返回一个新的元组,元组可以切片,切片的内容对应的ascii表
# print(b[3])

# print(bytes('你',encoding='utf-8'))                *
# print('你'.encode('utf-8'))

# def func():
#     pass
#
# print(callable(func))   # 检查这个对象是否可以调用          **

# print(chr(65))  # 输入数字,返回对应的ascii表位上对应的内容   **

# a = compile('input(">>>")','','exec')
# exec(a)

# print(complex(8))  # 复数             *

# print(dict(key=1,name=2))

# print(dir([1,2]))  # 查看对象的所有方法     ***

# print(divmod(5,2))   # 返回一个元组,元组的第一个元素是商,第二个元素是余数  **

# print(enumerate)   # 枚举

# li = [1,2,3,4,5,6,7]
#
# for i,em in enumerate(li,1):  # enumerate不写值默认是0         ****
#     # enumerate  第一个参数是可迭代对象,第二参数是计数
#     print(i,em)


# s = """9+4+3"""    # 将字符串中内容执行
# print(eval(s))     # 上班以后禁止使用

# li = [1,23,4,]
# s = """
# def func():
#     print(1)
# func()
# """
# g = exec(s)
# print(g)
# print(li)         # 公司非常禁止

# print(float(20))

# i = 3.56
# print(int(i))

# python3  6 / 3  2.0
# python2  6 / 3  2

# 's'.format()  # 字符串的方法
# print(format('a','>10'))      # 公用函数  右对齐
# print(format('a','<10'))      # 公用函数  左对齐
# print(format('a','^10'))      # 公用函数  居中

# print(format(3,'b'))

# print(format(3,'08b'))  # 00000011   二进制
# print(format(3,'o'))    # 八进制
# print(format(3,'x'))    # 八进制

# a = 1
# def func():
#     pass

# print(globals())  # 查看全局都哪些内容            **
# print(b)
# print(globals().get('b'))

# dic = {[1,2,3]:1}
# print(hash([1,2,3]))  #求对象的哈希值             *

# print(help(input))      # 不知道怎么用的时候可以使用help查看一下

# print(hex(33))           #  将10进制转换成16进制  *

# print(id('s'))             # 查看数据的内存地址   ***

# print(input(">>>"))         # 获取用户输入的内容  *****

# print(int())                  # 将数据转换成整型    *****

# print(isinstance([1,2,3],str))   #判断这个数据时什么类型  ***

# iter                             # 判断是不是可迭代对象   ***

# len()                              # 获取数据的长度     *****

# list()                              # 转换成一个列表  ***

# def func():
#     a = 1
#     print(locals())  # 查看局部空间的内容       ***
#
# func()

# print(max(1,2,3,4,5))   # 求最大值              ***

# print(min(1,2,3,4))       # 求最小值            ***

# print(memoryview(b'a'))        # 查看字节的内存地址

# print(next())               # 迭代器中的取下一个值  ***

# print(oct(9))                 # 将10进制转换成8进制  **

# open(文件名,对这个文件要操作的模式,编码)

# '你好'.encode('utf-8')
# coding:utf-8

# print(ord('中'))     # 输入的是unicode编码的内容    **
# print(chr(20013))    # 输入的是unicode的内容        **

# print(pow(2,3))  #两个参数的时候求幂运算
# print(pow(2,3))    #三个参数的时候先求幂运算在取余

# print('你好','我好',sep=' ',end='')
# print('大家好')

# print('你好',file=open('a','w',encoding='utf-8'))

# print('123')         # 是处理后给你显示的    *****
# print(repr('123'))   # 显示的是原数据        ***

# print(list(reversed()))  # 反转 元组,列表,字符串    ****

# print(round(5.472343212,3))   #四舍五入      ***

# li = [1,2,3,4]
# # s = slice(2)   #切片
# print(li[3])


# print(sum({1:4,2:5}))   #求和     ***

# print(type('aasas'))    # 获取数据类型

# print(vars(str))
# print(locals())

# li = [1,2,3,4]
# ls = [5,6,7,4,5,6]
# lst = ['a','b','c','d','e']
# print(list(zip(li,ls,lst)))  #拉链                  ****

# __import__('time')   # 导入的方式 ---- > 反射

# 重要的:*************************************************

第三节隐匿函数

# 匿名函数:

# lambda 关键字  x参数:x是返回值
# 一行函数 用于简单需求
# print((lambda x:x)(5))
# lambda 的返回值只能是一个

# f = lambda x,y:x*y
# print(f.__name__)     #<lambda>
# print(f(5,6))

# print(sorted([7,2,3,4],reverse=True))

# li = ['你好啊','我好','大家都挺好']

# def func(li):
#     return len(li)
# print(sorted(li,key=func)) # key指定一个排序的规则

# print(sorted(li,key=lambda x:len(x)))


# li = [
#     {'age':19},
#     {'age':52},
#     {'age':48},
#     {'age':30},
# ]

# def func(li):
#     return li['age']
# print(sorted(li,key=func))

# print(sorted(li,key=lambda x:x['age']))

# li = [1,2,3,4]
#
# def func(a):
#     if a > 2:
#         return a
# print(list(filter(func,li)))



# def func(li):
#     for i in li:
#         if i > 2:
#             print(i)
#
# func(li)

# li = [1,2,3,4]
#
# print(list(filter(lambda x:x>2,li)))

# li = [1,2,3,4,5]
#
# def func(i):
#     return i+10
# print(list(map(func,li)))  #映射


# li = [1,2,3,4,5]
# print(list(map(lambda x:x+10,li)))

# from functools import reduce
#
# li = [1,2,3,4,5]
#
# def func(x,y):        # x=12345
#     return x*10+y     # reduce 是做累计算的
# print(reduce(func,li))

 内置函数思维导图

https://www.processon.com/view/5aa09fa4e4b02e58dc3cbc84