Python学习（面向对象3）

一、inistance 和 issubclass

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

class Foo:
    pass

foo = Foo()
print(isinstance(foo,Foo))	#True

issubclass(cls1,cls2)：检查cls1是否是cls2的子类

class Foo:
    pass

class Bar(Foo):
    pass

print(issubclass(Bar,Foo))	#True

二、反射

所谓反射，是指程序可以访问、检测和修改它本身状态或者行为的一种能力（自省）

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

四个可以实现自省的函数

• hasattr
  • hasattr(*args,**kwargs)
• getattr
  • getattr(obj,name,default=None)
• setattr
  • def setattr(x, y, v)
• delattr
  • def delattr(x, y)

class Foo:
    f = "类的静态变量"

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

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

obj = Foo("Tom",22)

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

#获取某个属性
gt = getattr(obj,"name")
print(gt)       #Tom
gtf = getattr(obj,"say")
gtf()           #hello,Tom
#不存在会报错

#设置属性
print(obj.__dict__)     #{'name': 'Tom', 'age': 22}
setattr(obj,"good man",True)
setattr(obj,"show_name",lambda self:self.name + "good man")
print(obj.__dict__)     #{'name': 'Tom', 'age': 22, 'good man': True, 'show_name': <function <lambda> at 0x0000026BD8DE1EA0>}
print(obj.show_name(obj))   #Tomgood man

#删除属性
delattr(obj,"show_name")
print(obj.__dict__)     #{'name': 'Tom', 'age': 22, '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("Tom")
obj1['age'] = 18
obj1['age1'] = 19
print(obj1.__dict__)    #{'name': 'Tom', 'age': 18, 'age1': 19}
del obj1['age']
del obj1.age1
print(obj1.__dict__)    #{'name': 'Tom'}
obj1['name'] = "Jack"
print(obj1.__dict__)    #{'name': 'Jack'}

四、__del__

析构方法，当对象在内存中被释放，就会自动触发执行。一般不需要自定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

class Foo:
    def __del__(self):
        print("执行del函数")

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

五、__str__

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

当我们使用print(XXX)时，如果对象中定义了__str__方法，就会打印该方法return的信息描述

class Cat:
    def __init__(self,new_name,new_age):
        self.new_name = new_name
        self.new_age = new_age

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


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

六、类装饰器的实现

首先，__call__方法

def func():
    print("Hello")

func()
print(func())
#调用

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

class Student:
    def __init__(self,name):
        self.name = name
        
    def __call__(self,classmate):
        print("我的名字的是%s，我的同桌是%s"%(self.name,classmate))

stu = Student("haha")
stu("hehe")     #我的名字的是haha，我的同桌是hehe

用类装饰器，通过__init__ 和 __call__ 方法实现

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