什么是描述符

官方说法：python描述符是一个“绑定行为”的对象属性，在描述符协议中，它可以通过方法重写属性的访问。这些方法有 get(), set(), 和__delete__()。如果这些方法中的任何一个被定义在一个对象中，那么这个对象就是一个描述符。

换句话说： 含有以下三个方法之一的对象就是描述符

三个方法（协议）：

get(self, instance, owner):调用一个属性时,触发
set(self, instance, value):为一个属性赋值时,触发
delete(self, instance):采用del删除属性时,触发

什么是self instance、owner？

self 是当前描述符（对象）自身，类似C++this指针， instance 是描述符所属类对象实体、owner是描述符所在的类（谁拥有这些东西，当然是最高的类）

class Desc(object):
    def __get__(self, instance, owner):
        print("__get__...")
        print("self : \t\t", self)
        print("instance : \t", instance)
        print("owner : \t", owner)
        print('='*40, "\n")     
    def __set__(self, instance, value):
        print('__set__...')
        print("self : \t\t", self)
        print("instance : \t", instance)
        print("value : \t", value)
        print('='*40, "\n")
class TestDesc(object):
    x = Desc()
#以下为测试代码
t = TestDesc()
t.x
#以下为输出信息：
__get__...
self :          <__main__.Desc object at 0x0000000002B0B828>
instance :      <__main__.TestDesc object at 0x0000000002B0BA20>
owner :      <class '__main__.TestDesc'>
========================================

@property把函数调用伪装成对属性的访问

class Foo:
  @property
  def attr(self):
    print('getting attr')
    return 'attr value'

  def bar(self): pass
foo = Foo()

x = property(get, set, del);

容器类型协议：

如果希望定制的容器不可变：只需要定义 len() getitem()这两个魔法

如果希望定制的容器可变，还需要定义__setitem__ __delitem __()这两个魔法

class CountList:
    def __init__(self, *args):
        self.values = [x for x in args]#列表推导式 
        self.count = {}.fromkeys(range(len(self.values)),0)#建立字典记录访问次数

    #字典；0 - len(self.value) 
    def __len__(self):
        return len(self.values)

    #获取值， 并不是获取访问次数
    #gwtitem ,只要访问 必定触发， 这就是魔法
    def __getitem__(self,key):
        self.count[key] +=1
        return self.values[key]

python 迭代器： iter next

string = ‘hello, python’
it = iter(string)
next(it)
next(it)
…

iter迭代器为假的时候，抛出异常
it = iter(“hello,world”)
while True:
try:
each = next(it)
print (each)
except:
break;

迭代器的魔法方法：
iter()
next()

class Iter:
    def __init__(self, n =100):
        self.a = 0
        self.b = 1
        self.n = n

    def __iter__(self):
        return self

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b
        if self.a > self.n:   #停止迭代
            raise StopIteration
        return self.a

生成器 ： yeild语句的函数

生成器也是一种迭代器： yield 语句返回

乱入 ： 胡进里，没规律，嘿嘿

协同程序：协程

所谓协同程序就是可以运行的独立函数调用，函数可以暂停或者挂起，并在需要的时候从程序离开的地方继续执行

生成器也是一种迭代器，那么代表它也可以像迭代器一样， 可以配合next（迭代器对象）使用


仔细观察： generator 生成器第一次调用之后 yield 返回 ，之后并不是从函数头再开始 ，而是从离开的地方继续调用

def generator():
    a = 0
    b = 1
    print("开始迭代生成器")
    while True:
        a,b = b, a+b
        yield a

for each in generator():
    if(each > 100):
        break
    print(each,end = ' ')#不换行 ，以空格代替换行

生成器推导式作为函数的参数 可以不带（）

eg: 0 + … + 9
本来： sum( (i for i range(10))
和谐掉（） sum sum(i for i in range(10))

列表推导式[i for i in range(10)]
字典推导式{i for i in range(100)}
不存在元组推导式哦， 它变成了生成器generator推导式

模块

容器： 对数据的封装
函数：对语句的封装
类 ： 方法和属性的封装
模块： 就是程序。

导入模块名：
Find1 ：
导入：import +模块名(as t)
调用： 模块名(t). + 函数 ·

name == main

if name == main 作用： 让python识别： 程序是在主程序运行还是在模块内运行： 即让python识别是私有程序还是公有程序

也就是 if name == main 是主程序吗？ 是的话做什么， 不是的话做什么

搜索路径

python 导入模块的过程有一个路径搜索的过程

先sys.path.append(“模块路径”)
再导入模块

包 package

第一步 创建一个文件夹存放模块 。文件见名字就是包的名字
第二步 在文件夹内创建一个__init__.py 的模块文件，内容可以为空
第三步 将相关的模块放在文件夹（包）里面

导入 ： 包名.模块名