# 构造方法 创建一个对象的

# 初始化方法 __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 一个对象

# 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的内存中,只能有一个实例

# 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'

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__ 方法的执行是由对象后加括号触发的，即：对象() 或者 类()()

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

执行我了 aaa

# 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__方法