python基础---面向对象高级

disl

　　面向对象高级
　　
　　isinstance(obj,cls)
　　检查obj是否是类 cls 的对象
class Foo(object):　　
    pass
　　

　　
obj = Foo()
　　

　　
print(isinstance(obj, Foo))
　　
输出：
　　
True
　　issubclass(sub,super)
　　检查sub类是否是 super 类的派生类
class Foo(object):　　
    pass
　　

　　
class Bar(Foo):
　　
    pass
　　

　　
print(issubclass(Bar, Foo))
　　b.反射
　　主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）
　　python面向对象中的反射：通过字符串反射到真实的属性上
　　面向对象中类中属性的两种调用方法：
　　1.   类名.属性
　　2.类名.__dict__[‘属性名’] #通过字符串的形式
class Foo:　　
    x=1
　　
    def __init__(self,name):
　　
        self.name=name
　　

　　
    def f1(self):
　　
        print('from f1')
　　

　　

　　
print(Foo.x)   #方法1Foo.__dict__['x']      #方法2
　　实现自省的函数，通过操作字符串的方式映射到属性（适用于类和对象，在python中一切皆对象，类本身也是一个对象）
　　hasattr(obj,’name’)     判断obj中有没有一个name字符串对应的方法或属性
　　setattr(x,’y’,’v’)     设置函数，x对象名，y属性，v值
　　getattr(x,’y’)         取值函数，x对象名，y属性
　　delattr(x,’y’)         删除函数，x对象名，y属性
class Ftpserver:　　
    def __init__(self,host,port):
　　
        self.host=host
　　
        self.port=port
　　

　　
    def run(self):
　　
        while True:
　　
            cmd=input('>>: ').strip()
　　
            if not cmd:continue    # 判断输入是否为空
　　
            if hasattr(self,cmd):   # 判断类中是否存在此方法
　　
                func=getattr(self,cmd)   # 取出该方法的值并赋值给func
　　
                func()
　　
    def get(self):
　　
        print('get func')
　　

　　
    def put(self):
　　
        print('put func')
　　反射的好处：
　　1.实现可插拔机制：
　　可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能（首先使用hasattr进行判断是否存在此方法，存在则执行，不存在则跳过）
　　2.动态导入模块（基于反射当前模块成员）
　　c.item系列
　　__setitem__      设置函数
　　__getitem__      取值函数
　　__delitem__      删除函数
class Foo:　　
    def __getitem__(self, item):
　　
        print('=====>get')
　　
        return self.__dict__[item]
　　

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

　　
    def __delitem__(self, key):
　　
        print('============>del')
　　
        self.__dict__.pop(key)
　　

　　

　　
f=Foo()
　　
f['x']=123123123123    # 通过f[]的方式对对象进行操作时会调用item方法
　　
print(f['x'])
　　
del f['x']
　　
输出：
　　
==============>set
　　
=====>get
　　
123123123123
　　
============>del
　　d.打印对象信息__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('egon',18,'male')
　　
p2=People('alex',38,'male')
　　

　　

　　
print(p1)
　　
print(p2)
　　e.析构方法__del__
　　当对象在内存中被释放时，自动触发执行
　　注：如果产生的对象仅仅只是python程序级别的（用户级），那么无需定义__del__,如果产生的对象的同时还会向操作系统发起系统调用，即一个对象有用户级与内核级两种资源，比如（打开一个文件，创建一个数据库链接），则必须在清除对象的同时回收系统资源，这就用到了__del__
　　典型的应用场景：
　　创建数据库类，用该类实例化出数据库链接对象，对象本身是存放于用户空间内存中，而链接则是由操作系统管理的，存放于内核空间内存中,当程序结束时，python只会回收自己的内存空间，即用户态内存，而操作系统的资源则没有被回收，这就需要我们定制__del__，在对象被删除前向操作系统发起关闭数据库链接的系统调用，回收资源
class Foo:　　
    def __init__(self,x):
　　
        self.x=x
　　

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

　　
f=Foo(100000)
　　
del f
　　
print('=======================>')
　　
# 析构方法__del__与文件处理原理差不多：
　　

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

　　
#所以我们应该在del f之前保证f.close()执行,即便是没有del，程序执行完毕也会自动del清理资源，于是文件操作的正确用法应该是
　　
f=open('a.txt')
　　
f.close()  # f.close就相当于析构方法__del__，在回收用户空间的同时回收系统空间
　　7、异常处理
　　异常就是程序运行时发生错误的信号（在程序出现错误时，则会产生一个异常，若程序没有处理它，则会抛出该异常，程序的运行也随之终止）
　　错误有两种：
　　a.语法错误（在语法检测阶段抛出，必须在程序执行前就改正）
　　b.逻辑错误
　　例如：
TypeError      # 类型错误　　
for i in 3:
　　
    pass
　　

　　
NameError      # 名称错误
　　
aaaaa
　　

　　
ValueError     # 值错误
　　
int('asdfsadf')
　　

　　
IndexError     # 索引错误
　　
l=[1,2]
　　
l[1000]
　　

　　
KeyError       # key错误
　　
d={'a':1}
　　
d['b']
　　

　　
AttributeError # 属性错误
　　
class Foo:pass
　　
Foo.x
　　常见异常：
　　AttributeError      试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
　　IOError       输入/输出异常；基本上是无法打开文件
　　ImportError      无法引入模块或包；基本上是路径问题或名称错误
　　IndentationError      语法错误（的子类） ；代码没有正确对齐
　　IndexError   下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
　　KeyError     试图访问字典里不存在的键
　　KeyboardInterrupt   Ctrl+C被按下
　　NameError   使用一个还未被赋予对象的变量
　　SyntaxError Python   代码非法，代码不能编译(个人认为这是语法错误，写错了）
　　TypeError   传入对象类型与要求的不符合
　　UnboundLocalError  试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
　　ValueError   传入一个调用者不期望的值，即使值的类型是正确的
　　异常处理
　　a. 如果错误发生的条件是可预知的，我们需要用if进行处理：在错误发生之前进行预防
AGE=10　　
while True:
　　
    age=input('>>: ').strip()
　　
    if age.isdigit(): #只有在age为字符串形式的整数时,下列代码才不会出错,该条件是可预知的
　　
        age=int(age)
　　
        if age == AGE:
　　
            print('you got it')
　　
            break
　　b. 如果错误发生的条件是不可预知的，则需要用到try...except：在错误发生之后进行处理
　　异常类只能用来处理指定的异常情况，如果非指定异常则无法处理
try:　　
    aaaa        # 抛出NameError异常
　　
    print('==-==>1')
　　
    l=[]
　　
    l[3]        # 抛出IndexError异常
　　
    print('==-==>2')
　　
    d={}
　　
    d['x']      # 抛出KeyError异常
　　
    print('==-==>3')
　　
# 多分支异常
　　
except NameError as e:
　　
    print(e)
　　
except IndexError as e:
　　
    print(e)
　　
except KeyError as e:
　　
    print(e)
　　
except Exception as e:       # 万能异常，能捕捉到所有的异常
　　
    print(e)
　　
else:
　　
    print('在没有错误的时候执行')
　　
finally:
　　
    print('无论有无错误，都会执行')
　　c.主动抛出异常
try:　　
    raise TypeError('类型错误')
　　
except Exception as e:
　　
    print(e)
　　d.自定义异常
class EgonException(BaseException):　　
    def __init__(self,msg):
　　
        self.msg=msg
　　
    def __str__(self):
　　
        return '<%s>' %self.msg
　　

　　
raise EgonException('egon 的异常')
　　e.断言
　　assert