python魔术方法(一)

所谓的魔术方法就是让用户客制化类的方法，常常是python中开头有两个下划线的方法。

__new__()

new是创建一个类的过程

class A:
	def __new__(cls,x):
		print("__new__")
        return super().__new__(cls)

由于new函数是建立了一个对象，所以必须返回一个对象

__init__()

init是初始化一个类的过程

class A:
	def __new__(cls,x):
		print("__new__")
        return super().__new__(cls)
    
    def __init__(self,x):
    	print("__init__")

这个我们就很常用了

__del__

对象被释放的时候你想做什么，但是吧，python的释放是一个复杂的机制，由解释器控制的，也许这个对象被引用到0的时候被释放了，也有可能被垃圾回收机制释放了，而且这个释放可能在任意地方发生，这个释放是不受控制的，

class A:
	def __new__(cls,x):
		print("__new__")
        return super().__new__(cls)
    
    def __init__(self,x):
    	print("__init__")
    	
    def __del__(self):
    	print("__del__")
    	

这个__del__函数和关键字del没什么关系，del只是让对象少一个引用。

__repr__

返回对象的字符串表示

class A:
	def __repr__(self):
		return "A repr"
    
print(repr(A()))

__str__

返回对象的字符串表示，与上面的方法不同的点在于，本方法更多的是返回人类更好理解的信息，上一个方法返回的信息更为详细复杂。

class A:
	def __repr__(self):
		return "A repr"
print(str(A()))

如果我们没有定义这个函数，直接去调用呢，也可以，因为python会自动的调用 __repr__的返回值。

__format__

当你尝试用某种格式来打印一个类的时候就会用到这个函数

class A:
	def __format__(self,spec):
		if spec == "x":
			return "0xA"
		return "A"
    
print("{}".format(15))
print("{:b}".format(15))
print("{:x}".format(15))

print("{A()}")
print("{A():x}")

__bytes__

class A:
	def __bytes__(self):
		print("__bytes__called")
		return bytes([0,1])

print(bytes(A()))

当你尝试用自己类去建立一个bytes的时候，他应该返回什么，其实除非是客制化一个类的bytes表示，否则也是用不上的。

__eq__

改变比较的逻辑，判断两个对象是否相等

class Date:
	def __init__(self,num):
		self.num = num
	
	def __eq__(self,others):
		return self.num == other.num

为什么不能直接判断呢？，就像下面这样

class Date:
	def __init__(self,num):
		self.num = num

a = Date(1)
b = Date(1)
print(a == b)

因为如果没定义这些方法的话，a == b就会被翻译为 a is b ，这样的话就是比较两个对象的地址是否相等。咦~~，是不是有点像运算符重载。

而且理论上是不是比较方法必须返回bool值，但是python是没有对这个做任何限制的，你可以返回任何东西。这个有什么用呢，如果你比较两个向量的话，就可以返回一个向量，这个向量表示对应位置的值是否相等。

__ne__

如果我们没有单独的定义不等的魔术方法的话，python会将__eq__的结果取反

class Date:
	def __init__(self,num):
		self.num = num
	
	def __ne__(self,others):
		return self.num != other.num

__gt__

等于或者不等于是有默认实现的，如果我们没有定义的话就会调用 is，但是大于小于就没有默认调用了

class Date:
	def __init__(self,num):
		self.num = num
	
	def __gt__(self,others):
		return self.num > other.num

这里有个有趣的事情

a = Date(2)
b = Date(3)
print(a < b)

返回了结果True，不对啊，这个类没有小于的方法啊，其实这里我们的python又默认了大于和小于是一对，这里就调用了 b.__gt__(a)。因为在语义上a小于b和b大于a是一致的。

__lt__

小于函数，这里的优先级大于上面我们讲的默认大于。

class Date:
	def __init__(self,num):
		self.num = num
	
	def __lt__(self,others):
		return self.num > other.num

但是但是但是！！！这个优先级是一定的嘛？并不是，如果我们比较的不是同一个类的话，那我们就会遇到麻烦，啥？比较的还能不是同一个类？？是的，通过继承可以有衍生类啊，如果是和衍生类进行比较的话，优先调用的就父类。大部分情况下就是调用左边的那个类的方法，左边没有就是右边的，如果右边的类是左边的类的子类，那么就优先室友右边的类的函数。

__ge__

大于等于，大体和上面一致，python中不会对大于等于这个运算做任何推测

__le__

小于等于，大体和上面一致，python中不会对大于等于这个运算做任何推测

__hash__

hash散列函数有自己的默认实现，如果我们需要客制化才需要用hash函数。hash的基本定义在于两个类如果相等那么这两个类的hash必然相等。

这个函数要求必须返回一个整数，而且两个对象相等的话他们的hash值必须相等。

class A:
	def __init__(self,num1,num2):
		self.num1 = num1
		self.num2 = num2
	
	def __hash__(self):
		return 2

上面这个方法是可以的，但是很蠢，因为会造成非常严重的哈希碰撞。可以通过把对象的核心属性组成一个tuple的方式，求tuple的hash值作为对象的hash值。

class A:
	def __init__(self,num1,num2):
		self.num1 = num1
		self.num2 = num2
	
	def __hash__(self):
		return hash((self.num1,self.num2))

__bool__

调用对象的bool方法的默认方法。

class A:
	def __init__(self,num1,num2):
		self.num1 = num1
		self.num2 = num2
	
	def __bool__(self):
		if self.num1 > 10:
			return True

a = A(11)
if a :
    print("OK")