类的方法

断点调试

在想要加断点的地方用鼠标点击一下,你会看到一个红色圆圈
变红的地方,程序执行到,就会暂停
断点应该加在报错之前
绿色箭头表示快速跳到下一个断点执行
控制台报错,点击你能看懂的最后一行,光标会快速定位到错误代码,在错误代码上放,加断点,断点调试

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))   # true

isinstance()

判断第一个参数是不是第二个参数的对象

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)