反射和内置方法

hasattr():判断一个属性是否在对象中，返回True或者Flase

class Foo:
    def run(self):
        print(‘run‘)
    def speak(self)
        print(‘speak‘)
        
p = Foo()

cmd = input(‘请输入命令：‘)
if hasattr(p,cmd):
    print(‘在‘)
else：
    print(‘不在‘)

getattr():通过字符串获取属性或方法,如果获取到了,就会返回相应的属性或方法

class Foo:
    def run(self):
        print(‘run‘)
    def speak(self)
        print(‘speak‘)
        
p = Foo()
cmd = input(‘请输入命令：‘)
if hasattr(p,cmd):
    run = getattr(p,cmd)
    run()
else：
    print(‘该命令不存在‘)

setattr():通过字符串来设置属性或方法

#通过用户输入key和value往对象中赋值
class Foo:
    def run(self):
        print(‘run‘)
    def speak(self)
        print(‘speak‘)
        
p = Foo()
key = input(‘请输入key:‘)  #与用户交互，输入age
value = input(‘请输入value:‘)  #与用户交互，输入18
setattr(p,key,value)
print(p.age)
-----------------------------------------
18

#动态的往对象中放方法
class Foo:
    def run(self):
        print(‘run‘)
    def speak(self)
        print(‘speak‘)
    def test(a):
        print(a)
p = Foo()        
print(p.__dict__)  #{} 
setattr(p,‘test‘test)
print(p.__dict__) #{‘test‘: <function test at 0x0000024A2D41D400>}
p.test(0)
---------------------------------------
0

delattr():通过字符串来删除属性或方法

#动态删除p中属性为变量a的属性
class Foo:
    def run(self):
        print(‘run‘)
    def speak(self)
        print(‘speak‘)
    def test(a):
        print(a)
p = Foo()
p.name = ‘yjy‘
p.age = 20
p.sex = ‘female‘
a = input(‘请输入要删除的属性：‘)  #age
print(p.__dict__)  #{‘test‘: <function test at 0x0000020532F1D400>, ‘name‘: ‘yjy‘, ‘age‘: 20, ‘sex‘: ‘female‘}
delattr(p,a)
print(p.dict__)   #{‘test‘: <function test at 0x0000020532F1D400>, ‘name‘: ‘yjy‘, ‘sex‘: ‘female‘}

二、内置方法

__str__如果不重写__str__ print打印会打印出内存地址,如果重写了会打印出你想要的

class Foo:
    def __init__(self,name)；
    self.name = name
    def __str__(self) 
    return ‘[‘+self.name+‘]‘

f = Foo(‘yjy‘)
print(f.__str__())   #[yjy]   此时和print(f)一样

-------
#再举个例子
-------
l = [1,2,3]
#本质也是调用list的__str__方法

• 点拦截方法

__getattr__：如果去对象中取属性，一旦取不到，会进入到__getattr__

__setattr__：如果去对象中赋值属性，一旦取不到，会进入__setattr__

__delattr__：如果删除对象中的属性,一旦取不到，会进入__delattr__

class Foo:
    def __init__(self,name):
        self.name=name
    def __getattr__(self, item):
        return ‘没有这个字段‘
    def __setattr__(self, key, value):
        print(‘yyyyy‘)
    def __delattr__(self, item):
        print(‘zzzzz‘)

f=Foo(‘YJY‘)   #我们要给他赋值，没有取到打印yyyyy
print(f.name)  #我们获取name这个属性，没有取到则打印’没有这个字段‘
del f.name   #我们删除name这个属性，没有取到，则答应’zzzzz‘

__item__系列 对象通过[]取值,赋值,删除值的时候,会调用

#写一个类继承字典,让它可以 . 取值,可以中括号取值
class Mydict(dict):
    def __init__(self,**kwargs):
        super().__init__(**kwargs)
    def __getattr__(self, item):    
        # print(item)
        return self[item]
    def __setattr__(self, key, value):
        self[key]=value

        
# print(di[‘name‘])
# print(di.name)
# di.sex=19
# print(di.sex)
di[‘sex‘]=‘male‘
print(di.sex)

class Foo:
    def __init__(self, name):
        self.name = name
    def __getitem__(self, item):
        name=getattr(self,item)
        # print(name)
        return name
        # return self.__dict__[item]
    def __setitem__(self, key, value):
        print(‘obj[key]=lqz赋值时，执行我‘)
        self.__dict__[key] = value
    def __delitem__(self, key):
        print(‘del obj[key]时，执行我‘)
        self.__dict__.pop(key)

f=Foo(‘nick‘)
print(f[‘name‘])   #nick

__call__:对象加括号会调用它

class Foo:
    def __call__(self):
        print(‘hfsdhfsdh‘)
      
f = Foo()
f()   #hfsdhfsdh

• 上下文管理器，本质就是__enter__和__exit__

with open() as f:
    pass