Python魔术方法详解-优快云博客

本文链接：https://blog.youkuaiyun.com/shunjianxaioshi/article/details/129318682

魔术方法

魔术方法就是一个类中的方法，和普通方法唯一的不同是普通方法需要调用，而魔术方法是在特定时刻自动触发。
这些魔术方法的名字特定，不能更改，但是入口参数的名字可以自己命名。

基本魔术方法

new(cls[,…])

_new_ 是在一个对象实例化的时候所调用的第一个方法，而不是init，new方法返回的是对象

init(self[,…])

构造器，当一个实例被创建的时候调用的初始化方法

del(self)

构造器，当一个实例被销毁的时候调用的方法

call(self,[,args…])

允许一个类的实例像函数一样被调用：x(a,b) 调用 x.call(a,b)，如果没有__call__函数，不能把实例像函数一样调用，而要用x.function(a,b)调用实例x的实例化方法

len(self)

定义当被len()调用时的行为

class Foo(object):
    # __new__是一个魔术方法，并且是实例化对象时第一个调用的方法，返回的结果是实例化对象。
    def __new__(cls,*agrs,**cwds):
        print('调用__new__方法')
        inst = object.__new__(cls,*agrs,**cwds)
        print(inst)                       # 返回的是一个对象
        return inst 
    
    # __init__的第一个参数self是__new__魔术方法返回的结果
    def __init__(self,price = 50):
        print('调用__init__方法')
        print(self)                       # self是__new__方法返回的东西，因此self命名为其他名称也可以接受__new__返回的对象
        self.price = price
        
    def how_much_of_book(self,n):
        print('调用how_much_of_book方法')
        print(self)
        return self.price * n

	def __call__(self,m,n):
        print('调用__call__方法')
        self.how_much_of_book(n)          # 类里面可以随便这样调用其他方法
        return self.price * n


foo = Foo()                               # 实例化Foo()返回一个对象
print(foo.how_much_of_book(8))
print(foo(3,2))                          # 如果没有__call__(self,m,n)，foo()会报错，只能通过foo.function来调用

# 调用__new__方法
# <__main__.Foo object at 0x00000230D9AA2070>
# 调用__init__方法
# <__main__.Foo object at 0x00000230D9AA2070>
# 调用how_much_of_book方法
# <__main__.Foo object at 0x00000230D9AA2070>
# 400
# 调用__call__方法
# 调用how_much_of_book方法
# <__main__.Foo object at 0x00000230D9AA2070>
# 100

比较的魔术方法

_cmp_(self,other)

是比较方法里面最基本的魔术方法，它实际上实现了所有的比较符号(<,==,!=,etc.)。__cmp__方法是你想要实现所有的比较符号而一个保持清楚明白的一个好的方法。但是通常最好的一种方式是去分别定义每一个比较符号而不是一次性将他们都定义。

_eq_(self,other) 定义相等符号的行为，==
_ne_(self,other) 定义不等于符号的行为，!=
_It_(self,other) 定义小于符号的行为，<
_gt_(self,other) 定义大于符号的行为，>
_le_(self,other) 定义小于相等符号的行为，<
_ge_(self,other) 定义大于相等符号的行为，>=

class new_list:
    def __init__(self,a):
        self.a = a
    
    # 实例化方法比较两个实例大小
    def gt(self,other):    
        list1 = list(filter(lambda x:type(x)==int,self.a))
        list2 = list(filter(lambda x:type(x)==int,other.a))
        
        if sum(list1)>sum(list2):
            return True
        else:
            return False
    
    
    # 魔术方法比较两个实例大小
    def __gt__(self,other):    # 如果类中没有 def __ge__()这个魔术方法，那么 print(object1 > object2) 就会报错
        list1 = list(filter(lambda x:type(x)==int,self.a))
        list2 = list(filter(lambda x:type(x)==int,other.a))
        
        if sum(list1)>sum(list2):
            return True
        else:
            return False

list1 = new_list([1,2,3,22222,'sdd','da','dasdas'])
list2 = new_list([23,'3213',232,'qdv'])
list3 = new_list([1,21,3,22,99999,'sdd','da','dasdas'])

print(list1 > list2)          # 魔术方法比较
print(list1 > list3)          # 魔术方法比较
print(list1.gt(list2))        # 实例化方法比较
print(list1.gt(list3))        # 实例化方法比较
print(list3 > list1 > list2)  # 第一个大于符号会触动一下魔术方法，第二个大于符号也会触动一下魔术方法
print(list1 > list2 > list3)

# True
# False
# True
# False
# True
# False

	def __init__(self,a,b):
        self.a = a
        self.b = b
        
    def __str__(self):  # __str__定义当被str()调用时的行为
        return str(self.a + self.b)

object2 = A(3,4)       # 实例化对象

print(str(object2))    # 如果没有__str__魔术方法，打印的实例化对象的地址，有__str__魔术方法，该语句相当于调用 print(object2.__str__())

容器类型的魔术方法

_len_(self) 定义当被len()调用时的行为，返回容器中元素的个数
_getitem_(self，key) 定义获取容器中指定元素的行为，相当于self[key]
_setitem_(self,key,value) 定义设置容器中指定元素的行为，相当于self[key] = value
_delitem_(self,key) 定义删除容器中指定元素的行为，相当于del self[key]
_iter_(self) 定义当迭代容器中的元素的行为
_reversed_(self) 定义当被reversed()调用时的行为
_contains_(self,item) 定义当使用成员测试运算符(in 或 not in)时的行为

class NewDataType:
    def __init__(self,data):
        self.data = data
    
    def __len__(self):
        return len(self.data)
        
    def __getitem__(self,key):
        return self.data[key]
        
object1 = NewDataType(['1','2','4',33,44])  # 实例化对象时是否传入参数，根据init来定
print(len(object1))
# 5

print(object1[-1])
for i in object1:   # 如果没有__getitem__(self,key)，无法进行遍历的
    print(i)

# 44
# 1
# 2
# 4
# 33
# 44

class MyIter:
    def __init__(self,total,start=0):
        self.total = total
        self.start = start
    
    def __iter__(self):
        return self
        
    def __next__(self):    # 既可以通过for循环访问也可以通过 next()方法访问
        if self.start < self.total:
            self.start += 1
            return self.start
        else:
            raise StopIteration
    
myIter = MyIter(3)
it1 = iter(myIter)   # 这个函数触发 __iter__(self):
for i in it1:  
    print(i)

myIter = MyIter(4)   # 必须要再实例化对象一次，才能调用 it2 = iter(myIter)，不能直接调用 it2 = iter(myIter)
it2 = iter(myIter)   # 这个函数触发 __iter__(self):
print(next(it2))
print(next(it2))
print(next(it2))

# 1
# 2
# 3
# 1
# 2
# 3