day4心得

装饰器：

定义：本质就是函数，（装饰其他函数）就是为其他函数添加附加功能

原则：1、不能修改被装饰的函数的源代码

　　　2、不能修改被装饰的函数的调用方式

实现装饰器知识储备：

1、函数即"变量"

2、高阶函数

　　a：把一个函数名当做实参传给另外一个函数（在不修改被装饰函数源代码的情况下为其添加功能）

　　b：返回值中包含函数名（不修改函数的调用方式）

3、嵌套函数

高阶函数+嵌套函数=》装饰器

高级装饰器

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:kiko0o0

 import time

 user,passwd = 'zk',''
 def auth(auth_type):
     def outer_wrapper(func):
         def wrapper(*args, **kwargs):
             if auth_type == 'local':
                 username = input('username = ').strip()
                 password = input('password = ').strip()
                 if username == user and password == passwd:
                     print('\033[32;1m User has passed authentication \033[0m')
                     res = func(*args, **kwargs)
                     return res
                 else:
                     print('\033[31;1m Invalid username or password\033[0m')
             elif auth_type =='ldap':
                 print('ldap,不过去了')
                 res = func(*args, **kwargs)
                 return res
         return wrapper  #返回地址
     return outer_wrapper    #返回地址

 @auth(auth_type='ldap')
 def index(name):
     print('welcome to index page :',name)

 @auth(auth_type='local')    #home = auth()
 def home(name):
     print('welcome to home page:',name)
     return 'from home'

 def bbs():
     print('welcome to bbs page')

 index('zk')
 print(home('syf'))
 bbs()

高阶参数装饰器

斐波那契，以及异常抓取

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:kiko0o0

 #一种
 # def fib(max):
 #     n,a,b=0,0,1
 #     while n<max:
 #         print(b)
 #         a,b = b,a+b     #相当于  F = (b,a+b)   a = F[0]  b=F[1]
 #         n+=1
 #     return 'done'
 # fib(100)

 #生成器
 def fib(max):
     n,a,b=0,0,1
     while n<max:
         yield b
         a,b = b,a+b     #相当于  F = (b,a+b)   a = F[0]  b=F[1]
         n+=1
     return 'done'
 f = fib(10)
 while True:
     try:
         x = next(f)
         print('f:',x)
     except StopIteration as e:
         print('Generator return value:',e.value)
         break

斐波那契

通过生成器实现协程并行运算

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:kiko0o0
 import time
 def consumer(name):
     print("%s 准备发布系统!" %name)
     while True:
        baozi = yield

        print("上线包[%s]来了,被[%s]发布了!" %(baozi,name))

 def producer(name):
     c = consumer('A')       #函数变成生成器
     c2 = consumer('B')
     c.__next__()        #next只唤醒yield ，调用下生成器 也就是才能开始运行生成器
     c2.__next__()       #等同c2.send(None)
     print("准备传包!")
     for i in range(10):
         time.sleep(1)
         print("传2个上线包!")
         c.send(i)      #send 是唤醒yield并传值给他
         c2.send(i)

 producer("alex")

内置函数

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:kiko0o0

 print(abs(-123))   #abs()取绝对值
 print(all([1,2,3,0]) )      #如果可迭代对象里全为真，返回为真
 print(any([0,1]))           #如果可迭代对象里只要有一个为真，返回就为真，但是空为假
 print(type(ascii([1,1,1]))) #把内存数据对象，表示成一个可打印字符串形式
 repr()                      #用字符串表示这个对象
 print(bin(1))                 #把数字转换2进制
 print(bool(1))              #判断真假  0和空为False
 #字符串和二进制字节默认不可以修改
 a = bytearray('abcd',encoding='utf-8') #变成可修改的二进制字节格式
 print(a)
 a[1] = 100
 print(a)

 def zl(): pass
 print(callable(zl))      #判定一个是不是可以调用的(就是是否可以后面加'()',例如函数就是可以调用)
 print(chr(101))                   #返回ascii的对应表，必须数字
 print(ord('a'))                   #和chr()相反，必须输入ascii的字符
 # classmethod()
 code = '1+3*2+5'
 c = compile(code,' ','eval')                   #把字符串编译成可执行的代码
 print(eval(c))
 code = '''
 def fib(max):
     pass
 print('ok')

 '''
 d = compile(code,' ','exec')
 exec(d)                 #或是直接exec(code)

 complex()       #可以使用参数real + imag*j方式创建一个复数。也可以转换一个字符串的数字为复数；或者转换一个数字为复数
 delattr()       #函数作用用来删除指定对象的指定名称的属性，和setattr函数作用相反。
 dir()           #可以查看对像内所有属于及方法
 print(divmod(5,2))      #把除数和余数运算结果结合起来，返回一个包含商和余数的元组
 print(eval('1+2+3+7*3'))            #将字符串str当成有效的表达式来求值并返回计算结果
 exec()             #用来执行储存在字符串或文件中的Python语句
 cale = lambda n:print(n)    #匿名函数 只能处理简单的运算
 cale(5)
 res = filter(lambda n:n>5,range(10))
 #接收一个函数f和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，
 # filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list
 res1 = map(lambda n:n*n,range(5))
 # 将func作用于seq中的每一个元素，并将所有的调用的结果作为一个list返回
 import functools
 res2 = functools.reduce(lambda x,y:x*y,range(1,10))     #阶乘
 print(res2)
 for i in res1:
     print(i)

 frozenset([1,4,222,3,4,3,444]) #不可变集合
 print(globals())        #整个程序里会以字典类型返回当前位置的全部 全局变量。
 hash()                  #用于获取取一个对象（字符串或者数值等）的哈希值。
 hex()                   #转换16进制
 id()                    #返回内存地址
 locals()                #会以dict类型返回当前位置的全部 局部变量
 max()                   #返回列表里的最大值
 min()                   #返回列表里的最小值
 oct()                   #转换8进制
 pow(2,8)                   #返回多少的幂次方
 reversed()              #反转一个序列对象，将其元素从后向前颠倒构建成一个新的迭代器。
 round(1.332435,3)       #小数保留小数点后3位
 a = {3:2,1:4,-3:4,444:3}
 print(sorted(a.items()))                #字典排序默认按KEY排序
 print(sorted(a.items(),key = lambda x:x[1]))                #字典排序按value排序
 sum()                   #列表求和
 vars()                  #返回一个对象的所有属性
 zip()                   #拉链，数据结合 数据不一样多就按照最少的组合
 map()                   #类似zip 但是可以按照最多的组合，缺少的默认用None或指定一个值
 __import__('decorat')   

json和pickle

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:kiko0o0
 import json     #只能处理简单的 列表 字典 字符串等
 import pickle   #复杂可以
 info = {
     'name':'alex',
     'age':22
 }

 f = open('test.txt','w')
 f.write(json.dumps(info))   #序列化
 f.close()

 #--------------------------------
 f = open('test.txt','wb')       #pickle 需要用b 二进制
 f.write(pickle.dumps(info))   #序列化
 f.close()
 #---------------------------------
 f = open('test.txt','wb')
 pickle.dump(info,f)    #等同f.write(pickle.dumps(info))
 f.close()

序列化

 #!/usr/bin/env python
 # -*- coding:utf-8 -*-
 # Author:kiko0o0
 import json         #只能处理简单的 列表 字典 字符串等
 import pickle
 f = open('test.txt','r',encoding='utf-8')
 data = json.loads(f.read())         #反序列化
 f.close()
 print(data)
 #-----------------------------
 f = open('test.txt','rb')   #需要二进制
 data = pickle.loads(f.read())
 print(data)

 #------------------------
 f = open('test.txt','rb')
 data = pickle.load(f)       #等同data = pickle.loads(f.read())
 print(data)

反序列化