Python入门之面向对象编程(三)Python类的魔术方法

class Special:
    '''描述类的信息，__doc__返回放在这里的字符串结果'''
    
    __slots__ = ('name', 'age','__weight') # 限制属性的取值
    
    def __init__(self, name, age, weight):
        self.name = name
        self.age = age
        self.__weight = weight
    
    def __call__(self, content): # 定义 实例() 会返回什么结果
        print(content)
        
    def __str__(self): # 定义打印实例会返回什么结果
        return 'Special object (name:%s)' % self.name
    
    __repr__ = __str__  # 这样简单赋值即可
    
    def __len__(self): # 定义len函数返回的结果
        return len(self.name)
    
    def __eq__(self, num): # 实例和数字比
        return len(self.name) == num
    
    def __gt__(self, other): # 这样可以实现实例和实例比
        return len(self.name) >= len(other)
    
    def __getattr__(self, attr):
        if attr=='score':
            return "You can't see the score"

s = Special("Bob", 5, 4)
# s.hobby = "running" # 报错，因为__slots__限制了属性取值
s.__doc__ # 返回类定义时下方写的字符串描述内容
# '描述类的信息，__doc__返回放在这里的字符串结果'
s("__call__ is used") # 调用了__call__
# __call__ is used
print(s) # 调用__str__
# Special object (name:Bob)
s # 调用__repr__
# Special object (name:Bob)
len(s) # 调用了__len__
# 3
s==3 # 调用了__eq__
# True
Special("Mary", 4,5) > Special("Bob",5,4) # 调用__gt__
# True
s.score # 无score参数，调用__getattr__
# "You can't see the score"

s.__dict__ # 要把__slots__注释掉才能看见属性的字典
# {'_Special__weight': 4, 'age': 5, 'name': 'Bob'}
s.__module__ # 查看所属模块
# '__main__'
s.__class__ # 查看所属类
# __main__.Special
dir(s) # 返回实例的所有属性和方法，调用了__dir__()方法

class Ite1:
    
    def __init__(self, a):
        self.a = a
        
    def __iter__(self):
        return iter(range(2*self.a)) # iter函数将一个可迭代对象变成迭代器
     
i1 = Ite1(3)
for i in i1:
    print(i) # 0到 5

class Ite2:
    
    def __init__(self, a, b):
        self.a = a
        self.b = b
        
    def __iter__(self):
        return self
    
    def __next__(self):
        self.a += 1
        if self.a > self.b+1: # 条件成立则迭代器结束
            raise StopIteration()
        return self.a-1
    
for i in Ite2(2,5):
    print(i) # 返回2-5

class Index1:
    
    def __getitem__(self, index):
        return 2*index # 如果定义和__next__中内容类似则实现既可以循环又可以[]取值了
    
i = Index1()
i[2] # 4

class Index2:
    
    def __init__(self,**kw):
        self.dict = kw 
            
    def __getitem__(self, key):
        return self.dict[key]
    
    def __setitem__(self, key, value):
        self.dict[key] = value
        
    def __delitem__(self, key):
        del self.dict[key]
        
i = Index2(name="Bob")
i['name'] # 'Bob'
i['age'] = 13
i['age'] # 13
del i['age']
# i['age'] #报错，删掉就没有这个属性了

class Manager:
    
    def __init__(self, text):
        self.text = text
    
    def __enter__(self):
        self.text = "It has started " + self.text
        return self # 还是让这个类的实例进行下面的处理
        
    def __exit__(self, ex_type, ex_value, ex_tb):
        self.text = "It is over"
        
        
with Manager("machine") as m:
    print(m.text)
    
print(m.text) # as定义的m仍然可以调用
# It has started machine
# It is over
# 发现最后执行了__exit__ 把这个属性改变了

class DemoManager:

    def __enter__(self):
        pass

    def __exit__(self, ex_type, ex_value, ex_tb):
        if ex_type is IndexError:
            print(ex_value.__class__)
            return True
        if ex_type is TypeError:
            print(ex_value.__class__)
            return  # return None

# 下面故意制造两种错误
with DemoManager() as nothing:
    data = [1, 2, 3]
    data[4]  # raise IndexError, 该异常被__exit__处理了

with DemoManager() as nothing:
    data = [1, 2, 3]
    data['a']  # raise TypeError, 该异常没有被__exit__处理