面向对象之魔术方法

一、什么是魔术方法

在Python中，像__init__这类双下划线开头，双下划线结尾的方法，统称为魔术方法，魔术方法会在特定的时候自动调用；

注意：

魔术方法都是Python内部定义的，我们创建类的时候，不要定义双下划线开头和双下划线结尾这样的方法；

二、魔术方法

1、__new__方法

class MyClass(object):
    def __init__(self,name):
        self.name = name

    def __new__(cls, *args, **kwargs):
        print("这是自定义的new方法")
        # return super().__new__(cls)
        return object.__new__(cls)

mc = MyClass("YEWEIYIN")

执行结果为：
这是自定义的new方法

__new__方法是创建对象时调用的第一个魔术方法，__new__方法在类的父类object类里面，它被@staticmethod装饰器装饰成了静态方法，

如果自己定义的类里面要重写__new__方法，则新定义的__new__方法一定要有retrun返回值，不然不能创建实例对象；

为了创建的实例对象能够调用类里面的方法，__new__方法返回的值要为类对象创建的实例对象，如果返回的是其他对象，则不能调用__init__方法初始化，

__new__方法返回实例对象有两种写入方法：

return object.__new__(cls);

return super().__new__(cls);

__new__方法的应用场景：设计单例模式

****单例模式：

类第一次实例化之后创建了一个新的实例对象，往后类每次实例化创建的对象都是第一次创建的实例对象，也就是说，

类不管实例化多少次，它创建的实例对象都只有一个，而且是第一次创建的那一个；

简单的单例模式：

class MyClass(object):
    __instance = None　　#　　__开头表示是私有属性，定义之后不可进行更改
    def __new__(cls, *args, **kwargs):
        print("自定义的new方法实现单例模式")
        if cls.__instance is None:
            cls.__instance = object.__new__(cls)
        return cls.__instance

mc = MyClass()
mc.name = "yeweiyin"
print(id(mc))
print(mc.name)
mc2 = MyClass()
print(mc2.name)
print(id(mc2))

执行结果为：
自定义的new方法实现单例模式
20514352
yeweiyin
自定义的new方法实现单例模式
yeweiyin
20514352

通过执行结果，可以发现，我们创建了mc和mc2两个实例对象，通过mc实例对象又创建了一个name属性，在执行结果中，

mc和mc2两个实例对象的id是同一个，mc2实例对象能够调用mc实例创建的name属性，并得到相同的name属性值；

通过装饰器实现单例模式：

def single(cls):
    instance = {}　　#　　字典的键为类，值为类的实例对象
    def func(*args,**kwargs):　　　　
        if cls in instance:　　#　　如果类被创建过实例对象，那么忽略后面创建实例需求，直接返回已创建的实例对象
            return instance[cls]
        else:
            instance[cls] = cls(*args,**kwargs)　　#　　如果类没有被创建过实例对象，那么创建类的实例对象，并保存在字典中，然后返回实例对象
            return instance[cls]
    return func

@single
class MySingle(object):
    def myname(self):
        print("yeweiyin")
        
@single
class MySingleT(object):
    def __init__(self,name):
        self.name = name
    def updatename(self):
        print(self.name)

ms3 = MySingle()
ms3.age = 19
ms4 = MySingle()
print(ms4.age)

如上：只要类被Sigle这个装饰器装饰了，都是一个单例模式的类；

2、__str__方法和__repr__方法

>>> a = "abc"
>>> print(a)
abc
>>> a
'abc'
>>>

在交互环境下测试，如上：定义一个变量a = “abc”，通过print打印a的值，和直接输入a给出的值不一样，这是为什么呢？

原来，在使用print打印时，调用了__str__这个魔术方法，而直接输入变量a，调用的则是__repr__这个魔术方法；

触发__str__方法有三种情况：

通过print打印时；

调用内置函数str()方法时；

调用format()方法时；

触发__repr__方法有两种情况：

在交互环境下时；

调用repr()方法时；

具体调用如下：

class MyMethod(object):
    def __init__(self,name):
        self.name = name
    def __str__(self):
        print("触发str方法")
        return ("str方法返回的值：" + self.name)
    def __repr__(self):
        print("触发repr方法")
        return ("repr方法返回的值：" + self.name)

mm = MyMethod("yeweiyin")
print(mm)
str(mm)
format(mm)
repr(mm)
print(MyMethod(repr(MyMethod("MM"))))

执行结果：
触发str方法
str方法返回的值：yeweiyin
触发str方法
触发str方法
触发repr方法
触发repr方法
触发str方法
str方法返回的值：repr方法返回的值：MM

****注意：

****重写__str__方法和__repr__方法时，必须要加return，而且return返回的必须为字符串对象

在触发__str__方法的那三种情况下，会优先触发__str__方法，如果没有定义__str__方法，会去找__repr__方法触发，如果这两个方法都没有定义，

那么就会去找父类中的__str__反方法触发；

在触发__repr__方法的那两种情况下，会先找自身的__repr__方法去触发，如果自身没有定义__repr__方法，那么就会去找父类中的__repr__方法去触发；

深入解析__str__和__repr__的返回值：

__str__方法的返回值通俗点的意思是给用户看的，很直观的看到数据值，如上所示的，在交互环境下通过print方法触发了__str__方法，

返回a的值为：abc，我们就只看到a的值是abc，而不知道abc是什么类型，代表什么；

__repr__方法的返回值是给程序员看的，追踪到数据的根源（如：那个类创建出来的），如上所示的，在交互环境下直接输入a，

触发了__repr__方法，返回a的值为：'abc'，这样我们就知道了a的值是一个值为'abc'的字符串；

3、__call__方法

我们知道函数可以：函数名()，这样调用，而类或者其他对象不能通过：对象名()，这样调用呢，其实是__call__方法在起作用；

如果我们想要类创建的对象可以像函数一样调用，应该怎么做呢？

我们可以在类里面定义一个__call__方法即可，如：

class MyObject(object):
    def __init__(self,name):
        self.name = name
    def __call__(self, *args, **kwargs):
        print("call方法被调用")

mo = MyObject("yeweiyin")
mo()

执行结果：
call方法被调用

**对象在像函数一样被调用时触发__call__方法

由于__call__方法的特性，我们可以通过在类里面定义__call__方法来实现类作为装饰器

class MyCall(object):
    def __init__(self,func):
        self.func = func
    def __call__(self, *args, **kwargs):
        print("这是类装饰器的功能")
        self.func()
        print("调用原功能函数之后的装饰器功能")
@MyCall
def muen():
    print("实现新的功能")

muen()

执行结果：
这是类装饰器的功能
实现新的功能
调用原功能函数之后的装饰器功能

 4、上下文管理器的__enter__和__exit__的魔术方法

上下文管理器最常用的场景是操作文件，一般用with   as  语法连用；如：with open(filename,"r",encoding="utf-8") as f:

通常我们使用open打开文件读取或写入操作后要close关闭文件，但是使用with   as  的上下文管理器之后，就不要需要再关闭文件了，

其实际是with关键字触发了__enter__方法和__exit__方法；

自定义一个上下文管理器：

class MyOpen(object):
    def __init__(self,filename,method,encoding="utf8"):
        self.filename = filename
        self.method = method
        self.encoding = encoding
    def __enter__(self):
        self.f = open(self.filename,self.method,encoding=self.encoding)
        return self.f
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()
再简单一点：

class MyOpen(object):
    def __init__(self,filename,method,encoding="utf8"):

         self.f = open(filename,method,encoding=encoding)

    def __enter__(self):
         return self.f 
    def __exit__(self, exc_type, exc_val, exc_tb):
         self.f.close()

with MyOpen("test.txt","r") as f:
 # print(f.write("鹅鹅鹅，曲项向天歌"))
 　　print(f.read())

通过上面自定义的上下文管理器，我们可以知道，首先MyOpen这个类创建了一个实例对象，在引用with这个关键字方法时，触发了其内部的__enter__()魔术方法，打开文件，并将文件的句柄返回出来，再由as关键字传给f，完成读取文件内容，或者往文件内写入内容后，再触发__exit__()这个魔术方法，将文件关闭；

其中__exit__()方法的参数exc_type表示异常类型，exc_val表示异常值，exc_tb表示异常回溯追踪

自定义一个读取数据库数据的上下文管理器：

import mysql.connector
class DB:
    def __init__(self,config):
        self.cnn = mysql.connector.connect(**config)
        self.cursor = self.cnn.cursor()

    def __enter__(self):
        return self.cursor

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.cursor.close()
        self.cnn.close()

config = dict(
    host = "localhost",
    user = "root",
    password = "mysql",
    database = "test",
    port = 3306,
    charset = "utf-8")
with DB(config) as f:
    f.execute("select * from username;")
    print(f.fetchone())

5、算术运算的魔术方法__add__,__sub__等

以__add__方法为例，其他方法类似：

class MyAdd(object):
    def __init__(self,data):
        self.data = data

    def __add__(self, other):
        print(self.data)
        print(other.data)
        # print(self+other)  切记不能这样写，这样写会变成一个死循环，因为self和other都是实例对象，如果外部再写一个加法运算：d+f，那么会无限执行上面打印的那两行代码
        return self.data+other.data
d = MyAdd("D")
f = MyAdd("F")
print(d + f)

执行结果为:
D
F
DF

重写__add__魔术方法要注意：

self和other这两个参数都为实例对象，不能在__add__方法内部写self+other；

如上面的例子：d+f，是d触发的__add__这个方法，相当于d.__add__(f)

6、