Python 面向对象高级

一 isinstance(obj,cls)和issubclass(sub,super)

isinstance(obj,cls)检查是否obj是否是类 cls 的对象

class Foo(object):
     pass 
obj = Foo() 
     isinstance(obj, Foo)

issubclass(sub, super)检查sub类是否是 super 类的派生类

class Foo(object):
    pass
class Bar(Foo):
    pass
issubclass(Bar, Foo)

二 反射

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩；

class Foo:
    x = 1
    def __init__(self,name):
        self.name = name
    def f1(self):
        print('from f1')
f = Foo('wang')
print(f.name)
print(hasattr(f,'name'))              #hasattr(object, name)，判断一个对象里面是否有name属性或者name方法，返回BOOL值
print(getattr(f,'name'))              #getattr(object, name,default)，获取对象object的属性或者方法，如果存在打印出来，如果不存在，打印出默认值，默认值可选
print(setattr(f,'name','Jim'))        #setattr(object, name, values)，给对象的属性赋值，若属性不存在，先创建再赋值
print(delattr(f,'name'))              #delattr(object, name),删除指定对象的指定名称的属性，和setattr函数作用相反
#结果
wang
True
wang
None
None

3 item系列

class Foo:
    def __getitem__(self, item):
        print('=====>get')
        return self.__dict__[item]

    def __setitem__(self, key, value):
        self.__dict__[key]=value
        # setattr(self,key,value)

    def __delitem__(self, key):
        self.__dict__.pop(key)
f=Foo()
f.x=1
print(f.x)
print(f.__dict__)
#结果
1
{'x': 1}
=====>get


f['x']=123123123123
del f['x']   #删除

4 打印对象信息__str__

class People:
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex
    def __str__(self): #在对象被打印时触发执行
        return '<name:%s age:%s sex:%s>' %(self.name,self.age,self.sex)
p1=People('wang',18,'male')
p2=People('zhang',38,'male')

print(p1)
print(p2)

#结果
<name:wang age:18 sex:male>
<name:zhang age:38 sex:male>

5 析构方法__del__

析构方法，当对象在内存中被释放时，自动触发执行。

注：如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__,如果产生的对象的同时还会向操作系统发起系统调用，即一个对象有用户级与内核级两种资源，比如（打开一个文件，创建一个数据库链接），则必须在清除对象的同时回收系统资源，这就用到了__del__

class Foo:
    def __init__(self,x):
        self.x=x

    def __del__(self): #在对象资源被释放时触发
        print('-----del------')
        print(self)

f=Foo(100000)
del f
print('=======================>')

典型的应用场景：

创建数据库类，用该类实例化出数据库链接对象，对象本身是存放于用户空间内存中，而链接则是由操作系统管理的，存放于内核空间内存中

当程序结束时，python只会回收自己的内存空间，即用户态内存，而操作系统的资源则没有被回收，这就需要我们定制__del__，在对象被删除前向操作系统发起关闭数据库链接的系统调用，回收资源

这与文件处理是一个道理：

f=open('a.txt') #做了两件事，在用户空间拿到一个f变量，在操作系统内核空间打开一个文件
del f #只回收用户空间的f，操作系统的文件还处于打开状态

#所以我们应该在del f之前保证f.close()执行,即便是没有del，程序执行完毕也会自动del清理资源，于是文件操作的正确用法应该是
f=open('a.txt')
读写...
f.close()
很多情况下大家都容易忽略f.close,这就用到了with上下文管理