特殊方法（双下方法）

__str__:如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

class A:
    def __init__(self):
        pass
    def __str__(self):
        print(666)
        return '太白'
a = A()
# print(a)
ret = '姓名：%s' % a
print(ret)

 

__repr__

class A:
    def __init__(self):
        pass
    def __repr__(self):
        return '太白'
a = A()
print(repr(a))  #和下面的一样 返回的都是 太白
print('%r'%a)  #和下面的一样 返回的都是 太白

__call__  ***

class Foo:

    def __init__(self):
        pass

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

obj = Foo()
obj('WuSir', 'alex')  # 对象()就会触发 __call__()方法

__new__
如果对象比喻成一个孩子，那么__new__就相当于她妈，__init__就相当于他爸，给对象穿衣服。

如果这样写，这个对象产生不了。这里面的__new__把我object的__new__给覆盖掉了。

这个结果是None，这样没有什么意义。

 

# 讨论的 __init__  __new__ 先后顺序
class A:
    def __init__(self):
        self.x = 1
        print('in init')

    def __new__(cls, *args, **kwargs):
        print('in __new__')
        return object.__new__(cls)

obj = A()
print(obj.x)

 

 

设计模式：单例模式

# 设计模式：单例模式：让一个类的实例化对象有且只有一个。 ***

class A:
    pass
ret = A()
ret1 = A()
print(ret, ret1)

# 单例模式设计模式有7种，下面只介绍一种：

class A:
    __instance = None #None会内存单独开一个空间，所有的空字典、空列表、空元祖都会统一指向这个空间，为了节省内存。
    def __new__(cls, *args, **kwargs):
        if cls.__instance is None: #cls就是A类
            obj = object.__new__(cls)
            cls.__instance = obj
        return cls.__instance

ret1 = A()
ret2 = A()
ret3 = A()
print(ret1, ret2, ret3)  #结果都是一个内存地址：<__main__.A object at 0x000001FBC1A18CC0>

 

那么单例模式有什么用呢？

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

 __item__系列 __getitem__  __setitem__ __delitem__ ***

# 对一个对象进行类似于字典的操作，就会触发__item__系列的某个方法。

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

    # def __getitem__(self, item):
    #     # print('__getitem__此方法执行了')
    #     # print(item)
    #     # return self.item  # self.'name'
    #     return self.__dict__[item]
    # def __setitem__(self, key, value):
    #     self.key = value

    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        # self.__dict__.pop(key)
    # def __delattr__(self, item):
    #     print('del obj.key时,我执行')
    #     self.__dict__.pop(item)

f = Foo('alex')
# print(f['name'])
# f['age'] = 25
del f['name']
print(f.__dict__)