元类 创造 类 所有类的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__方法