Day 28面向对象的进阶-内置函数（__new__,__del__）

 元类 创造 类  所有类的type 都是他的元类

类创造 对象   具体创造对象的方法 __new__方法

class 类名（classmata = type）#默认是

class 类名（classmeta =元类名）

一、__del__方法

# 构造方法 创建一个对象的
# 初始化方法 __init__ 给已经创建出来的对象添加属性
# 析构方法 删除一个对象的时候调用的方法
import time
class A:
    def __init__(self):
        self.f = open('userinfo','a')
    def consume(self):
        pass
    def __del__(self):
        '''在删除一个对象之前做一些收尾工作'''
        self.f.close()
        print('删除一个对象的时候调用我')

a = A()
time.sleep(1)
del a
# 删除一个对象的时候,如果内部存在__del__方法,
# 那么在删除一个对象之前先执行__del__方法中的代码
print(a)

 

二、__new__构造方法

#new 一个对象
# object.__new__()
class A:
    def __init__(self):
        print('执行init方法了')
    def __new__(cls):
        print('执行new方法了')
        return object.__new__(cls) #创造对象，将对象返回。

a =A()
# 结果：
# 执行new方法了
# 执行init方法了
print(type(a))
print(type(A))
#先执行__new__方法，创造出一个对象。
#然后把创造出来的对象传递给__init__方法.
#会把self自动的返回，被a接收.

#元类
#有一个元类 在创建类
# type()所有直接用class创建出来的类的元类都是type
class 类名(B,classMeta =元类名)
class 类名(B,classmeta =type) #默认
#元类 创造 类  所以所有的类的type都是他的元类，默认是type
#类 创造 对象  具体创造对象的方法__new__方法，所有的对象的type
#都是他的对应的

三 、单例模式

一个类可以被多次实例化 ，但是同一时间在python的内存中，只能有一个实例.

一个类 可以被多次实例化 但是同一时间在python的内存中,只能有一个实例
# class A:
#     _instance = None
#     def __init__(self,name):
#         '''给娃穿衣服'''
#         self.name = name
#     def __new__(cls, *args, **kwargs):
#         '''生娃的过程'''
#         if not A._instance:
#             A._instance = object.__new__(cls)
#         return A._instance
# a1 = A('alex')  # 第一次实例化的时候创造一个实例
# print(a1.name)
# a2 = A('egon')
# print(a1.name,a2.name)  # 'alex' 'alex'

# class A:
#     def __init__(self,name):
#         '''给娃穿衣服'''
#         self.name = name
#     def __new__(cls, *args, **kwargs):
#         '''生娃的过程'''
#         if not hasattr(A,'_instance'):
#             A._instance = object.__new__(cls)
#         return A._instance
# a1 = A('alex')  # 第一次实例化的时候创造一个实例
# print(a1.name)
# a2 = A('egon')
# print(a1.name,a2.name)  # 'alex' 'alex'

# class A:
#     name = 'Alex'
#
#     @classmethod
#     def func(cls):
#         pass
#
# A.name = 'Egon'

四、 item系列 

class A:
    def __init__(self,name):
        self.name =name
        self.age =81
    def __getitem__(self, item):
        return  self.__dict__[item]
    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        del self.__dict__[key]

a =A('alex')
print(a['name']) #对应了类中一个方法的语法
print(a.name)#同上
print(a['age'])#对于了类中一个方法的语法
print(a.age)#同上
# 增加和修改一个属性
a['sex']= '不详'
# print()
print(a.__dict__)
print(a.sex)
print(a['sex'])
a['sex']='女'
print(a.__dict__)
del a['sex']
print(a.__dict__)

五、__call__方法

对象后面加括号，触发执行。

注：构造方法的执行是由创建对象触发的，即：对象 = 类名() ；而对于 __call__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

class  A:
    def __call__(self,a):
        print('执行我了',a)
    def call(self,a):
        print('执行了我',a)
A()('aaa')
# a =A()
# a('aaa')# __call__
结果 ：

执行我了 aaa

六、__hash__方法

# hash
# 不可变的数据类型都可以被hash
class A:pass
    # def __hash__(self):
    #     return 1
a = A()
b = A()
print(hash(a))   # object.__hash__()
print(hash(a))   # object.__hash__()
print(hash(a))   # object.__hash__()
print(hash(a))   # object.__hash__()
print(hash(a))   # object.__hash__()
print(hash(a))   # object.__hash__()
print(hash(a))   # object.__hash__()
print(hash(b))   # object.__hash__()

# dict的key   set的元素
# dic  key --> value
# dic[key] = value

# hash(obj)函数,obj对象对应的类必然内部实现了__hash__方法
# hash的结果就是__hash__方法的返回值
# 且在一次成的执行过程中是不会发生变化的
# 且要想作为字典的key或者作为集合的元素,这个对象对应的类必须实现__hash__方法