python面向对象——常用内置方法

class Person(): 
    #构造函数
    def __init__(self,name,age=None): 
        self.name=name 
        self.age=age
        self.lists=[1,3,5]
        self.dicts={}
    #打印函数,类似java中的toSring()
    def __str__(self):
        return 'Peason(%s)'%self.name
    #对象的字典表示
    def __dict__(self):
        return {'name':self.name}
    #对象相加
    def __add__(self,obj):
        return self.age+obj.age
    #匹配对象[index]模式
    def __getitem__(self,item):
        return self.lists[item]
    #匹配对象[key]=value模式
    def __setitem__(self,k,v):
        self.dicts[k]=v
        print(self.dicts)
    #匹配del 对象
    def __delitem__(self,k):
        del self.dicts[k]
        print(self.dicts)
    #可迭代对象必须实现
    def __iter__(self):
        return iter(self.lists)
    #在类的对象被执行的时候obj()会执行
    def __call__(self,args,**kwargs):
        print('i was called!%s,%s'%(args,kwargs['b']))
    #在类对象被int()处理时调用
    def __int__(self):
        return self.age


if __name__=='__main__':
    li=Person('lili')
    print(li)
    print(li.__dict__())
    li['score']=100
    li['score2']=200
    del li['score']
    for i in li:
        print(i)
    li(10,b=20)
    li.age=30
    print(int(li))

getattr、setattr、delattr

当使用obj.x = y的时候触发对象的setattr方法，当del obj.x的时候触发对象的delattr方法。
当尝试访问对象的一个不存在的属性时 obj.noexist 会触发getattr方法，getattr方法是属性查找中优先级最低的。
可以重写这3个方法来控制对象属性的访问、设置和删除。
**特别注意：如果定义了getattr，而没有任何代码（即只有pass），则所有不存在的属性值都是None而不会报错,可以使用super().__getattr__()方法来处理**

class Student:
    def __getattr__(self, item):
        print('访问一个不存在的属性时候触发')
        return '不存在'

    def __setattr__(self, key, value):
        print('设置一个属性值的时候触发')
        # self.key = value  # 这样会无限循环
        self.__dict__[key] = value

    def __delattr__(self, item):
        print('删除一个属性的时候触发')
        if self.__dict__.get(item, None):
            del self.__dict__[item]

stu = Student()
stu.name = 'zlw'  # 设置一个属性值的时候触发
print(stu.noexit)  # 访问一个不存在的属性时候触发 , 返回'不存在'
del stu.name  # 删除一个属性的时候触发

enter、exit

这两个方法的重写可以让我们对一个对象使用with方法来处理工作前的准备，以及工作之后的清扫行为。

class db_conn(object):

    def __init__(self, conn_id):
        self.conn = MySqlHook.get_connection(conn_id=conn_id).get_hook().get_conn()
        self.cur = self.conn.cursor()

    def __enter__(self):
        return self.cur

    def __exit__(self, exc_type, exc_value, exc_trace):
        self.conn.commit()
        self.cur.close()
        self.conn.close()

iter、next

这2个方法用于将一个对象模拟成序列。内置类型如列表、元组都可以被迭代，文件对象也可以被迭代获取每一行内容。重写这两个方法就可以实现自定义的迭代对象。

class MyRange():
    def __init__(self,begin,end,step):
        self.begin=begin
        self.end=end
        self.step=step
        self.count=0

    def __iter__(self):
        return self

    def __next__(self):
        if self.begin <self.end:
            self.count=self.begin
            self.begin=self.begin+self.step
            return self.count
        else:
            raise StopIteration('已经到达临界')

if __name__=='__main__':
    ra=MyRange(1,20,3)
    for item in ra:
        print(item)