面向对象的进阶（item系列，__new__,__hash__,__eq__）

面向对象的进阶（item系列，__new__,__hash__,__eq__）

一、item系列

getitem、setitem、delitem（操作过程达到的结果其实就是增删改查）

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

    def __getitem__(self, item):  # 与f['xx']形式对应
        if hasattr(self, item):
            return self.__dict__[item]

    def __setitem__(self, key, value):  # 与f['xx']='ss'形式对应
        self.__dict__[key] = value

    def __delitem__(self, key):  # 与del f['xx']形式对应
        del self.__dict__[key]

f = Foo('egon',30,'男')
print(f['name'])
#  f['name']---对象['xx']这种形式就会触发前面的__getitem__方法，将name就传给了item
#  支持以这样的方式取得了对象的属性name，正常的是f.name取到属性

f['hobby'] = '男'
# 新增加的key和value，触发__setitem__方法，将对应的属性和值放入原本的字典中
print(f['hobby'], f.hobby)
# 以f['hobby']这样的方式取到新增的属性,原本正常取值f.hobby

# del f.hobby  # 正常的删除方式
# print(f.hobby)  # 此时会报错，显示：AttributeError: 'Foo' object has no attribute 'hobby'

del f['hobby']
# 如果执行到这步，就会显示:AttributeError: __delitem__,显示没有这个方法
# 这个删除方式就触发__delitem__方法，前面类里面就必须得有定义该方法
print(f.__dict__)  # 字典里面就没有hobby的属性了

运行结果：

C:\Users\3-2\PycharmProjects\untitled\venv\Scripts\python.exe C:/Users/3-2/PycharmProjects/untitled/面向对象进阶.py
egon
男 男
{'sex': '男', 'age': 30, 'name': 'egon'}

Process finished with exit code 0

这种用中括号就可以直接调的方式，比如用字典，列表的实现过程，就是内部存在了item系列这个机制的原因

这种用中括号就可以直接调的方式，比如用字典，列表的实现过程，就是内部存在了item系列这个机制的原因
object原生支持__delattr__所以才可以直接del f.hobby而不报错，但是del f['hobby']得通过自己实现，
所以当类方法里面没有__delitem__的时候就会报错

二、__new__

__init__:初始化方法
__new__:构造方法，创建一个对象。self就是__new__构造出来的，即__new__方法是self产生的机制
平时是不需要用到执行__new__方法的，以下例子只是简单说明它是怎么用的：

class A:
    def __init__(self):
        self.x = 1
        print('in init function')
    def __new__(cls, *args, **kwargs):
        # 传入一个默认参数cls，执行__new__方法前还没有self,所以只能传一个类进来
        print('in new function')
        return object.__new__(A,*args,**kwargs)
        # object.__new__创造了一个新的对象，然后将这个对象传给self的位置，所以当执行self的时候就可以使用对象了

a = A()  # 实例化，会先执行__new__方法，再执行 __init__方法

运行结果：

in new function
in init function

Process finished with exit code 0

一个典型的设计模式（23种）：单例模式
单例模式:一个类始终只有一个实例；当第一次实例化这个类的时候就创建一个实例化的对象；当之后再来实例化的时候，
就会用之前创建的对象

# 实现单例模式的例子：

class A:
    __instance = False  # 私有的静态变量 不希望别人可以使用，必须得经过自己的设置
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __new__(cls, *args, **kwargs):
        if cls.__instance:  # 如果为真就执行下面代码,否则执行后面的代码
            # 第二次进来的时候就符合这个了
            return cls.__instance  # 第二次进来就直接将之前创建的对象返回给self了
        cls.__instance = object.__new__(A)
        # 因为第一次进来的时候就是__instance = False，所以执行这行代码代码
        # 用object.__new__创建一个类A的新的对象，并且赋值给 cls.__instance
        return cls.__instance  # 这里就是将新建的对象return回去

egon = A('egg',38)
# 真正能实例化对象并且占用内存的是object里面的self,但是这里使用的对象始终是object.__new__创建的，
# 因为自己就有对象了，就不会去使用object里面的了
# 反正能够实现单例化的原因是__new__方法的使用
egon.cloth = '小花袄'
nezha = A('nazha',25)
nezha.shoes = '小白鞋'
print(nezha)
print(egon)
# 执行到这里根据运行结果显示内存地址是同一个，也就是说第二次实例化的时候是在对第一个实例化后的
# 对象进行操作的，而并没有再次创建另一个占内存的对象，如果第二次实例化传的参数和原对象一致，
# 参数值就会进行覆盖，如果第二次实例化传的参数只是原属性的一部分，则相同的覆盖，原来的继续会
# 在表现在现有对象中
print(nezha.name)
print(egon.name)
# 执行到这里原来egon的名字已经被nezha覆盖了
print(nezha.cloth)
# 执行到这里原来egon的cloth会继续穿在nezha上

运行结果：

<__main__.A object at 0x0000025C0C2293C8>
<__main__.A object at 0x0000025C0C2293C8>
nazha
nazha
小花袄

三、__hash__

# 在没有定义__hash__方法的时候，hash都是针对内存地址的，而不是针对对象属性，内存地址不一样，hash的结果也不一样 

class A: 
　　def __init__(self,name,sex): 
　　　　self.name = name 
a = A('egn','男') 
b = A('egon','nv')
print(hash(a)) 
print(hash(b))

运行结果：

154259419512
154259419617

# 定义了—__hash__方法后，属性不同hash值也会不同，属性相同hash值也会相同：
class A:
    def __init__(self,name,sex):
        self.name = name
        self.sex = sex
    def __hash__(self):
        return hash(self.name+self.sex)

a = A('egon','男')
b = A('egon','男')
c = A('egon','nv')
print(hash(a))
print(hash(b))
print(hash(c))

运行结果：

8385798543724353936
8385798543724353936
-7270162062837990016

四、__eq__

没有__eq__方法的时候，两者比较是比较内存地址：
class A:
    def __init__(self,name):
        self.name = name

obj1 = A('egg')
obj2 = A('egg')
print(obj1 == obj2)
# 没有定义__eq__方法的时候，比较时候默认比较内存地址，上面两个内存地址是不一样的

运行结果：

False

# 定义__eq__方法时可以自己设定执行内容,‘==’触发的_eq_方法
class A:
    def __init__(self,name):
        self.name = name

    def __eq__(self, other):
        if self.name == other.name:
            return True
        else:
            return False

obj1 = A('egg')
obj2 = A('egg')
obj3 = A('EGG')
print(obj1 == obj2)  # 等号触发的__eq__
print(obj2 == obj3)  # 等号触发的__eq__

运行结果：

True
False

Process finished with exit code 0