面向对象——格式化|析构|反射

1、__str__:

# 格式化方法：在外界打印该对象的时被调用

# 格式化外界直接打印改类对象的字符串表示结果

class A:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return '<name:%s|age:%s>'%(self.name,self.age)

a=A('老王',88)
print(a)#<name:老王|age:88>

2、__del__:
# 析构方法：在对象被销毁的时候被调用，在销毁前可以做一些事情

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

    def __del__(self):
	# del会在self代表的对象被消耗的时候被调用
        # 我们可以在析构函数中释放该对象持有的其他资源，
        # 或者将一些持有资源持久化(保存到文件或数据库中)
        del self.name

a = A('老王', 88)
print(a, type(a))

3、了解 对象.语法的内部实现

class B:
    # 了解：对象.语法的内部实现
    def __setattr__(self, key, value):
        # print(key, value)
        b.__dict__[key] = value
        # b.__dict__[key] = value.lower()
        # b.__dict__['xyz'] = 'XYZ'

    # 了了解：将对象添加属性的方式可以同字典形式
    def __setitem__(self, key, value):
        self.__dict__[key] = value


b = B()
b.name = 'BBB'  # b.__dict__['name'] = 'BBB'
print(b.name)

b['age'] = 18
print(b.age)  # 访问还是通过.语法访问

4、反射：通过字符串与类及类的对象的属性（方法）建立关联
反射:
    通过 字符串 来操作类与对象的属性。
    hasattr()
        判断对象或者类的属性是否存在！

    getattr()
        获取对象或者类的属性
        参数1: 对象
        参数2: '属性名'
        参数3: 默认值

    setattr()
        设置对象或者类的属性

    delattr()
        删除对象或者类的属性

# 反射：通过字符串与类及类的对象的属性(方法)建立关联
class A:
    num = 10
print(hasattr(A, 'num'))
res = getattr(A, 'num', '默认值')
print(res)
delattr(A, 'num')
print(setattr(A, 'tag', 10))
# 类的属性类来操作

class B:
    def __init__(self, name):
        self.name = name
print(hasattr(b, 'name'))
print(getattr(b, 'name', '对象的属性类不能获取'))
delattr(b, 'name')
print(setattr(b, 'age', 18))
# 对象的属性对象来操作

class C:
    def fn(self):
        print('fn')

    @classmethod
    def func(cls):
        print('func')

fn = getattr(C, 'fn')
c = C()
fn(c)  # 类获取对象方法调用时传入具体的对象

obj_fn = getattr(c, 'fn') 
obj_fn()  # 对象获取对象方法调用时不用传参

func = getattr(C, 'func')
func()  # 类获取类方法调用时不需要传入参数

# 总结：
# 类的属性用类来操作
# 对象的属性用对象来操作
# 方法建议使用类来操作，得到的方法调用时
#       -- 对象的方法要传入具体的对象
#       -- 类的方法不需要传入参数