面向对象高级A（反射，拦截方法）
一等公民：只要可以把一个东西赋值给一个变量，这个东西就叫一等公民
断点调试
在想要加断点的地方用鼠标点击一下，会看到一个红色圆圈
变红的地方，程序执行到，就会暂停
断点应该加在报错之前，在错误代码上放断点进行调试
向下绿色箭头是单步调试
右下角色绿色三角形是快速调到下一个断点执行
控制台报错，点击你能看懂的最后一行，光标会定位到错误代码
issubclass()
判断第一个类是不是第二个类的子类，返回true或者false
class Foo:
pass
class Bar(Foo):
pass
class Tt(Bar):
pass
print(Tt.__bases__) #(<class '__main__.Bar'>,)
print(issubclass(Bar, Foo)) # True
print(issubclass(Tt, Foo)) # True
isinstance()
判断第一个参数是不是第二个参数的对象，返回True或者False
class Foo:
pass
class Tt:
pass
f = Foo()
print(isinstance(f, Foo)) # true
print(isinstance(f, Tt)) # false
反射
hasattr(): 判断一个属性是否在对象中，返回true或者false
getattr():通过字符串获取属性或方法，如果获取到了，就会返回相应的属性或方法
settattr():通过字符串来设置属性或方法
delattr():通过字符串来删除属性或方法
class Foo:
def run(self):
print('run')
def speak(self):
print('speak')
p = Foo()
cmd = input('请输入命令')
if hasattr(p, cmd):
cmd1 = getattr(p, cmd)
cmd1()
else:
print('该命令不存在')
‘’‘
请输入命令：run
run
请输入命名：a
该命令不存在
’‘’
# 动态的加属性
class Person():
def __init__(self, name, age):
self.name = name
self.age = age
p = Person('nick', 19)
key=input('请输入key: ')
value=input('输入value: ')
setattr(p,key,value)
print(p.age)
print(p.__dict__)
'''
请输入key:nick
输入value:123
19
{'name': 'nick', 'age': 19, 'nick': '123'}
'''
# 动态的删属性
p.name = 'lqz'
p.age = 18
p.sex = 'male'
a = input('请输入要删除的属性: ')
print(p.__dict__)
delattr(p, a)
print(p.__dict__)
"""
请输入要删除的属性: sex
{'name': 'lqz', 'age': 18, 'sex': 'male'}
{'name': 'lqz', 'age': 18}
"""
# 动态的加方法
# 需要先写一个函数，然后通过setattr()往对象中加方法
def test(a):
print(a)
print(p.__dict__)
setattr(p, 'test', test)
print(p.__dict__)
p.test(0) # 0
#模块也是对象，也可以用这四个方法
#内置模块
import os
print(hasattr(os, 'path1')) #False
#使用自己写的模块，通过反射来获取模块中是否有我要使用的属性或方法，如果有就执行，没有就报错
#这种方法可以用在：我想调用别人写的模块，但是我并不知道他写没写完，所以我需要用到hasattr先判断是否存在，存在的话用getattr拿到它，否则抛异常
'''
#别人写的,领导规定要写speak,run,eat方法
#这个人没写完
#utils.py
def speak():
print('speak')
def run():
print('run')
#这个人写完了
#def eat():
print('eat')
#opera.py
import utils
if hasattr(utils, 'eat')
eat = getattr(utils, 'eat')
eat()
else:
print('那个人还没写完呢')
# 那个人还没写完呢
'''
内置方法
__str__
class Foo:
def __init__(self, name):
self.name = name
def __str__(self):
return '['+self.name+']'
f = Foo('nick')
print(f) #print会按照__str__里面重写的格式进行打印
# print(f.__str__()) # 打印结果同上: [nick]
l = [1, 2, 3]
print(l) # [1, 2, 3]本质也是调用list的__str__方法
点拦截方法
如果去对象中取属性，一旦取不到，会进入__getattr__
如果去对象中赋值属性，一旦取不到，会进入到__setattr__
如果删除对象中的属性，会进入__delattr__
class Foo:
def __init__(self, name):
self.name = name # name没拿到值，要进入到__setarr__中,
# 找到后打印出来name的值 'nick'
print(name)
def __getattr__(self, item):
return '没有这个字段'
def __setattr__(self, key, value):# key值是参数name,
# value是值'nick'
print(key)
print(value)
def __delattr__(self, item):
print('zzzz')
f = Foo('nick') # 生成对象调用__init__方法，
print(f.name) #重写了__setattr__, 所以找不到name，这样就会进入__getattr__中
#######
#小例子#
#######
# 写一个类继承字典， 让他可以.取值，也可以中括号取值
class Mydict(dict):
def __init__(self, **kwargs):
super().__init__(**kwargs)
def __getattr__(self, item):
# pass
return self[item]
di = Mydict(name = 'lqz', age = 18)
print(di['age'])
print(di.name) #点取值找不到，
# 会触发__getattr__，继承了字典，直接利用key返回value
[]中括号拦截
__item__系列， 对象通过[]中括号取值，赋值删除值的时候会调用
#实现机理和.拦截一样，只不过是对象
# 用中括号调用时会触发
class Foo:
def __init__(self, name):
self.name = name
def __getitem__(self, item):
name = getattr(self, item) # 通过反射
# 拿到nick,并返回，这句话之后可
# 以使用中括号进行取值
return name
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')
f['name'] = 'ljy'
del f['name']
# print(f.name)
print(f['name'])
()对象加小括号拦截
_call_
class Foo:
def __call__(self):
print('xxxx')
f = Foo()
f()
# xxxx
