python描述符魔术方法_Python基础教程（十） Python的面向对象编程之魔术方法

魔术方法：用__xxx___表示

__init__(self,p1,p2,...):

xxx

构造方法，实例化对象的时候会自动调用,一般用于初始化声明类的属性

例如:

class Person:

name=""

def __init__(self,name):

self.name=name

def sayname(self):

print(self.name)

zbp=Person("zbp")

zbp.sayname()

如何声明一个私有属性,在PHP中,所谓的私有属性就是只能在类内部使用的属性,不能在类之外使用

只要在属性名前添加"__",即可声明一个私有属性

如 __name="xxx"

或者self.__name="xxx"

但是呢其实这个私有变量是可以在外部调用的

访问 _类名__属性名 就可以

例如：

class Person:

__name="zbp"

zbp=Person()

print(zbp.name) #报错

print(zbp.__name) #报错

print(zbp._Person__name) #可以

#所以说py的私有变量其实是伪私有

构造方法只能返回None,不能返回其他类型

__del__(self) 析构方法

某对象的所有引用都被del之后，就会调用这个方法。

如：

class A:

def __del__(self):

print("析构函数")

a1=A()

a2=a1

a3=a2

del a1 #没输出

del a3 #没输出

del a2 #输出析构函数4字

算数魔术方法：

__add__(self,...) #对象相加时自动调用

__sub__(self,...) #...

__mul__(self,...)

__truediv__(self,..)

__repr__(self) #当调用对象时会调用，如

a=A()

a #调用

__str__(self) #当print对象时会调用

这两个方法都要返回字符串，否则报错

__getattr__(self,name) #当用户访问一个不存在的属性时调用

__getattribute__(self,name) #当用户访问类的一个属性时触发(在类内调用属性也会触发)，无论这个属性是否存在

PS：__getattribute__的触发会先于__getattr__

__setattr__(self,name,value)#当设置一个属性时(无论是在类之内还是之外设置)触发，无论这个属性是否存在,调用这个方法返回的就是你访问的属性的属性值

__delattr__(self,name) #当干掉一个属性时触发

现在我有一个需求，Test类里面有一个属性是nickName

我的需求是，当我访问nickName属性，要输出nickName属性后加上abc这个字符

class Test:

nickName="zbp"

def __getattribute__(self,name):

newStr=super().__getattribute__(name) #super().__getattribute__(name)返回nickName的值，super()是object对象，是所有对象的基类

newStr+="abc"

return newStr

t=Test()

print(t.nickName)

描述符：(就是一个类)

就是将某种特殊类型的类(描述符)的实例指派给另一个类的属性

什么事特殊类型的类？

就是至少存在以下一个魔术方法的类：

__get__(self,instance,owner) 访问描述符对象时触发，要返回属性的值

__set__(self,instance,value) 在给描述符对象时触发，不返回任何内容

__delete__(self,instance)删除描述符对象时触发，不返回任何内容

现在写一个描述符：

class MyDecriptor:

def __get__(self,instance,owner):

print("getting",self,instance,owner)

def __set__(self,instance,value):

print("getting",self,instance,value)

def __delete__(self,instance)

print("getting",self,instance)

class Test:

x=MyDecriptor()

#这里将描述符的类实例化赋给Test的属性

test=Test()

test.x #触发描述符的__get__

#__get__里面的self是描述符对象，即x

#instance是test对象

#owner是Test这个类

test.x="zbp"#触发描述符的__set__

del test.x #触发描述符的__delete__

其实property()就是一个描述符

这里我们可以自己写一个描述符代替property的功能

class MyProperty:

def __init__(self,getAttr=None,setAttr=None,delAttr=None):

self.getAttr=getAttr#这里传进来的这3个参数的内容是方法，就是要将3个方法赋给描述符的变量

self.setAttr=setAttr#这么一来，MyProperty的这3个属性就变成了可以调用的方法

self.delAttr=delAttr

def __get__(self,instance,owner):

return self.getAttr(instance)

def __set__(self,instance,value):

self.setAttr(instance,value)

def __delete__(self,instance):

self.delAttr(instance)

class A():

__a=None #设置为私有的属性，必须调用方法来访问和设置该属性

def getA(self):

return self.__a

def setA(self,value):

self.__a=value

def delA(self):

del self.__a

x=MyProperty(getA,setA,delA)#将3个方法赋给描述符

定制容器：

什么是容器，就是能存放东西的变量，比如列表，字符串，字典，元组都是容器

如果希望定制的容器是不可变的话，只需定义__len__()和__getitem__()方法

如果是可变的，还要多定义__setitem__和__delitem__方法

__len__在len(对象)时触发

__getitem__在调用对象[key]时触发

__setitem__和__delitem__的触发以此类推

现在有一个需求，写一个自定义的列表，要求这个列表定义后不能改变，而且访问该列表的count属性能返回所有元素访问的次数

class MyList:

def __init__(self,*args):

self.list=list(args)

self.len=len(self.list)

#self.count={}.formkeys(range(self.len),0) #这句话可以代替下面的for循环

self.count={}

a=0

for i in self.list:

self.count[a]=0

a+=1

def __len__(self):

return self.len

def __getitem__(self,key):

if key<0 or key>self.len-1 :

return ""

self.count[key]+=1

return self.list[key]#不用担心这里会无限递归，self[key]才会无限递归

迭代器(迭代就是循环啦)

这里我要说一点：遍历列表，元组的时候，for i in xxx 中的i是序列的值

但是遍历字典的时候，for i in xxx中的i是字典的下标

xxx[i]才是他的值,就当是复习一下啦

介绍两个bif:

iter()/next()

如

str1="zbp"

it=iter(str1)

next(it)#z

next(it)#b

next(it)#p

next(it)#报错

for其实就是使用iter()和next()实现的

迭代器是一个具有__iter__()/__next__()魔术方法的类

__iter__()/__next__()

当循环一个对象的时候，就会自动调用这两个方法，__iter__()没有什么内容，直接return self即可

__next__()是每循环一次就调用一次

class addCount:

i=0

r=0

def __init__(self,s):#s是目标值

self.s=s

def __iter__(self):

return self

def __next__(self):

if(self.r>=self.s):

raise StopIteration#停止循环

else :

self.r+=self.i

self.i+=1

return self.r

a=addCount(1000)

for i in a:

print(i)