day4心得

装饰器：

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

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

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

实现装饰器知识储备：

1、函数即"变量"

2、高阶函数

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

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

3、嵌套函数

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

高级装饰器

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

import time

user,passwd = 'zk','123'
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('33[32;1m User has passed authentication 33[0m')
                    res = func(*args, **kwargs)
                    return res
                else:
                    print('33[31;1m Invalid username or password33[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)