断点调试
在想要加断点的地方用鼠标点击一下,你会看到一个红色圆圈
变红的地方,程序执行到,就会暂停
断点应该加在报错之前
绿色箭头表示快速跳到下一个断点执行
控制台报错,点击你能看懂的最后一行,光标会快速定位到错误代码,在错误代码上放,加断点,断点调试
issubclass和isinstance
issubclass()
判断第二个类是不是第一个类的子类，返回true或者false
ass Foo:
pass
class Bar(Foo):
pass
class Tt(Bar):
pass
print(Bar.__bases__)
print(issubclass(Bar,Foo)) # true
print(issubclass(Tt,object)) # trueisinstance()
判断第一个参数是不是第二个参数的对象
class Foo:
pass
class Tt():
pass
f=Foo()
print(isinstance(f,Foo)) # true
print(isinstance(f,Tt)) # false反射
用户输入一段字符串，芷心该字符串相对应的方法
hasattr():判断一个属性是否在对象中,返回True或者False
getattr():通过字符串获取属性或方法,如果获取到了,就会返回相应的属性或方法
setattr():通过字符串来设置属性或方法
delattr():通过字符串来删除属性或方法
class Foo:
def run(self):
print('run')
def speak(self):
print('speak')
p=Foo()
print(Foo.__dict__)
cmd=input('请输入命令:')
#方案一:
# print(Foo.__dict__[cmd])
# Foo.__dict__[cmd](p)
if hasattr(p,cmd):
run=getattr(p,cmd)
run()
else:
print('该命令不存在')
#通过用户输入key和value往对象中赋值
key=input('请输入key:')
value=input('输入value:')
setattr(p,key,value)
print(p.age)
#动态的往对象中放方法
def test(a):
print(a)
print(p.__dict__)
setattr(p,'test',test)
print(p.__dict__)
p.test(0)
#动态的删除属性
#原始的删除方法
p.name='lqz'
print(p.__dict__)
del p.name
print(p.__dict__)
#动态删除p中属性为变量a的属性
p.name='lqz'
p.age=18
p.sex='male'
a=input('请输入要删除的属性:')
print(p.__dict__)
delattr(p,a)
print(p.__dict__)
#直接p.a是不对的
del p.a
#删除对象中属性为name字符串的属性
#判断一下对象中有没有没有我输入的属性,如果有,打印
p.name='lqz'
p.age=18
p.sex='male'
cmd=input('请输入要查询的属性:')
if hasattr(p,cmd):
a=getattr(p,cmd)
print(a)
else:
print('该属性不存在')例子：
class BlackMedium:
feature='Ugly'
def __init__(self,name,addr):
self.name=name
self.addr=addr
def sell_house(self):
print('%s 黑中介卖房子啦,傻逼才买呢,但是谁能证明自己不傻逼' %self.name)
def rent_house(self):
print('%s 黑中介租房子啦,傻逼才租呢' %self.name)
b1=BlackMedium('万成置地','回龙观天露园')
print(b1.__dict__)
print(hasattr(b1,'sell_house'))
a='sell_house'
getattr(b1,'sell_house')
getattr(b1,a)()
sell_house=getattr(b1,a)
name=getattr(b1,'name')
print(name)
print(sell_house)
delattr(b1,'xxx')
print(b1.__dict__)
delattr(b1,'name')
print(b1.__dict__)
模块也是对象，也可以用这四个方法
使用自己的模块，通过反射来获取模块中是否有我要是用的方法，如果有就执行，没有就提示还没有写完
内置方法
我们之前学过的__init__就是最简单的内置方法
__str__
如果不重写__str__，print就会打印出内存地址
_repr__ 跟str类似,在交互式命令下直接写变量名,会执行__repr__
class Foo:
def __init__(self,name):
self.name=name
def __str__(self):
return '['+self.name+']'
f=Foo('nick')
# print(f.__str__()) # 和下一句相同
print(f) # [nick]__setattr__,__delattr__,__getattr__
这三者都是点拦截方法
如果去对象中取属性,一旦取不到,会进入到__getattr_
如果去对象中赋值属性,一旦取不到,会进入到__setattr_
如果删除对象中的属性,会进入__delattr__
class Foo:
def __init__(self,name):
self.name=name
# def __getattr__(self, item):
# # print('xxxx')
# return '你傻逼啊,没有这个字段'
# def __setattr__(self, key, value):
# print('yyyyy')
def __delattr__(self, item):
print('zzzzz')
f=Foo('nick')
# print(f.name)
# # print(f.age)
print(f.__dict__)
# print(f.name)
# f.sex='male'
del f.name
print(f.__dict__)__item__系列
对象通过[]中括号取值，赋值，删除值的时候，会调用
class Foo:
def __init__(self, name):
self.name = name
def __getitem__(self, item):
name=getattr(self,item)
# print(name)
# print(self.__dict__[item])
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'])__call__
加对象会调用
lass Foo:
def __call__(self):
print('xxxx')
f=Foo()
f(）__inter__和__exit__
上下文管理器
class Open:
def __init__(self, name):
self.name = name
def __enter__(self):
print('出现with语句，对象的__enter__被触发，有返回值则赋值给as声明的变量')
# return self
def __exit__(self, exc_type, exc_val, exc_tb):
print('with中代码块执行完毕时执行我啊')
with Open('a.txt') as f:
print('=====>执行代码块')
# print(f,f.name)