4.1.7 特殊方法与运算符重载

　　Python的类有大量的特殊方法，其中比较常见的是构造函数和析构函数。Python中类的构造函数是__init__()，一般用来为数据成员设置初始值或进行其他必要的初始化工作，在创建对象时被自动调用和执行。如果用户没有设计构造函数，Python将提供一个默认的构造函数用来进行必要的初始化工作。Python中类的析构函数是__del__()，一般用来释放对象占用的资源，在Python删除对象和回收对象空间时别自动调用和执行。如果用户没有编写析构函数，Python将提供一个默认的析构函数进行必要的清理工作。

　　在Python中，除了构造函数和析构函数之外，还有大量的特殊方法支持更多的功能，例如，运算符重载就是通过在类中重写特殊函数来实现的。在自定义类时如果重写了某个特殊方法即可支持对应的运算符，具体实现了什么工作则完全可以根据需要来定义。

　　　　　　　　　　　　　　　　　　　　　　　　　　Python类特殊方法

方法	功能说明
__new__()	类的静态方法，用于确定是否要创建对象
__init__()	构造函数，生成对象时调用
__del__()	析构函数，释放对象时调用
__add__()	+
__sub__()	-
__mul__()	*
__truediv__()	/
__floordiv__()	//
__mod__()	%
__pow__()	**
__repr__()	打印、转换
__setitem__()	按照索引赋值
__getitem__()	按照索引获取值
__len__()	计算长度
__call__()	函数调用
__contains__()	in
__eq__()、__ne__()、__lt__()、__le__()、__gt__()、__ge__()	==、!=、<、<=、>、>=
__str__()	转化为字符串
___lshift__()、__rshift__()	<<、>>
__and__()、__or__()、__invert__()、__xor__()	&、|、~、^
__iadd__()、__isub__()	+=、-=

 1、__init__：构造初始化函数，在创建实例对象为其赋值时使用，在__new__之后，__init__必须至少有一个参数self，就是这个__new__返回的实例，__init__是在__new__的基础上可以完成一些其它初始化的动作，__init__不需要返回值。

2、__new__:创建并返回一个实例对象，如果__new__只调用了一次，就会得到一个对象。继承自object的新式类才有__new__这一魔法方法，__new__至少必须要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供，__new__必须要有返回值，返回实例化出来的实例（很重要），这点在自己实现__new__时要特别注意，可以return父类__new__出来的实例，或者直接是object的__new__出来的实例，若__new__没有正确返回当前类cls的实例，那__init__是不会被调用的，即使是父类的实例也不行。__new__是唯一在实例创建之前执行的方法，一般用在定义元类时使用。

创建对象的步骤：

a、首先调用__new__得到一个对象

b、调用__init__为对象添加属性

c、将对象赋值给变量。

class A(object):
    pass

class B(A):
    def __init__(self):
        print('__init__被调用...')

    def __new__(cls):
        print('__new__被调用...')
        print(id(cls))
        return object.__new__(A)  #注意在此处采用了参数A而不是cls，__new__没有正确返回当前类cls的实例
    
'''
从运行结果可以看出，__new__中的参数cls和B的id是相同的，表明__new__中默认的参数cls就是B类本身，而在return时，
并没有正确返回当前类cls的实例，而是返回了其父类A的实例，因此__init__这一魔法方法并没有被调用，
此时__new__虽然是写在B类中的，但其创建并返回的是一个A类的实例对象。
'''

3、__class__：获得已知对象的类 ( 对象.__class__)。

class A:
    count = 0
    def addcount(self):
        self.__class__.count += 1

4、__str__：在将对象转换成字符串  str(对象)  测试的时候，打印对象的信息，__str__方法必须要return一个字符串类型的返回值，作为对实例对象的字符串描述，__str__实际上是被print函数默认调用的，当要print（实例对象）时，默认调用__str__方法，将其字符串描述返回。如果不是要用str()函数转换。当你打印一个类的时候，那么print首先调用的就是类里面的定义的__str__。

class A:
    def __init__(self,name):
        self.name = name

    def __str__(self):
        return '我是A类的实例对象a，我的名字叫{}'.format(self.name)

if __name__ == '__main__':

    a = A('老王')
    print(A)  #<class '__main__.A'>
    print(a)  #我是A类的实例对象a，我的名字叫老王

    #__str__方法是不会被调用的，而print(a)的时候，_str__就被调用了。

可以看出，直接敲a的话，__str__方法是不会被调用的，而print(a)的时候，__str__就被调用了。

5、__repr__：如果说__str__体现的是一种可读性，是给用户看的，那么__repr__方法体现的则是一种准确性，是给开发人员看的，它对应的是repr()函数，重构__repr__方法后，在控制台直接敲出实例对象的名称，就可以按照__repr__中return的值显示了。

class A:
    def __init__(self,name):
        self.name = name

    def __str__(self):
        return '我是A类的实例对象a，我的名字叫{}'.format(self.name)

    def __repr__(self):
        return '哈哈，我是A的实例对象a!'

if __name__ == '__main__':

    a = A('老王')
    print(A)  #<class '__main__.A'>
    print(a)  #我是A类的实例对象a，我的名字叫老王
    print(repr(a))

'''
打印操作会首先尝试__str__和str内置函数(print运行的内部等价形式)，它通常应该返回一个友好的显示。

__repr__用于所有其他的环境中：用于交互模式下提示回应以及repr函数，它通常应该返回一个编码字符串，可以用来重新创建对象，或者给开发者详细的显示。

当我们想所有环境下都统一显示的话，可以重构__repr__方法；当我们想在不同环境下支持不同的显示，例如终端用户显示使用__str__，而程序员在开发期间则使用底层的__repr__来显示，实际上__str__只是覆盖了__repr__以得到更友好的用户显示。

'''

6、__del__：对象在程序运行结束之后进行垃圾回收的时候调用这个方法，来释放资源。此时，此方法是被自动调用的。除非有特殊要求，一般不要重写。在关闭数据库连接对象的时候，可以在这里，释放资源。

class NewClass(object):
    num_count = 0  # 所有的实例都共享此变量，即不单独为每个实例分配
    def __init__(self,name):
        self.name = name
        NewClass.num_count += 1
        print(name,NewClass.num_count)

    def __del__(self):
        NewClass.num_count -= 1
        print('Del',self.name,NewClass.num_count)

    def test(self):
        print('aa')

if __name__ == '__main__':
    #aa = NewClass('Hello')
    #bb = NewClass('World')
    #cc = NewClass('aaaa')
    #print('Over')
    pass

#可以看出在程序运行结束之后，__del__默认被调用了三次，分别对实例对象aa,bb,cc进行垃圾回收，因为此时创建的实例已经没有对象再指向它了。

import time

class Animal:
    def __init__(self,name):
        print('__init__方法被调用')

    def __del__(self):
        print('__del__ ......')

wangcai = Animal('旺财')
xiaoqiang = wangcai

del wangcai
print('*' * 50)
del xiaoqiang
time.sleep(2)
print('over......')

#__init__方法被调用
#**************************************************
#__del__ ......
#over......

'''可以看出，wangcai和xiaoqiang指向的是同一个实例对象，在del wangcai的时候，__del__并没有被调用，因为此时这个对象还在被xiaoqiang引用着，当del xiaoqiang的时候，__del__就默认被调用了，因为此时没有变量再引用这个实例对象了，相当于其引用计数变为0了，这个对象理所当然就会被垃圾回收。

总而言之，__del__魔法方法是在对象没有变量再引用，其引用计数减为0，进行垃圾回收的时候自动调用的。

'''

7、__getattribute__：属性访问拦截器，在访问实例属性时自动调用。在python中，类的属性和方法都理解为属性，且均可以通过__getattribute__获取。当获取属性时，相当于对属性进行重写，直接return object.__getattribute__(self, *args, **kwargs)或者根据判断return所需要的重写值，如果需要获取某个方法的返回值时，则需要在函数后面加上一个()即可。如果不加的话，返回的是函数引用地址。

class Test(object):
    def __init__(self,subject1):
        self.subject1 = subject1
        self.subject2 = 'cpp'

    def __getattribute__(self,obj):
        if obj == 'subject1':
            return 'redirect python'
        else:
            return object.__getattribute__(self,obj)


if __name__ == '__main__':
    s = Test('Python')
    print(s.subject1)
    print(s.subject2)

#redirect python
#cpp

'''
在创建实例对象s并对其初始化的时候，subject1的值设置为‘python’，subject2的值设置为‘cpp’，
在访问s的subject1属性时，因为Test类对object类中的__getattribute__方法进行了重写，
所以在调用此方法时，首先对要访问的属性做一个拦截和判断，
此时__getattribute__方法中的参数obj对应的是要访问的属性，若要访问subject1属性，
则对该属性进行重写，返回了一个不同的字符串，我们可以看到，在初始化时，
subject1 的值为‘python’，而在访问subject1这个属性时，返回的值是'redirect python'，
而在访问subject2时，则调用其父类中的__getattribute__方法，返回正常的subject2属性的值。
当然，在访问类的方法属性时，也可以通过重写__getattribute__的方法对其进行重写。
'''

8、__bases__：获取指定类的所有父类构成元素，使用方法为类名.__bases__

class A:
    pass

class B(A):
    pass

class C():
    pass

class D(B,C):
    pass

print(D.__bases__)

#(<class '__main__.B'>, <class '__main__.C'>)   直显示父类，不现实父类的父类

9、__mro__：显示指定类的所有继承脉络和继承顺序，假如这个指定的类不具有某些方法和属性，但与其有血统关系的类中具有这些属性和方法，则在访问这个类本身不具有的这些方法和属性时，会按照__mro__显示出来的顺序一层一层向后查找，直到找到为止。

class A:
    pass

class B(A):
    pass

class C():
    pass

class D(B,C):
    pass

print(D.__mro__)

# (<class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, 
      <class '__main__.C'>, <class 'object'>)

10、__call__:具有__call__魔法方法的对象可以使用XXX()的形式被调用，比如说类的实例对象

class Dog(object):

    def __init__(self):
        print('__init__被调用......')

    def __call__(self):
        print('__call__被调用......')

#wangcai = Dog()
#wangcai()

'''
__init__被调用......
Traceback (most recent call last):
  File "C:/Users/dddd/PycharmProjects/untitled5/test1.py", line 8, in <module>
    wangcai()
TypeError: 'Dog' object is not callable
'''
'''
可以看到，Dog类的实例对象laowang是不可以使用laowang()的方式进行调用的，
   因为其没有__call__魔法方法，进行了修改之后，
   laowang这个实例对象就可以使用()的方式被调用了：
'''

#然后为Dog类重写 __call__函数
wangcai = Dog()
wangcai()

#__init__被调用......
#__call__被调用......

11、魔法属性：__stlos__:可以限制实例对象的属性和方法，但是对类不起作用。

12、__all__:将一个py文件作为模块导入时，其中if __name__ == "main"以上的类、方法、函数等都能被导入，但某些方法可能只是用来做测试用的，不希望也不建议被导入，可以用__all__=['函数名或方法名']的方式限制一下哪些函数或方法可以被导入，即[]中的函数名或方法名可以被导入。但是需要强调的是，__all__魔法方法只针对通过 from xx import *这种导入方式有效。

#自定义一个脚本
__all__ = ['a','b']

def a():
    print('a')
    
def b():
    print('b')

def c():
    print('c')
    
if __name__ == '__main__':
    print('hello 老王')
    print('123')