python 通过创建简单的Vector()对象来深入了解魔术方法

直接上代码

from math import hypot
class Vector:
    def __init__(self,x =0,y=0):
        self.x =x
        self.y = y
    def __iter__(self):
        return (i for i in (self.x,self.y)) #return得是一个个出来的这种迭代器
        # return  [self.x,self.y]报错
    def __repr__(self):#这是给程序员控制台直接输出的
        return "look! Vector(%r,%r)"%(self.x,self.y)
    def __str__(self):#print(v1)显示return
        return "str vector"
    def __abs__(self):
        return hypot(self.x,self.y)#hypot() 返回欧几里德范数 sqrt(x*x + y*y)。
    def __bool__(self):
        return bool(abs(self))
    def __add__(self, other):
        x =self.x +other.x
        y = self.y+other.y
        return Vector(x,y)
    def __eq__(self, other):
        '''
        解决了两个对象 == 进行比较内容的问题
        '''
        if self.x == other.x and self.y ==other.y:
            return True
    def __hash__(self):
        return hash(self.x)*hash(self.y)
        # return 1
    def __mul__(self, scalar):
        if isinstance(scalar,int):
            return Vector(self.x*scalar,self.y*scalar)
        if isinstance(scalar,Vector):
            x = self.x * scalar.x
            y = self.y * scalar.y
            return Vector(x, y)

    def __getattr__(self, item):
        print("getattr")
        return  item + ' is not exits'

    def __setattr__(self, key, value):
        self.__dict__[key] = value

    def __getitem__(self, item):
        print("getitem")

        return self.__dict__[item]

    def __setitem__(self, key, value):
        self.__dict__[key] = value

v1 = Vector(3,4)
v2 = Vector(3,4)
v1_x,v1_y = v1

m ={"X":3}
n = {"X":3}
print(v1.__dict__)
print("m==n:",m==n) #T
print("m is n ", m is n) #F
'''

is 运算符比 == 快，因为is不能重载，所以python不用寻找调用特殊方法，a==b等于a.__eq__(b)
python == 是比较内容， is 是比较是否为同一个对象，就是看内存地址(通过id())，可变类型不可哈希，对于不可变类型相同内容则hash相同，不同内存空间则id不相同（在这里不考虑python解释器的优化）
那么对于对象呢？ == 和 is 
对于python解释器，两个对象之间用“==”， 对于数值类型的数据，只要两个数据大小相等，那么就是相等，但是对于非数值型的数据，比如字符串，python默认去比较两个对象的地址
__eq__对于运算符进行重载，使==不去比较对象的id而是看__eq__ return 的True or False
__hash__ 解决了对象无法hash的问题，如果不自己重写__hash__那么hash(v1)会报错：TypeError: unhashable type: 'Vector'。
__hash__重写后hash(v1) return的就是自定义 __hash__ return 的。
hash()好处比如说利用集合去重
__getattr__ 当通过 对象.属性 发现对象没这个属性就调用这个方法 a =v1.z  因为v1没有z这个属性所以就调用getattr,a 为getattr return的值。
__getitem__ 让对象拥有索引的属性  当通过 对象[属性] 调用,就调用这个方法，。没有就直接报错，
__iter__可以让对象被拆包，遍历'''

print("v1==v2:结果",v1==v2)#可以把eq方法注释起来看看效果，有__eq__为T，无为F
print("v1 is v2",v1 is v2)
print("hash(v1)  hash(v2)",hash(v1),hash(v2))
print("---------------------------------")
print(v1.z)
print(v1["x"])
try:
    print("---------------------------------------------")
    v1["z"]
except Exception as e:
    print("报错",e)

print("----------------------------------")
print(v1+v2)#__add__
print(bool(v1))#__bool__
print(v1*3)
print(v1*v2)
print(abs(v1))
print(format(v1))
print(id(4444),id(4444))#python解释器的优化