13装饰器和内置函数

Posted 2021-02-13 xiaozhu1993

装饰器

# 1.装饰用的工具

# import time         #内置函数计算函数运行时间
# print(time.time())

# 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()

# 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 func(): # 我
#     print(‘这是主功能!‘)
#
# def warpper(f):  # 太白
#     def inner():
#         f()
#         print(‘这是新功能!‘)
#         # 扩展的功能
#     return inner
# func = warpper(func)
# func()
# import time
# def func(*args,**kwargs): # 我
#     print(args)
#     print(‘这是主功能!‘)
#     time.sleep(1)
#
# def warpper(f):  # 太白
#     def inner(*args,**kwargs):  # 带点礼
#         start_time = time.time()
#         f(*args,**kwargs)
#         end_time = time.time()
#         print(‘%s函数的运行时间:%s‘%(f.__name__,end_time - start_time))
#         # 扩展的功能
#     return inner
# func = warpper(func)  # 问太白
# func(5) # 带的礼进去了

import time


# def warpper(f):  # 接受被装饰的函数内存地址
#     def inner(*args,**kwargs):  # 接受被装饰函数的参数
#         start_time = time.time() # 新功能
#         ret = f(*args,**kwargs)  # 调用被装饰的函数,被装饰参数带上
#         end_time = time.time()
#         print(‘%s函数的运行时间:%s‘%(f.__name__,end_time - start_time))
#         return ret               # 被装饰的函数返回值
#     return inner
#
# @warpper   # func = warpper(func)  语法糖
# def func(*args,**kwargs):
#     print(args)   # 打印被装饰的函数参数
#     print(‘这是主功能!‘)
#     time.sleep(1)
#     return ‘大妈‘  # 返回值
# ret = func(5)  #ret = func(5)  == inner(5)  返回值  func(5)
# print(ret)  # 被装饰的函数返回值



# def func(a):
#     """
#     被装饰的函数
#     :return:
#     """
#     print(a)  # 1
#     print(‘我是被装饰的函数‘)
#
#
# def warpper(f): # 接受一个被装饰的函数内存地址  # f == <function func at 0x0000023D5CE31E18>
#     def inner(a):  # 接受一个被装饰的函数的参数 a = 1
#         print(‘这是被装饰的函数调用之前‘)
#         print(f.__name__)  # func
#         f(a)  # 调用被装饰的函数   f(1) == func(1)
#         print(‘这是被装饰的函数调用之后‘)
#     return inner
#
# func = warpper(func)  # 这样要满足人家规定的不改表调用方式
# # func == <function warpper.<locals>.inner at 0x000001BAC19D99D8>
# print(func.__name__)   # func = inner函数
# func(5)  # 调用inner函数  func(1) == inner(1)
# # print(func)


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

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

# @warpper        # 使用规范,装饰放在被装饰的函数离它最近正上方
# def func(a):
#     print(‘这是登录‘)
# func(5)
#
# @warpper
# def reg(a):
#     print(‘这是注册‘)
# # reg(3)
#
# def index():
#     print(‘这是主页‘)

# index()

# 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__)  # 显示被装饰的函数名


# 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()

 

什么是内置函数? 就是python给你提供的. 拿来直接用的函数, 比如print., input等等.

截止 到python版本3.6.2 python一共提供了68个内置函数. 有 一些我们已经用过了. 有一些还没有用过. 还有一些需要学完了面向对象才能继续学习的.

今 天我们就认识一下python的内置函数.

# 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))