装饰器 DF

装饰器:

　　从名字上来看,装饰器就是用来装饰内容的一个工具.本质上是一个闭包

　　在开发中,装饰器必须要遵守开放封闭原则:对扩展开放,对修改源代码封闭.

　　在装饰器中,有一个很重要的工具就是@,称之为语法糖,语法糖的本质就是:被装饰的函数名 = 装饰器的名字(被装饰的函数名)

　　在装饰器的应用上,有一个很简单的例子

计算简易的函数运行时间

import time　　　　　　　　　　　　　　　　　 # 导入time模块
print(time.time())　　　　　　　　　　　　　 # 获取时间戳
start_time = time.time()　　　　　　　　　　# 开始时间
def foo():　　　　　　　　　　　　　　　　　　 # 定义函数foo
    time.sleep()　　　　　　　　　　　　　　　# 可以自己定义睡眠时间
    print(100)　　　　　　
foo()　　　　　　　　　　　　　　　　　　　　   # 调用函数foo
end_time = time.time()　　　　　　　　　　　 # 结束时间
在这时,函数的运行时间为end_time-start_time

接一个比较规范的写法:

import time    　　　　　　　　　　　　　　　　 1,导入time模块　
def func(x):　　　　　　　　　　　　　　　　　　 2,定义func函数,此时必须有形参
    def wapper():　　　　　　　　　　　　　　　 5,定义wapper函数
        start_time = time.time()　　　　　　 9,
        x()　　　　　　　　　　　　　　　　　　　10,这儿的x是foo的内存地址,加括号是调用foo函数
        end_time = time.time()　　　　　　　 12,
        print(start_time - end_time) 　　　 13,
    return wapper　　　　　　　　　　　　　　　 6,将wapper函数的内存地址返回给调用者func
def foo():　　　　　　　　　　　　　　　　　　　　3,定义foo函数
    print("今天周二")　　　　　　　　　　　　　　11,执行print
foo = func(foo)　　　　　　　　　　　　　　　　　4,等号右边,将foo的内存地址传给了func函数的x
　　　　　　　　　　　　　　　　　　　　　　　　　　7,等号左边,将wapper的内存地址赋给了foo,
foo()    　　　　　　　　　　　　　　　　　　　　 8,调用wapper函数

 现在用一个装饰器来写:

def func(x):　　　　　　　　　　　　　　　　
    def wapper(*args,**kwargs):
        x(*args,kwargs)
    return wapper
@func　　　　　　　　　　　　　　　　　　　　　　@加装饰器的名字,就相当于:inner = func(inner)
def inner(*args,**kwargs):
    print(*args)
inner()　　　　　　　　　　　　　　　　　　　　ps:这是最简单的一种装饰器

内置函数,

　   python中提供的一些工具,我们可以直接拿过来用,我们知道,在python中有68个内置函数.在之前已经接触过input,print,id,globals,locals等几个函数;

　　今天来继续学习一些内置函数,在目前所学的知识中,比较重要的函数,主要有enumerate,lambda,sorted,filter,map,zip,reduce

enumerate,枚举

for i in enumerate():　　　　括号中第一个参数必须是可迭代对象,第二个参数是起始值,可以自己定义,默认为0
    print(i)
for i in enumerate("166",1)
　　print(i)
　　　　　　　　　　输出结果为(1,'1'),(2,'6'),(3,'6')

lambda,匿名函数

　　匿名函数定义时,没有def,没有函数名,它有形参,可以接收多个形参,查名字可以用:函数.__name__

格式为:　　lambda 参数:返回值

f = lambda x:x+x
print(f(3))
                    输出内容为:6
可以直接写:print((lambda x:x+x)(3)),调用时要传参

sorted,排序

print(sorted(可迭代对象))　　　　　　　　　　默认是升序
print(sorted(可迭代对象),reverse=True)　　降序

例1:

sorted('可迭代对象',key='函数名',reverse=True)　　　　　　函数名里写排序的规则,可以指定升序或者降序

lst = ['光年之外','bgm','这个世界太疯狂','accord']
print(sorted(lst,key=lambda x:len(x),reverse=True))
　　　　输出结果为:['这个世界太疯狂','accord','光年之外','bgm']

filter 筛选过滤

　　filter('写好过滤规则的函数','可迭代对象')

筛选列表:
lst = [1,2,3,4,5,6]
print(list(filter(lambda x:x>3,lst)))　　　　　　结果为:[4,5,6]

筛选字典:
dic = [{'name':'依依','age':18},{'name':'小五子','age':20}]
print(list(filter(lambda x:x['age']>18,dic)))　　　　　　　　结果为:{'name':'小五子',''age':20}

map,映射函数

1,可以快速实现列表内每个元素的基础运算,加,乘...

2,可以快速的将多个可迭代对象,元素位置相同的进行上下累加

lst = [1,2,3,4,5,6]
lst1 = [2,3,4,5,6,7]
print(list(map(lambda x,y:x+y,lst,lst1)))　　　　　　　　结果为[3,5,7,9,11,13]

zip函数

　　它的返回值是多个,如果是多个可迭代对象,按照最短的进行输出,可以将它戏称为拉链函数

lst = [1,2,3]
lst1= [2,3,4,5,6]
lst2 = [5,6,7,8]
for i in zip(lst,lst1,lst2):
    print(i)　　　　　　　　　　　　　　　　结果为:(1,2,5),(2,3,6),(3,4,7)

reduce,实现累计算

python3中,导入reduce函数:from functools import reduce

lst = [1,2,3,4,5,6]
print(reduce(lambda x,y:x**2,lst))　　　结果为:120

其他函数:

检测可迭代对象:

　　all( ),都为真时,输出True,有一个假就为False

　　any( ),有一个真即为True

进制转换:

　　bin( ),把参数转化成二进制

　　otc( ),把参数转化成八进制

　　hex( ),把参数转化成十六进制

和ascii码相关:

　　acsii( ),如果括号中元素在ascii码中,就原生显示;如果不在,就返回\u...

　　chr( ),对应ascii码,输入位置字符找出对应字符

　　ord( ),找带字符位置的编码

和数字运算相关:

　　abs( ),求数字的绝对值

　　round( ),四舍五入;第一个参数为浮点数,第二个参数为保留的位数

　　pow( ),两个参数是求幂运算,三个参数是求幂后再取余

　　max( ),求最大值;如果是字典,比较的是键

　　min( ),求最小值

　　float( ),浮点;

和字节相关:

　　memoryview( ),求字节的内存地址

　　bytes( ),查字节;第一个参数是要查询的内容,第二个参数是编码集

　　bytearray( ),返回一个新字节数组,每个元素的值的范围是0~256对应的是ascii码表;第一个参数放内容,第二个参数是编码集

callable( ),判断是否可调用

repr( ),显示数据的原生形态

以下两个函数禁用:

eval( ),它可以执行字符串中的部分内容,容易出问题

exec( ),不论字符串输入什么,都可以运行,更容易出问题

递归
　　要满足的条件是:自己调用自己,是一个无止境的递归,必须得有明确的终止条件

def func():
    print("你好")
    func()
func()　　　　　　　　会报错,内存溢出

　　官方声明递归的最大深度为1000,修改递归最大深度的方式是:sys.setrecursionlimit('修改的数量')

def func(n):
    print(n)
    n += 1
    func(n) 
func(1)　　　　　　　 实际测试在996-998之间

　　递归主要应用在os模块中,可以递归创建文件夹,也可以删除,也可以查看文件