【Rollo的Python之路】Python 面向对象 （六） 特殊成员

Python 面向对象 ：特殊成员

1.0.1  __call__  :__call__()的本质是将一个类变成一个函数（使这个类的实例可以像函数一样调用）

直接用obj()调用：

 

class Roo:
    def __init__(self):
        print('init')

    def __call__(self, *args, **kwargs):
        print('call')

obj = Roo()
obj()
Roo()()

 

1.0.2 __str__ ：主要用来打印，str (obj),执行obj的__str__方法，并把返回值给obj

class Roo:
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def __str__(self):
        return '%s---%s' %(self.name,self.age)


obj = Roo('rollo',25)
print(obj)

 

1.0.3 __int__ :转换数字

class Roo:
    def __init__(self):
       pass

    def __int__(self):
        return 123


obj = Roo()
print(obj,type(obj))
#int 一个对象，自动执行对象的__int__方法，并将返回值给int的对象
r = int(obj)
print(r)

 

1.0.4 __init__ 类()自动执行，这个是类的构造方法

 

1.0.5 __add__: 两个对象相加，自动执行第一个对象的__add__方法，并将第二个对象当作参数传入，一个一个

class Roo:
    def __init__(self,name,age):
        self.name = name
        self.age = age


    def __add__(self, other):
        #self = obj1('rollo',25)
        #other = obj2('beyond',29)
        return self.age + other.age

obj1 = Roo('rollo',25)
obj2 = Roo('beyond',29)

ret = obj1 + obj2
print(ret,type(ret))

 

class Roo:
    def __init__(self,name,age):
        self.name = name
        self.age = age


    def __add__(self, other):
        #self = obj1('rollo',25)
        #other = obj2('beyond',29)
        # return self.age + other.age
        return Roo('mathew',54)
    
obj1 = Roo('rollo',25)
obj2 = Roo('beyond',29)

ret = obj1 + obj2
print(ret,type(ret))

 

1.0.6 和__add__一样一样的。

• __add__: 加运算
• __sub__: 减运算
• __mul__: 乘运算
• __truediv__: 除运算
• __mod__: 求余运算
• __pow__: 乘方

 

1.0.7 __del__ :析构函数，释放对象时使用

 

class Roo:
    def __init__(self,name,age):
        self.name = name
        self.age = age


    def __add__(self, other):
        #self = obj1('rollo',25)
        #other = obj2('beyond',29)
        # return self.age + other.age
        return Roo('mathew',54)
    def __del__(self):#对象被销毁的时候，自动执行的方法
        pass

 

1.0.8 __dict__ :将对象中封装的所有内容通过字典的形式返回

class Roo:
    def __init__(self,name,age):
        self.name = name
        self.age = age


obj = Roo('rollo',36)

ret = obj.__dict__
print(ret)

class Roo:
    """
    当前类 ：注释也当作类的成员
    """
    def __init__(self,name,age):
        self.name = name
        self.age = age


obj = Roo('rollo',36)

ret = obj.__dict__
print(ret)

 

1.0.9 __getitem__ :自动执行对象的类中的__getitem__方法，索引值会当做参数传入，__setitem__,__delitem__

 

 

class Roo:

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __getitem__(self, item):
        return item + 10

    def __setitem__(self, key, value):
        print(key,value)

    def __delitem__(self, key):
        print(key)
obj = Roo('rollo',25)
ret = obj[8]
print(ret)

obj[100] = 'mak'

del obj[666]

 

class Roo:

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __getitem__(self, item):
        return item + 10

    def __setitem__(self, key, value):
        print(key,value)

    def __delitem__(self, key):
        print(key)
obj = Roo('rollo',25)

obj = [1:4:2]  #切片也是执行__getitem__方法
ret = obj[8]

 

 

__getitem__ :如果item是基本类型：int,str，就索引猎取

　　　　　　如果item是一个slice对象的话，就切片。

 

class Roo:

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __getitem__(self, item):
        # return item + 10
        # print(item,type(item))
        if type(item) == slice:
            print('调用切片处理')
        else:
            print('索引处理')

    def __setitem__(self, key, value):
        print(key,value)

    def __delitem__(self, key):
        print(key)
obj = Roo('rollo',25)

obj [1:4:2]  #切片也是执行__getitem__方法
ret = obj[8]

class Roo:

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __getitem__(self, item):
        # return item + 10
        # print(item,type(item))
        if type(item) == slice:
            # print('调用切片处理')
            print(item.start,item.stop,item.step)
        else:
            print('索引处理')

    def __setitem__(self, key, value):
        print(key,value)

    def __delitem__(self, key):
        print(key)
obj = Roo('rollo',25)

obj [1:4:2]  #切片也是执行__getitem__方法
ret = obj[8]
print(ret)

 

同时切片也可以：__setitem__,__delitem__

 

class Roo:

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __getitem__(self, item):
        # return item + 10
        # print(item,type(item))
        if type(item) == slice:
            # print('调用切片处理')
            print(item.start,item.stop,item.step)
        else:
            print('索引处理')

    def __setitem__(self, key, value):
        print(key,value)

    def __delitem__(self, key):
        print(key)
obj = Roo('rollo',25)

obj [1:3] = [22:66]
del obj [1:3]

 

1.0.10 __iter__

 i 是可迭代对象 ，就用iter()方法变成迭代器，才能for。

如果类 中有__iter__方法，对象就是可迭代的

对象__iter__ 的返回值，是迭代器

for循环，迭代器，next

如果是可迭代对象，用iter变成迭代器

class Roo:

    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __iter__(self):
        return iter((1,2,3))# i 是可迭代对象 ，就用iter()方法变成迭代器，才能for。


obj = Roo('rollo',24)

#1.0执行obj对象的类中的__iter__方法，并获得返回值。
#2.0 循环上一步反回来的对象

for i in obj:
    print(i)

 

1.0.11 metaclass，类的祖宗

　　1.0.11.1 Python中一切事物都是对象

　　1.0.11.2  

class Roo:
    pass

obj = Roo()
#obj是对象，Roo类
#Roo类也是一个对象，type的对象

　　 1.0.11.3 Roo = type('Roo',(object,),{'func':function})  也是声明一个类

Roo = type('Roo',(object,),{'func':lambda x:123})
obj = Roo()

　　1.0.11.4

　　类都是type类的对象：type()

　　“对象”都是类的对象：类()

 

class Mytype(type):
    def __init__(self):
        print(123)

class Roo(object,metaclass=Mytype): #metaclass 用的是mytype的构造方法，不用默认的type的__init__
    def func(self):
        print(666)

 

obj= bar().

经历了，__call__方法，再到__new__，然后再到__init___