面向对象进阶

内容目录　　　　　　　　　　

isinstance和issubclass　　

放射　　　　　　　　　  

　　setattr　　　　　　   

　　delattr　　　　　　   

　　getattr　　　　　　   

　　hasattr　　　　　　  

__str__和__repr__　　　 

item系列　　　　　　　  

　　__getitem__　　　    

　　__setitem__　　　    

　　__delitem__　　　    

 

 

isinstance和issubclass　　

# isinstance(0,t)检查是否obj是否是类 cls 的对象;检查数字类型是否统一
# issubclass(cls,classinfo)检查sub类是否是 super 类的派生类
class A:pass
class B(A):pass
a = A()

print(isinstance(a,A))  #True
print(isinstance(1,int))  #True

print(issubclass(B,A))  #True
print(issubclass(A,B))  #False

 

反射　　　　　　　　　　

python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）
四个可以实现自省的函数  hasattr()  getattr()  setattr()  delattr()
下列方法适用于类和对象（一切皆对象，类本身也是一个对象）

 

class Teacher:
    student_informat = {'查看老师信息':'show_teacher','查看学生信息':'show_student'}
    def __init__(self,name,age,love):
        self.name = name
        self.age = age
        self.love = love

    def show_teacher(self):
        print('老师ale')

    def show_student(self):
        print('学生sx')

    @classmethod
    def func(self):
        print('喜欢笑')

teacher = Teacher('hh',23,'running')
for k in teacher.student_informat:
    print(k)
k = input('请输入你的选择：')
if hasattr(teacher,Teacher.student_informat[k]):
    getattr(teacher,Teacher.student_informat[k])()

# 反射对象中的属性和方法   # hasattr getattr setattr delattr

class A:
    def func(self):
        print('in func')
a = A()
a.name = 'alex'
a.age = 63

# 反射对象的属性
ret = getattr(a,'name')   # 通过变量名的字符串形式取到的值
print(ret)  #alex
print(a.__dict__)  #{'name': 'alex', 'age': 63}


a.变量名 = input('>>>')   # 输入 你好
print(getattr(a,'变量名'))   #你好
print(a.__dict__['变量名'])   #你好

# 反射对象的方法
a.func()
ret = getattr(a,'func')
ret()

class A:
    price = 20
    @classmethod
    def func(cls):
        print('in func')

# 反射类的属性
# A.price
print(getattr(A,'price'))  #20
print(A.__dict__)


# # 反射类的方法 ：classmethod staticmethod
A.func()
if hasattr(A,'func'):
    getattr(A,'func')()  #in func

反

#模块
import time
# 反射模块的属性
print(time.time)  #<built-in function time>
print(getattr(time,'time'))  #<built-in function time>

# 反射模块的方法
getattr(time,'strftime')()

# 内置模块也能用
import time
print(getattr(time,'time')())  #1569147060.450408
print(getattr(time,'asctime')())  #Sun Sep 22 18:11:00 2019

def qqxing():
    print('qqxing')
year = 2018
import sys
print(sys.modules['__main__'].year)

# 反射自己模块中的变量
print(getattr(sys.modules['__main__'],'year'))

# # 反射自己模块中的函数
getattr(sys.modules['__main__'],'qqxing')()

# 变量名 = input('>>>')
print(getattr(sys.modules[__name__],'变量名'))

import time
# 要反射的函数有参数怎么办?
print(time.strftime('%Y-%m-%d %H:%M:S'))
print(getattr(time,'strftime')('%Y-%m-%d %H:%M:S'))

# setattr  设置修改变量
class A:
    pass
a = A()

setattr(a,'name','nezha')
setattr(A,'name','alex')

print(A.name)
print(a.name)

# delattr 删除一个变量
delattr(a,'name')
print(a.name)
delattr(A,'name')
print(a.name)

 

 __str__和__repr__　　　　

改变对象的字符串显示__str__,__repr__
自定制格式化字符串__format__

format_dict={
    'nat':'{obj.name}-{obj.addr}-{obj.type}',#学校名-学校地址-学校类型
    'tna':'{obj.type}:{obj.name}:{obj.addr}',#学校类型:学校名:学校地址
    'tan':'{obj.type}/{obj.addr}/{obj.name}',#学校类型/学校地址/学校名
}
class School:
    def __init__(self,name,addr,type):
        self.name=name
        self.addr=addr
        self.type=type

    def __repr__(self):
        return 'School(%s,%s)' %(self.name,self.addr)
    def __str__(self):
        return '(%s,%s)' %(self.name,self.addr)

    def __format__(self, format_spec):
        # if format_spec
        if not format_spec or format_spec not in format_dict:
            format_spec='nat'
        fmt=format_dict[format_spec]
        return fmt.format(obj=self)

s1=School('oldboy1','北京','私立')
print('from repr: ',repr(s1))
print('from str: ',str(s1))
print(s1)

'''
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
'''
print(format(s1,'nat'))
print(format(s1,'tna'))
print(format(s1,'tan'))
print(format(s1,'asfdasdffd'))

class B:
    def __str__(self):
        return 'str : class B'

    def __repr__(self):
        return 'repr : class B'


b = B()
print('%s' % b) #str : class B
print('%r' % b) #repr : class B

 

item系列　　　　　　　　　

__getitem__\__setitem__\__delitem__

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

    def __getitem__(self, item):
        print(self.__dict__[item])

    def __setitem__(self, key, value):
        self.__dict__[key]=value
    def __delitem__(self, key):
        print('del obj[key]时,我执行')
        self.__dict__.pop(key)
    def __delattr__(self, item):
        print('del obj.key时,我执行')
        self.__dict__.pop(item)

f1=Foo('sb')
f1['age']=18
f1['age1']=19
del f1.age1  #del obj.key时,我执行
del f1['age']  #del obj[key]时,我执行
f1['name']='alex'
print(f1.__dict__)  #'name': 'alex'}