经验拾忆（纯手工）=> Python三器
可迭代对象、生成器、迭代器三者的关系
1. 迭代器必定是可迭代对象
2. 生成器是迭代器的一种
3. 可迭代对象：必须实现 __iter__方法
4. 迭代器：必须实现 __iter__方法 和 __next__ 方法
5. 生成器：必须实现 __iter__方法 和 __next__ 方法，yield 代替了这两个方法
6. 工具包： from collections import Iterable,Iterator
7. 查看抽象接口：
In [265]: Iterable.__abstractmethods__
Out[265]: frozenset({'__iter__'})
In [266]: Iterator.__abstractmethods__
Out[266]: frozenset({'__next__'})
8. 可迭代对象均可以被 for循环 所遍历， 另外 实现了 __getitem__的类 其对象也可for遍历
关于 __getitem__等魔法方法，之后会单独写一篇文章。
生成器
生成器有两种写法：
形式一：
In [230]: def f():
...: for x in range(10):
...: yield x
In [231]: y = f()
形式二:
In [239]: y = ( x for x in range(10) )
In [240]: y
Out[240]: <generator object <genexpr> at 0x0000024A4D3AFB48>
'推进生成器' 迭代有三种方式：
方式1：
In [232]: next(y)
Out[232]: 0
方式2：
In [233]: y.__next__()
Out[233]: 1
方式3：
In [236]: y.send(None)
Out[236]: 2
前两种方式是等价的，第三种方式有些差异，且听我说：
In [248]: def f():
...: print(1)
...: a = yield 2
...: print(a)
In [249]: y = f()
In [250]: y.send(None)
1 # 这里是 print(1)的结果
Out[250]: 2
In [251]: y.send(100)
100 # 这里是print(a)的结果
不知道阁下可否看出和两种的差异：
1. yield 2 # 这行多了个赋值操做
2. send(100) # send() 函数里面放了个，而后print(a) 打印的就是100
举个例子：
1. a = yield 2 # 至关于一个士兵等待指令，等号左边还未执行，程序就被封锁了
2. send(100) # 长官输入了一个100，士兵收到后就把程序解封，并执行等号左边
3. 因而 就至关于 a 被赋值为 100
迭代器
先看两个简单的函数：
In [294]: iter([1,2,3])
Out[294]: <list_iterator at 0x24a4e7f5780>
In [295]: reversed([1,2,3])
Out[295]: <list_reverseiterator at 0x24a4d38a6a0>
自定义迭代器：
In [283]: class A(Iterator): # 注意这里：继承了Iterator就不用实现 __iter__接口了
...: def __init__(self, value):
...: self.value = value
...: self.index = -1
...: def __next__(self): # 注意这里：__next__是写逻辑的主要接口，每次返回单个值
...: self.index += 1
...: return self.value[self.index]
In [284]: a = A(['Tom', 'Jerry'])
In [285]: next(a)
Out[285]: 'Tom'
In [286]: next(a)
Out[286]: 'Jerry'
串联合并迭代器：
1. 普通序列迭代器串联
In [287]: from itertools import chain
In [289]: chain(range(1),range(2),range(3))
Out[289]: <itertools.chain at 0x24a4d2c77f0>
In [290]: list(chain(range(1),range(2),range(3)))
Out[290]: [0, 0, 1, 0, 1, 2]
2. 字典序列迭代器串联
In [288]: from collections import ChainMap
In [291]: ChainMap({1:1},{2:2,3:3})
Out[291]: ChainMap({1: 1}, {2: 2, 3: 3})
In [292]: dict(ChainMap({1:1},{2:2,3:3}))
Out[292]: {1: 1, 2: 2, 3: 3}
装饰器
装饰器若是按钻牛角尖的方式来理解的确是很头疼的事情。先说个例子吧：
In [296]: def f(func):
...: def f1():
...: print('原函数以前加点功能')
...: func() # 这就是原函数
...: print('原函数以后加点功能')
...: return f1
In [299]: @f #这句等价于=> func = f(func)
...: def func():
...: print('我是原函数哦')
In [300]: func()
>> 原函数以前加点功能
>> 我是原函数哦
>> 原函数以后加点功能
解释
用大白话来说，装饰器就是在原函数的先后加功能。也就是给原函数加个外壳。看上去是调用的原函数，
实则调用的是外壳函数，外壳函数里面包括原函数和 一些其余的自定义功能
例子：
面包很差吃啊，可是你还想吃这个面包，咋整？ 上下抹点奶油，就变成了三明治（我没吃过。。）
吃其余面包的时候继续抹上奶油就好了（封装性）
面包-原函数
三明治-被装饰器装饰后的函数
各类功能（吃法）快速拼接：
@奶油
def 面包1():
pass
@奶油
def 面包2():
pass
@沙拉
def 面包1():
pass
@沙拉
def 面包2():
pass
存在问题：
@f #这句等价于=> func = f(func)
这是我上面说过的一句话，你仔细看看：
func以前指向的是（原函数）面包的空间，恩，func函数名 也就是(__name__) 是func（面包）
如今他指向的是（新函数）三明治的空间，恩，它的函数名是f1(三明治)
函数名变了，有些张冠李戴的感受，若是不想让它变，并保持自己的函数名，看我操做：
In [301]: from functools import wraps
In [316]: def f(func):
...: @wraps(func) ### 没错 这里是最主要的，基本格式固定写法，照着写便可
...: def f1():
...: print(func.__name__)
...: print('原函数以前加点功能')
...: func()
...: print('原函数以后加点功能')
...: return f1
标准装饰器使用（原函数带有返回值 和 参数）：
In [323]: def f(func):
...: @wraps(func)
...: def f1(*args, **kwargs):
...: print('报年龄和性别~~~')
...: return func(*args, **kwargs)
...: return f1
In [324]: @f #每次都要记住 test=f(test) 这个隐含的变形，熟了就行了
...: def test(name,age):
...: print(name, age)
In [325]: test('Tom',18)
-------------------------------下面是打印部分
报年龄和性别~~~
Tom 18
带参数的装饰器：
构造以下：
def foo(arg): # 其实就是在原来的基础上再再再次包装个外壳，仅此而已
# 以前讲的装饰器f实现代码原封不动全放在这里面，看下面帮你写好了。
def f(func):
@wraps(func)
def f1(*args, **kwargs):
return func(*args, **kwargs)
return f1
return f
调用形如：
@foo('123') #多了个参数，可分解为foo的返回值f 放在 @ 的后面，是否是一切又回到了从前？
def func():
pass
装饰类：
应用场景：
Python WEB框架 Flask/Django都有 FBV和CBV模式 (之后我也会写这方面的文章)
FBV: Function Based View 简单来讲，逻辑视图用函数来写
----那么须要装饰器的时候，直接用普通函数装饰器装饰到函数上便可
CBV: Class Based View 简单来讲，逻辑视图用类来写
----这种没有函数，是用类写的，那么这时候就须要对类进行装饰了
核心思想：
仍是记住上面讲的隐式变形，只不过此次传给装饰器的是类，对类的操做可就太多了。
里面一大堆黑魔法，下面我就来写一下类初始化功能性装饰器。（之后也会单独写黑魔法的文章）
In [1]: def f(c):
def f1(*args, **kwargs):
return c(*args,**kwargs)
return f1
In [2]: @f
...: class A:
...: def __init__(self,name):
...: print(name)
In [3]: A('Tom')
Tom # 这是print打印的输出
Out[3]: <__main__.A at 0x2948e8fb828>
类装饰器：
这个场景真没遇到过，不过实现也很容易的。
In [8]: class A:
...: def __init__(self,func):
...: self.func = func
...: def __call__(self,*args,**kwargs):
...: print('类装饰填充了啊')
...: self.func(*args, **kwargs)
...:
In [9]: @A
...: def test():
...: print('我是原函数')
...:
In [10]: test()
类装饰填充了啊
我是原函数
说明：后面关于类的装饰器若是理解困难当作了解便可，用的也少。
结束语：
我一直认为Python的 三器、三程 是相对困难 又 颇有含金量的东西。 当时学的时候理解不了，特别是装饰器，即便理解了，当时照着别人的例子去记忆和理解，事后也忘得很快， 当消化成本身的东西，或者本身能为这个语法举个例子出来，那么印象会很深入。 语法这东西就是长时间不用就会忘记，没办法，捡起来个十几回-几十次就顺手了，都这样过来的。 当你对复杂语法熟悉的时候，你能够不用去从头去理思路，而是脑中迅速就能够闪现出它的流程。 我感受我三器写的比较全面了，若是有问题欢迎交流与改正！
相关文章
- 1. 经验拾忆（纯手工）=> Python三程
- 2. 经验拾忆（纯手工）=> Python基本数据类型
- 3. 经验拾忆（纯手工）=> Python高阶函数操做
- 4. 经验拾忆（纯手工）=> Python正则全解详解
- 5. 经验拾忆（纯手工）=> Python好用深度技能工具介绍
- 6. C++拾忆
- 7. 算法拾忆
- 8. Django组件拾忆
- 9. [TODO]Python拾遗（三）
- 10. 纯手工注入
- 更多相关文章...
- • XML 验证器 - XML 教程
- • SQLite - Python - SQLite教程
- • PHP开发工具
- • Docker容器实战(六) - 容器的隔离与限制
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章