面向对象3

面向对象3

isinstance 和 issubclass

isinstance(obj,cls) 检查obj是否是类cls的对象

class Foo:
    pass

foo = Foo() # 实例化
print(isinstance(foo,Foo)) 
# True

issubclass(cls,classinfo)

class Foo:
    pass

class Bar(Foo):
    pass

print(issubclass(Bar,Foo))
# True

反射

反射是指程序可以访问、检测和修改它本身的状态或者行为的一种能力。

在Python中，面向对象中的反射是指通过字符串的形式操作对象的相关属性。

四个可以实现自省的函数

attribute

• hasattr
  • hasattr(*args,***kwargs)
• getattr
  • getattr(obj,name,)
• setattr
• delattr

class Foo:

    f = "类的静态变量"
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def say(self):
        print("hello,%s"% self.name)

obj = Foo("charon",18)

# 检测是否含有某个属性
print(hasattr(obj,'name'))
print(hasattr(obj,'say'))

# 获取属性
gt = getattr(obj,'name')
print(gt)
gtf = getattr(obj,'say')
gtf()

# gtf1 = getattr(obj,'hello')
print(obj.__dict__)
# 设置属性
setattr(obj,'good man',True)
setattr(obj,'show_name',lambda self: self.name + ' good man')
print(obj.__dict__)
print(obj.show_name(obj))

# 删除属性
delattr(obj,'show_name')
print(obj.__dict__)
print(obj,'name')
print(obj.__dict__)

# True
# True
# charon
# hello,charon
# {'name': 'charon', 'age': 18}
# {'name': 'charon', 'age': 18, 'good man': True, 'show_name': <function <lambda> at 0x000001DD404B2EA0>}
# charon good man
# {'name': 'charon', 'age': 18, 'good man': True}
# <__main__.Foo object at 0x000001DD4068BEB8> name
# {'name': 'charon', 'age': 18, 'good man': True}

联想：字符串，列表，元组可以通过索引值引用值，字典可以通过关键字引用值，用了[]。

item系列

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)

obj1 = Foo("Pluto")
obj1['age'] = 18	# 添加
obj1['age1'] = 19
print(obj1.__dict__)
del obj1['age']		# 删除
del obj1.age1
print(obj1.__dict__)
obj1['name'] = "Charon"		# 修改
print(obj1.__dict__)
# {'name': 'Pluto', 'age': 18, 'age1': 19}
# del obj[key] 时：
# del obj.key 时：
# {'name': 'Pluto'}
# {'name': 'Charon'}

__del__

析构方法，当对象在内存中被释放，就会自动触发执行。

一般不需要自定义。

class Foo:

    def __del__(self):
        print("执行Del函数")

obj = Foo()
del obj
# 执行Del函数

__str__

• 如果直接print打印对象，会看到创建对象的内存地址。

• 当我们使用print（xxx）时，输出对象，如果对象定义了__str__方法，就会打印该方法的描述

class Cat:

    def __init__(self,new_name,new_age):
        self.name = new_name
        self.age = new_age

    def __str__(self):
        return "名字是：%s，年龄是：%s"% (self.name,self.age)

cat = Cat("Charon",3)
print(cat)
# 名字是：Charon，年龄是：3

def func():
    print("hello")

func()
print(func())

对应的，类实例对象的调用，需要使用到__call__的特殊方法

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

    def __call__(self, classmate):
        print("我的名字是{}，我的同桌是{}".format(self.name,classmate))

stu = Student("charon")
stu("pluto")	
# 我的名字是charon，我的同桌是pluto
用类装饰器实现

class Test:
    def __init__(self,func):
        print("装饰器准备装饰")
        self.__func = func

    def __call__(self, *args, **kwargs):
        print("Wrapper Context")
        print("Before")
        self.__func(*args, **kwargs)
        print("After")

@Test
def show():
    print("Hello")

print("flag")
show()

# 装饰器准备装饰
# flag
# Wrapper Context
# Before
# Hello
# After