Python面向对象进阶之高级编程

dyok

　　__slots__：定义类时，使用__slots__变量可以限制能添加的实例的属性
　　形如：__slots__ = ['name','age']
　　这样实例化的对象只能绑定到name和age属性，其他属性则无法被绑定
class People:　　
    __slots__ = ['name','age']
　　
    def __init__(self,name,age):
　　
        self.name = name
　　
        self.age = age
　　
p = People('laowang',18)
　　
print(p.name)
　　
p.sex = 'male'
　　
print(p.sex)
　　执行结果：
laowang　　

　　
Traceback (most recent call last):
　　

　　
  File "C:/", line 43, in <module>
　　

　　
    p.sex = 'male'
　　

　　
AttributeError: 'People' object has no attribute 'sex'
　　可以看出name属性初始化成功并且可以访问，但是sex属性无法添加
　　__call__方法：只要定义类型的时候，实现__call__函数，这个类型就成为可调用的
class People:　　
    def __init__(self,name):
　　
        self.name=name
　　
    #
　　
    def __call__(self, *args, **kwargs):
　　
        print('call')
　　
    #
　　
p=People('egon')
　　
print(callable(People))
　　
print(callable(p))
　　
p()
　　执行结果为：
　　True
　　True
　　call
　　意味着People及其产生的对象均为可调用的，并且:对象()会执行__call__方法
　　__getitem__、__setitem__、__delitem__方法：提供以字典的方式操作对象属性
class Foo:　　
    def __init__(self,name):
　　
        self.name=name
　　
    def __getitem__(self, item):
　　
        # print('getitem',item)
　　
        return self.__dict__[item]
　　
    def __setitem__(self, key, value):
　　
        print('setitem-----<')
　　
        self.__dict__[key]=value
　　
    def __delitem__(self, key):
　　
        self.__dict__.pop(key)
　　
        # self.__dict__.pop(key)
　　
    # def __delattr__(self, item):
　　
    #     print('del obj.key时,我执行')
　　
    #     self.__dict__.pop(item)
　　
f=Foo('egon')
　　
f['name']='egon'
　　
print(f.name)
　　
f['age']=18
　　
print(f.__dict__)
　　
del f['age']
　　__iter__、__next__方法：可以实现一个迭代器协议，类定义中加入这两个方法可以将类实例化的对象变为可迭代的对象
　　需要注意下的就是__next__中必须控制iterator的结束条件，不然就死循环了
　　下例利用此原理实现了一个简单的range（）函数的功能
class Range:　　
    def __init__(self,start,stop):
　　
        self.start = start
　　
        self.stop = stop
　　
        pass
　　
    def __iter__(self):
　　
        return self
　　
    def __next__(self):
　　
        if self.start >= self.stop:
　　
            raise StopIteration
　　
        n = self.start
　　
        self.start += 1
　　
        return n
　　

　　
for i in Range(1,10):
　　
    print(i)
　　__del__方法：析构函数，当对象在内存中被释放时，自动触发执行
　　注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class Open:　　
    def __init__(self,filepath,mode='r',encode='utf-8'):
　　
        self.f=open(filepath,mode=mode,encoding=encode)
　　
    def write(self):
　　
        pass
　　
    def __getattr__(self, item):
　　
        return getattr(self.f,item)
　　
    def __del__(self):
　　
        print('----->del')
　　
        self.f.close()
　　
f=Open('a.txt','w')
　　
f1=f
　　
del f
　　
print('=========>')
　　__enter__、__exit__方法：实现上下文管理协议，即with语句，这个跟文件操作时使用with语句一样：
with open('filepath/filename','r',encoding='utf-8') as f:　　
        '代码块'
　　在类定义时定义__enter__、__exit__方法可以让类产生的对象使用with语句
class Foo:　　
    def __enter__(self):
　　
        print('=====》enter')
　　
        return self
　　
    def __exit__(self, exc_type, exc_val, exc_tb):
　　
        print('exit')
　　
        print('exc_type',exc_type)
　　
        print('exc_val',exc_val)
　　
        print('exc_tb',exc_tb)
　　
        return True
　　

　　
with Foo() as obj: #res=Foo().__enter__() #obj=res
　　
    print('with foo的自代码块',obj)
　　
    raise NameError('名字没有定义')
　　
    print('************************************')
　　
print('------>')
　　__exit__()中的三个参数分别代表异常类型，异常值和追溯信息,with语句中代码块出现异常，则with后的代码都无法执行，但是__exit__如果有返回值，则with语句块之外的代码可以正常执行
　　__str__方法：当类的方法被调用时，会调用此方法返回一个字符串（为了好看与打印相关重要信息）
　　元类：
　　关于元类的详细讲解可参阅此文：深刻理解Python中的元类(metaclass)