内置方法 new-del

__new__ 构造方法生产对象的时候用的 ------单例模式

__del__析构方法在删除一个对象之前用到的 --------归还操作系统资源

class Foo(object):
    def __new__(cls, *args, **kwargs):
        print('in new') # 先执行
        obj = object.__new__(cls)  #self 在这里被创造出来的
        print(obj)           #  <__main__.Foo object at 0x032222B0>
        return obj
    def __init__(self):
        print('init',self)# 后执行   #   init <__main__.Foo object at 0x032222B0>
Foo()

# 实例化一个对象时
# 先开辟一个属于这个对象的空间，并在这个空间存放一个类指针，这时要用的new，
# 如果自己没有new，就用object的new

class A: pass
a1 = A()
a2 = A()    #对象地址不相同，说明有两个实例，不是单例模式
print(a1)   #<__main__.A object at 0x006221D0>
print(a2)   #<__main__.A object at 0x00622230>

# 设计模式 - 单例模式
# 一个类有且只能由一个实例
# 下面就让我们来实现单例模式

class A:
    __flag = None
    def __new__(cls, *args, **kwargs):
        if cls.__flag is None:
            cls.__flag = object.__new__(cls)
            return cls.__flag
    def __init__(self,name=None,age=None):
        self.name = name
        if age:
            self.age = age
a1 = A('alex',84)
# print(a1)
# a2 = A('alex',56)
# print(a2)
a3 = A('alex')
print(a3)          # None
print(a1.age)      # 84

这样做保证了一个类无论被实例化多少次，都只开辟一次空间，第一使用的是同一块内存地址

如果我们想控制实例化的次数呢？

我这里做了控制实例化次数为4，如下

class A(object):

    __flag = []
    __count = 0

    def __new__(cls, *args, **kwargs):
        if cls.__count<4:
            cls.__flag = object.__new__(cls)
            cls.__count+=1
            print(cls.__flag)
        return cls.__flag

    def __init__(self,name,age):
        self.name = name
        self.age = age
    @classmethod
    def getsize(cls):
        return cls.__flag

a1 = A('alex',22)
a2 = A('wangsir',23)
a3 = A('evaj',24)
a4 = A('bg',25)
a5 = A('tb',26)
a6 = A('tb1',262)
print(a5.age)
print(A.getsize())

此时前3次实例化对象地址都是各自是各自的，第4次到第6次实例化的对象地址都是第4个的，但他们的值都是按照第6个实例化对象的值取

如果这么理解不明白的话，换一种说法，前3次都是正常的实例化，第四次开始，就实现了一个单例模式，如果不懂单例模式，可以看看上面

我写的

#python 解释器

# 1.我们主动删除 del obj
# 2.python解释器周期性删除
# 3.在程序结束之前所有内容都需要清空

import time
class A:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __del__(self):
        # 只和del obj语法有关系，在执行del obj之前回来执行一下__del__中内容
        print('执行我了')
a = A('alex',84)
print(a.name)
print(a.age)
del a
# time.sleep(1)
#在所有的代码执行完毕后，所有的值都会被python解释器回收

# import time
# class A:
#     def __init__(self,path,mode='GBK'):
#         self.f = open(path,'w')
#     def __del__(self):
#         '''
#         归还一些错做系统资源的时候使用
#         包括文件网络数据库连接
#         '''
#         self.f.close()
# a = A('userinfo')
# time.sleep(1)