day18 python学习 内置函数，匿名函数，装饰器的

Posted 2020-10-14 王大拿

format的用法

print(format(‘aa‘,‘>20‘))
print(format(‘aa‘,‘<20‘))
print(format(‘aa‘,‘^20‘))

打印结果如下

                  aa
aa                  
         aa     

sort    用法     li. sort()  得到的是新的列表li   从小到大排列    li.sort(reverse=True)#这个是倒叙排列（从大到小）

sorted   ret=sorted(li)   的到的是一个可迭代对象，需要print（list（ret))  强转列表在打印才能取出他的值

reverse     与sort相同

reversesed  与sorted相同

 

print(globals())#打印全局变量，
print(locals())#打印局部变量


a=‘你好‘

b=a.encode（‘utf-8‘)   编码 ，将文字编码成二进制形式
print(t)

#打印结果是   b‘\xe4\xbd\xa0‘   实质是二进制，内置的ide转成十六进制了

            
c=b.decode(‘utf-8‘)     解码
print(c)                 
#打印结果是  你            将二进制解码成文字

#bytearray
ret = bytearray(‘alex‘,encoding=‘utf-8‘)#对比较长的字符串做修改的时候，
# 指定某一处进行修改，不会改变这个bytearry的内存地址

print(id(ret))
print(ret[1])
ret[1]=11
print(id(ret))
a=ret.decode(‘utf-8‘)
print(a)  #  这是打印结果 aex

print(ord(‘v‘))#  118  打印一个字母的ascll码的十进制值

print(chr(97))#  a  这个可以打印出ascll码值对应的字母

print(repr(‘sada‘))# ‘sada‘ 可以打印出这种带字符串和它带的引号的格式

print(‘name:%r‘%(‘金老板‘)) #这个同上,打印结果  name:‘金老板‘

#enumerate    #枚举
l = [‘笔记本‘, ‘phone‘, ‘apple‘, ‘banana‘]

for i,k in enumerate(l,1):  这里两个参数来接受，i接受后边的数字，
    print(i,k)

#拉链函数 zip  他会将数值按照最终的数量值转换成对应数量的拉链元祖形式的

print(list(zip([0,1,2,3,4],[5,6,7,8],[‘a‘,‘b‘])))
#这是打印结果[(0, 5, ‘a‘), (1, 6, ‘b‘)]

filter   过滤，过滤器

map  

#filter(方法也就是函数，可迭代对像)就是有一个可迭代对象，
# 想要一个新的内容集，是从原可迭代对象中筛选出来的
#新内容少于等于原内容的时候，才能用到filter
def func1(X):
    if X>10:
       return True
ret1=filter(func1,[1,22,3,45,12,6])#有返回值，返回的是一个迭代器
print(list(ret1))
#去掉所用空内容（None)和空字符串(内容为空格）
l=[‘sad‘,‘dsz‘,None,‘   ‘, ‘DSA‘]

def func(x):
    return x and x.strip()#直接return新的值，当里边的值不为空，而且x.strip（）之后不是空的，
    # 意思是不是空格的就可以
ret=filter(func,l)
print(list(ret))
#map（function,itrator)  #返回一个与原来数量相同的迭代器
ret=map(abs,[-1,-5,5,6,-11])
print(list(ret))
#filter和map
#参数很相近：都是一个函数名+可迭代对象
#且返回值页很相近：都是返回可迭代对象
#区别
#filter是做筛选的，结果还是原来就在可迭代对象中的项

#装饰器进阶
#装饰器的进阶有两个
@func1
@func2
def ada()
 #俄罗斯套娃式函数，里边套靠近函数的
#装饰器函数，外边套另一个函数#  要记住是那个套那个的

ef wrapper1(func):
    def inner1(*args,**kwargs):
        print(‘in wrapper 1,before‘)
        ret = func(*args,**kwargs)   #qqxing
        print(‘in wrapper 1,after‘)
        return ret
    return inner1

def wrapper2(func):     #inner1
    def inner2(*args,**kwargs):
        print(‘in wrapper 2,before‘)
        ret = func(*args,**kwargs)   #inner1
        print(‘in wrapper 2,after‘)
        return ret
    return inner2
#当一个函数要引用两个装饰器才能完成功能时
@wrapper2  #先在外层执行这个的第一句
@wrapper1  #在执行这个地方执行的所有内容，然后再返回去执行上边的函数剩下的内容
def qqxing():
    print(‘qqxing‘)
qqxing()

#装饰器进阶2  带有def  outer():的函数

def outer(flag):  #这里写的是要传入的标志位，作用
    # 是给装饰器在通过标志位判断在执行时要不要执行if  flag的内容
    def timer(func):
        def inner(*args,**kwargs):
            if flag:
                print(‘‘‘执行函数之前要做的‘‘‘)
            re = func(*args,**kwargs)
            if flag:
                print(‘‘‘执行函数之后要做的‘‘‘)
            return re
        return inner
    return timer

@outer(False)#在这里传入要不要执行那句的条件
def func():
    print(111)

func()