Python初识 - day5

一、装饰器（decorator）

　　1.定义：本质是函数（装饰其它函数），就是为了其它函数添加附加功能。

　　2.原则：一是不能修改被装饰函数的源代码；二是不能修改被装饰函数的调用方式。

　　3.装饰器包含的知识点：

　　　　　　<1>函数（可作为变量）

　　　　　　<2>高阶函数

　　　　　　　　a.把一个函数名当作实参传给另一个函数（在不修改被装饰函数的情况下，为其添加新功能）

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

　　　　　　 <3>嵌套函数

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

　　4.下面举例分析：

　　　　<1>把一个函数名当作实参传给另一个函数 

　　　　　　　　

 import time
 #把一个函数名当作实参传给另一个函数
 def hyt():
     time.sleep(3)  #延迟三秒
     print('This is hyt')

 def congcong(func):   #函数作为变量
     str_time = time.time() #记录开始时间
     func()    #运行hyt函数
     stop_time = time.time() #记录结束时间
     print('The func runs time is %s '%(stop_time-str_time)) #输出：The func runs time is 3.000171661376953

 congcong(hyt)

　　　　　　

　　　　　<2>返回值中包含函数名

　　　　　　　　

import time
#返回值中包含函数名(不修改函数的调用方式)
def hyt():
    time.sleep(3)  #延迟三秒
    print('This is hyt')

def cc(func):
    print(func)#打印hyt函数的内存地址，结果：<function hyt at 0x00206780>
    return func #返回hyt函数的内存地址
hyt=cc(hyt)   #cc(hyt)表示传递hyt函数的内存地址，而cc(hyt())表示传递hyt函数的返回值，不符合高阶函数的定义
hyt()   #运行hyt函数

　　　　　<3>嵌套函数
　　　　

　　　　　　　　

 def foo():
    # '嵌套函数：在一个函数的函数体内部用def声明并调用另一个函数。'
     print('This is foo')
     def func():     #局部起作用，故只能在函数体内部调用
         print('This is func')

     func()
 foo()

　　　　　　

　　　　　<4>#局部作用域与全局作用域的访问顺序

 

　　 5.装饰器实际运用

　　　　<1>简单点的：　　　　

　　　　

　　　　　　

 def timer(func):    #timer(cc1) func = cc1
     'decorator(装饰器高潮版)'
     def hyt(*args,**kwargs):  #非固定传参，前者接受位置参数，后者接受关键字参数
         star_time = time.time() #time.time()调用时间的计时功能
         func(*args,**kwargs)  #run cc1()
         stop_time = time.time()
         print('The func running time is %s'%(stop_time-star_time))
     return hyt
 @timer      #等同于cc1 = timer(cc1)
 def cc1():
     time.sleep(1)
     print('This is cc1..')
 cc1()

 @timer      #等同于cc2 = timer(cc2) = hyt  cc2()=>hyt() ==> cc2(name,age)==>hyt(name.age)
 def cc2(name,age):
     time.sleep(3)
     print('Name is \033[32;1m{s1}\033[0m,Age is \033[31;1m{s2}\033[0m'.format(s1=name,s2=age))
 cc2('SC',20)

　　　　　<2>复杂点的：

　　　　

　　　　　　

 #装饰器经典款
 import time
 user = 'cc'
 passwd = ''
 def auth(func):
     def wrapper(*args,**kwargs):
         usename = input('Usename:').strip()
         password = input('Password:').strip()
         if user == usename and passwd == password:
             print('Welcome \033[32;1m%s hased passed authentication\033[0m'%(usename))
             func(*args,**kwargs)
         else:
             exit('\033[31;1m Your usename or password is invalid\033[0m')
     return wrapper

 def index():
     print('Welcome index page')
 @auth
 def home():
     print('Welcome home page')
 @auth
 def bbs():
     print('Welcome bbs page')
 index()
 home()
 bbs()
 '''

 #装饰器限量版
 import time
 user,passwd = 'cc','123456'
 def auth(auth_type):
     print('Auth type:',auth_type)
     #按照登录方式的不同而选择不同的认证方式
     def out_wrapper(func):
         def wrapper(*args,**kwargs):
             usename = input('Usename:').strip()
             password = input('Password:').strip()
             if auth_type == 'local':
                 if user == usename and passwd == password:
                     print('\033[32;1mWelcome %s hased passed authentication\033[0m'%(usename))
                     res_home = func(*args,**kwargs)# from home
                     print('---after authentication---')
                 else:
                     exit('\033[31;1m Your usename or password is invalid\033[0m')
             else:
                 print('There is no ladp.....')
         return wrapper
     return out_wrapper

 def index():
     print('Welcome index page')

 @auth(auth_type='local') #home = home(out_wrapper) => wrapper => home()=>wrapper()
 def home():
     print('Welcome home page')
     return 'from home'

 @auth(auth_type='ldap')
 def bbs():
     print('Welcome bbs page')
 index()
 home()
 bbs()

二、生成器（generator）

　　1.定义：　　　　　
　　　　　　通过列表生成式。可以直接创建一个列表。但是受到内存限制，列表容量有限。而且，创建一个包含上百万　　　　个元素的列表，那后面绝大多数元素占用的空间都白白浪费了。所以，如果列表可以按照某种算法推算出来，那　　　　我们可以在循环的过程中不断推算后续的元素，这样就不必创建完整的list，从而节省大量的空间。在python中，　　　这种一边循环一边计算的机制，称为生成器：generator。

　　2.生成器创建方法及实例
　　 　<1>最简单的生成方法：把列表生成式的[]改成（），就创建了一个生成器（generator）。

　　　 <2>列表生成式和生成器实例：
　　　　

　　　　　　　　

 #列表生成式（简洁）

 a = [i*2 for i in range(8)]
 print(a)    #输出结果：[0, 2, 4, 6, 8, 10, 12, 14]

 #传统的列表生成方式

 a = []
 for i in range(8):
     a.append(i*2)
 print(a) #输出结果：[0, 2, 4, 6, 8, 10, 12, 14]

（列表生成式）

　　　　　　　　

 L = [x * x for x in range(8)]  #列表（list）
 print(L) #输出：[0, 1, 4, 9, 16, 25, 36, 49]
 M = (x * x for x in range(8))  #生成器(generator)
 print(M) #输出：<generator object <genexpr> at 0x00537F00>
 print(M.__next__()) #输出：0  生成器的_next_()方法
 print(M.__next__()) #输出：1
 print(M.__next__()) #输出：4

（生成器）

　　　　<3>生成器的调用和迭代
　　　　　　注意：生成器（generator）保存的是算法，每次调用_next_(),就计算出M的下一个元素的值，直到计算到最　　　　　　后一个元素，没有更多元素时，抛出StopIteration(异常)的错误。但这种方法太过繁琐，创建generator后，　　　　　基本不会使用_next_(),正确方法是使用for循环来迭代它，并且不需要关心StopIteration的错误　　
　　　   

　　　　　　　　

 N = (y*2 for y in range(6))
 for i in N:
     print(i) #输出：0 2 4 6 8 10

　　　　　　　　

　　　　<4>斐波拉契数列和异常处理
　　　　　　generator很强大，但如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以使用　　　　函数来实现。比如著名的斐波拉契数列（Fibonacci）,除第一个和第二个数外，任意一个数可有前两个数相加得　　　　到：1,1,2,3,5,8,13，...斐波拉契数列用列表生成式写不出来，但可用函数轻松表示出来　
　　　

　　　　　　　　

 def fib(max):  #max = 10
     n ,a,b = 0,0,1
     while n < max:
         #print(b)
         yield  b #yield 表示出产，产生，保存了函数的中断状态
         a,b = b,a+b # t = (b,a+b) 是一个元组，a=t[0],b=t[1]
         n = n + 1
     return 'worked down' #异常的时候打印return的内容
 #fib(10) #输出：1,1,2,3,5,8,13,21,34,55
 print(fib(max)) #输出：<generator object fib at 0x00507E70>

 '''
 f = fib(10)
 print(f.__next__())#输出：1
 print(f.__next__())#输出：1
 print(f.__next__())#输出：2
 print('Hello everyone，now looping') #可以插在生成器其中不影响其连续过程
 for i in f:
     print(i)#输出：3,5,8,13,21,34,55
 '''
 #异常处理
 g = fib(6)
 while True:
     try: #未出错的时候执行
         x = next(g)  #next为内置方法，等同于_next_()方法
         print('g:',x)   #输出：g: 1   1   2   3   5   8
     except StopIteration as e: #出错时捕获错误定义为e
         print('Generator return value:',e.value) #输出Generator return value: worked down
         break

　　3.关于生成器并行运算
　　

　　　　

 import time
 def consumer(name):
     print('\033[32;1m%s\033[0m 准备吃饭了'%name)
     while True:
         shuijiao = yield   #yield 接受来自N的send 方法传来的参数
         print('\033[31;1m[%s]\033[0m 饺子煮好了，被\033[32;1m%s\033[0m吃完了'%(shuijiao,name))

 N = consumer('hyt')
 N.__next__() #此方法只调用，不传值，输出：hyt 准备吃饭了
 N.__next__() #输出：[None] 饺子煮好了，被hyt吃完了
 b1,b2 = '猪肉馅','牛肉馅'
 N.send(b1) #send方法调用并传值，输出：[猪肉馅] 饺子煮好了，被hyt吃完了
 N.send(b2) #输出：[牛肉馅] 饺子煮好了，被hyt吃完了

 def prodouct(name):
     c1 = consumer('sc')
     c2 = consumer('cc')
     c1.__next__()
     c2.__next__()
     print('\033[32;1m%s 开始做饺子了！\033[0m'%name)
     for i in range(3):
         time.sleep(2)
         print('两人平分一碗饺子')
         c1.send('粉丝')
         c2.send('韭菜')
 prodouct('congcong')

三、迭代器

　　1.可迭代对象（Iterable）

　　　　<1>定义：
　　　　　可以直接作用于for循环的数据类型有以下几种：
　　　　一类 是集合数据类型，如list、tuple、dict、set、str等
　　　　二类 是generator，包括生成器和带yield的generator function.
　　　　这些可以直接作用于for循环的对象统称为可迭代对象：Iterable。
　　　　
　　　　<2>判断方法：可以使用isinstance()判断一个对象是否有Iterable对象。
　　　　<3>实例：

　　　　　　　　

 from collections import Iterable
 print(isinstance([],Iterable)) #判断列表是否有可迭代对象 True
 print(isinstance((),Iterable))  #判断字典是否有可迭代对象 True
 print(isinstance({},Iterable))  #判断集合是否有可迭代对象  True
 print(isinstance('huangyuting',Iterable))   #判断字符串是否有可迭代对象  True
 print(isinstance(666,Iterable)) #判断数字是否有可迭代对象  False
 print(isinstance((x for x in range(4)),Iterable)) #判断generator是否有可迭代对象  True

　　　　　　注意：而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，

　　　　　　直到最后抛出StopIteration错误表示无法继续返回下一个值了。

　　2.迭代器（Iterator）

　　　　<1>定义：可以被next函数调用并不断返回下一个值的对象称为迭代器：Iterator。

　　　　<2>判断方法：可以使用isinstance()判断一个对象是否是迭代器（Iterator）对象。

　　　　<3>实例：　　　　

　　　　　　

 from collections import Iterator
 print(isinstance((),Iterator))   #判断字典是否是迭代器  False
 print(isinstance([],Iterator))  #判断列表是否是迭代器  False
 print(isinstance({},Iterator))  #判断集合是否是迭代器  False
 print(isinstance('congcong',Iterator))  #判断字符串是否是迭代器  False
 print(isinstance(888,Iterator))  #判断数字是否是迭代器  False
 print(isinstance((x for x in range(5)),Iterator))  #判断生成器是否是迭代器  True

　　　　　 <4>　可迭代对象转成迭代器的方法：

　　　　　 　　由上可知，生成器都是迭代器，然而list,dict,str虽然都是可迭代对象（Iterable）,但不是

　　　　　　迭代器（Iterator），可以把list,dict,str等Iterable变成Iterator可以使用iter()函数。如下

　　　　　　所示：　　　　　

　　　　　　　　

 from collections import Iterator
 print(isinstance(iter([]),Iterator),type(iter([])))    #True <class 'list_iterator'>
 print(isinstance(iter(()),Iterator),type(iter(())))    #True <class 'tuple_iterator'>
 print(isinstance(iter({}),Iterator),type(iter({})))    #True <class 'dict_keyiterator'>
 print(isinstance(iter('hytsc'),Iterator),type(iter('hytsc')))   #True <class 'str_iterator'>

　　3.一点疑问解答:　为什么list,dict,str等数据类型不是迭代器（Iterator）?

　　　　因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopItration错误。可以将这个数据流看成一个有序序列，但我们却不能提前知道序列的长度，只有不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。

    Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的。

　4. Python的for循环本质上就是通过不断调用next()函数实现的，
　　例如：
　　

　　　　

 for x in range(5):
     print(x)
 #等价于
 t = iter(range(5)) #首先获得Iterator对象
 #print(dir(t)) #打印 t 可调用的所有方法
 while True: #循环
     try:
         x = next(t) #获取下一个值
     except StopIteration: #遇到StopIteration就退出循环
         break

四、python内置函数大揭秘：
　　

 print(all([1,0,4])) #所有数据为真（非零即为真），空表也为假 输出：False
 print(any((0,-1,4))) #任意数据为真 输出：True
 print(bin(10)) #将十进制转为二进制 输出：0b1010
 print(hex(10))#将十进制转为十六进制 输出：0xa
 print(oct(8))#将十进制转为八进制 输出：0o10
 print(bool([])) #判断真假（非零即为真），输出：False

 a = bytes('abcde',encoding='utf-8')
 print(a)    #输出：b'abcde'
 b = bytearray('abcde',encoding='utf-8')
 print(b)    #输出：bytearray(b'abcde')
 b[0] = 65  #此处只能输入ASCII码值，A为97
 print(b)    #输出：bytearray(b'Abcde')

 a = 'hello'
 print(a.capitalize(),a) #字符串不能修改，只能重新生成新的，输出：Hello hello

 def func():
     pass
 print(callable(func)) #判断是否可调用

 print(chr(97)) #打印ASCII码对应的字符，输出;a
 print(ord('a')) #打印字符a对应的ASCII码值，输出;97

 code = '''
 def fib(max):
     n,a,b = 0,0,1
     while n < max:
         #print(b)
         yield  b
         a,b = b,a+b
         n = n + 1
     return 'worked down'
 #fib(10)
 #异常处理
 g = fib(10)
 while True:
     try: #未出错的时候执行
         x = next(g)  #next为内置方法，等同于_next_()方法
         print('g:',x)   #输出：g: 1   1   2   3   5   8
     except StopIteration as e: #出错时捕获错误定义为e
         print('Generator return value:',e.value) #输出Generator return value: worked down
         break
 '''
 exec(code) #将字符串编译成一段可执行文件
 #py_obj = compile(code,"fib.log","exec") #将字符串编译成指定文件名的可执行代码
 #exec(py_obj)

 print(dir(code)) #打印 字符串code的所有方法
 print(divmod(9,2)) #求两个数的商和余数，并打印出来，输出：(4, 1)

 h = "['hello','world']"
 print(eval(h))  #将字符串转成字典或列表

 calc = lambda n:n**2
 print(calc(3))
 calc = lambda n:4 if n<3 else n #lambda为匿名函数
 print(calc(2)) #输出：4

 res = filter(lambda x:(x%2==1),range(10)) #从列表中筛选0到100以内的奇数
 for i in res:
     print(i) #输出：1,3,5,7,9

 res1 = map(lambda y:y*2,range(4))#将列表中元素全部处理
 res2 = [lambda d:d*d for d in range(2)]
 for i in res1:
     print(i)#输出：0,2,4,6
 for i in res2:
     print(i)#输出：<function <listcomp>.<lambda> at 0x006BE4F8>
             #      <function <listcomp>.<lambda> at 0x002EE300>

 import functools  #functools意为函数工具
 res3 = functools.reduce(lambda a,b:a*b ,range(1,6))#求列表1到6的阶乘，a接收a*b的值，b接收列表中的值
 print(res3)

（待续）

　　　　

　　

 a = frozenset([1,2,3,5,6,8]) #frozenset函数修饰后为不可变列表，集合

 print(globals()) #打印所在模块当前最大命名空间内的变量名和值（key-value）
 print(hash('cc'))#哈希函数，建立字符串等于数字的特定位置关系，输出：1362460451

 def test():
     local_test = 666 #局部变量
     print(locals())#返回局部变量，输出：{'local_test': 666} 打印所在模块当前最小命名空间内的变量名和值
     print(globals())#不包含local_test
 test()
 b = 999
 print(globals()) #只打印全局变量，不打印局部变量
 print(globals().get('local_test')) #输出：None

 print(pow(2,4)) #表示求 2 的 4 次方 输出：16

 print(round(3.14159,2)) #表示将3.14159保留两位小数
 '''
 a = {'b':5,'a':1,'d':4,'c':8}
 print(sorted(a.items())) #输出：[('a', 1), ('b', 5), ('c', 8), ('d', 4)],默认以key排序
 print(sorted(a.items(),key=lambda x:x[1] ))#输出：[('a', 1), ('d', 4), ('b', 5), ('c', 8)]，指定以value排序

 d = [1,3,5,7]
 e = ['h','e','l','l','o']
 for i in zip(d,e):  #zip取最短的列表进行一一对应
     print(i)    #输出：(1, 'h') (3, 'e') (5, 'l') (7, 'l')

 __import__('生成器') #导入字符串

（完结）

五、序列化与反序列化
　　<1>序列化（json、pickle）

　　　　

 #序列化:将内存对象转换成字符串保存起来
 '''import json
 info = {
     'name':'cc',
     'age':20,
     'job':'student'
 }
 f = open('test.txt','w',encoding='utf-8')
 #f.write(str(info))#很low的方法
 print(json.dumps(info),type(json.dumps(info)))#输出:{"age": 20, "job": "student", "name": "cc"} <class 'str'>
 f.write(json.dumps(info)) #专业方法
 f.close()
 '''
 #json 与 pickle 的区别在于：pickle只能在python中使用，而json却可以在各个语言间转换

 #pickle
 import pickle
 def hey(name):
     print('hello',name)

 info2 = {
     'name':'hyt',
     'age':18,
     'func':hey
 }
 f = open('test2.txt','wb')
 print(pickle.dump(info2,f))#输出：None
 pickle.dump(info2,f) #与 f.write(pickle.dumps(info)) 作用相同
 f.close()

　　　

　　　<2>反序列化（json、pickle）　　　　

　　　　

 import json
 f = open('test.txt','r')
 #很low的方法
 data = f.read()
 f.close()
 print(data,type(data)) #输出：{'age': 20, 'job': 'student', 'name': 'cc'} <class 'str'>
 print(eval(data),type(eval(data))) #eval()是内置函数，可将字符串转为字典或列表,
                                 #输出：{'name': 'cc', 'age': 20, 'job': 'student'} <class 'dict'
 #专业的方法
 data = json.loads(f.read())
 print(data,type(data))#输出：{'job': 'student', 'age': 20, 'name': 'cc'} <class 'dict'>
 print(data['name'])#输出：cc
 '''

 #pickle
 import pickle
 def hey(name):
     print('hello',name)
 info2 = {
     'name':'hyt',
     'age':18,
     'func':hey
 }
 f = open('test2.txt','rb')
 data = pickle.load(f)# data = pickle.loads(f.read())
 print(data,type(data)) #输出：{'age': 18, 'name': 'hyt', 'func': <function hey at 0x0094E468>} <class 'dict'>
 print(data['func']('hyt'))
 f.close()