类的内置方法及单例模式

一、类的内置方法

类的内置方法(魔法方法):
　　凡是在类内部定义，以__开头__结尾的方法，都是类的内置方法，也称之为魔法方法。

　　类的内置方法，会在某种条件满足下自动触发。

1.__new__:

条件: 在__init__触发前，自动触发。

# 条件: __init__: 在调用类时自动触发。
    def __init__(self):
        print('执行__init__')
# 条件: __new__: 在__init__触发前，自动触发。
    def __new__(cls, *args, **kwargs):
        print('执行__new__')
        # python内部通过object调用内部的__new__实现产生一个空的对象  ---> 内存地址
        return object.__new__(cls, *args, **kwargs)

obj = Demo()
# 输出：
执行__new__
执行__init__

2.__init__:

条件: 在调用类时自动触发。

1 # 条件: __init__: 在调用类时自动触发。
2     def __init__(self):
3         print('执行__init__')
4 obj = Demo()

3.__getattr__:

条件: 在 “对象.属性” 获取属性时，若 “属性没有” 时触发。

    # 条件: __getattr__: 在 “对象.属性” 获取属性时，若 “属性没有” 时触发。
    def __getattr__(self, item):
        print('执行__getattr__')
        # return 想要返回的值
        return item

4.__getattribute__:

条件: 在 “对象.属性” 获取属性时，无论 "属性有没有" 都会触发。

注意: 只要__getattr__ 与 __getattribute__ 同时存在类的内部，只会触发__getattribute__。

    # 条件: __getattribute__: 在 “对象.属性” 获取属性时，无论"属性有没有"都会触发。
    def __getattribute__(self, item):
        #     print('执行__getattribute__')
        print(self.__dict__)   # 注意: 此处不能通过 对象.属性，否则会产生递归调用，程序崩溃
    # 注意: 只要__getattr__与__getattribute__同时存在类的内部，只会触发__getattribute__。

5.__setattr__:

条件:  当 “对象.属性 = 属性值” , 添加或修改属性时触发

    # 条件: __setattr__: 当 “对象.属性 = 属性值”, 添加或修改属性时触发
    def __setattr__(self, key, value):      # key---> 对象.属性名  value ---》 属性值
        print('执行__setattr__')
        # print(key, value)
        # self.key = value      # 出现递归
        # 此处是对 对象的名称空间 ---》 字典进行操作
        self.__dict__[key] = value
        print(self.__dict__)

6.__call__:

条件:  在调用对象 “对象 + ()” 时触发。

    # 条件: __call__: 在调用对象 “对象 + ()” 时触发。
    def __call__(self, *args, **kwargs):
        print('执行__call__')
        return  self

7.__str__:

条件:  在打印对象时触发。
注意: 该方法必须要有一个 “字符串” 返回值。

    # 条件: __str__: 在打印对象时触发。
    def __str__(self):
        print('执行__str__')
        return '123'
        # list1 = list([1, 2, 3, 4])
        # print(list1)   --->   return [1, 2, 3, 4]
    # 注意: 该方法必须要有一个 “字符串” 返回值。

8.__getitem__:

条件:  在对象通过 “对象[key]” 获取属性时触发

    # 条件: __getitem__: 在对象通过 “对象[key]” 获取属性时触发
    def __getitem__(self, item):
        print(item)
        print('执行__getitem__')

9.__setitem__:

条件:  在对象通过 “对象[key]=value值” 设置属性时触发。

    # 条件: __setitem__: 在对象通过 “对象[key] = value值” 设置属性时触发。
    def __setitem__(self, key, value):
        print('执行__setitem__')
        print(self.__dict__)
        self.__dict__[key] = value
        print(self.__dict__)

二、单例模式

单例模式:
　　指的是在确定 "类中的属性与方法" 不变时，需要反复调用该类，产生不同的对象，会产生不同的内存地址，造成资源的浪费。

让所有类在实例化时，指向同一个内存地址，称之为单例模式。 ----> 无论产生多个对象，都会指向单个实例。

- 单例的优点:
　　节省内存空间。

单例模式: 
　　1.通过classmethod
　　2.通过装饰器实现
　　3.通过__new__实现
　　4.通过导入模块时实现
　　5.通过元类实现。

HOST = '192.168.0.1'
PORT = 1124


class MySQL:

    single_obj = None

    def __init__(self, host, port):
        self.host = host
        self.port = port

    @classmethod
    def singleton(cls, host, port):    # 单例方法 ---> 类方法
        # 判断single_obj中若没有值，证明没有对象
        if not cls.single_obj:
            # 产生一个对象并返回
            obj = cls(host, port)
            # None ---> obj
            cls.single_obj = obj

        # 若single_obj中有值，证明对象已经存在，则直接返回该对象
        return cls.single_obj

    def start(self):
        print('启动MySQL')

    def close(self):
        print('关闭MySQL')


obj1 = MySQL.singleton(HOST, PORT)
print(obj1.host)
obj2 = MySQL.singleton(HOST, PORT)
print(obj2.port)