python描述符的简单介绍

这篇文章主要介绍“python描述符的简单介绍”，在日常操作中，相信很多人在python描述符的简单介绍问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”python描述符的简单介绍”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

　　什么是描述符

　　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 :

　　========================================

　　@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():郑州妇科医院 http://www.xadsyyfk.com/

　　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 的模块文件，内容可以为空

　　第三步 将相关的模块放在文件夹(包)里面

　　导入 ： 包名.模块名

到此，关于“python描述符的简单介绍”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注编程网网站，小编会继续努力为大家带来更多实用的文章！