Python入门学习笔记——19.面向对象-高阶-内置成员及魔术方法

####################################
# 1.内置成员
class A():
    pass
class B(A):
    pass
class C(A):
    pass

class Demo(B,C):
    '''
    此处是类的说明文档
    '''
    name = 'a'
    age = 20

    def say(self):
        print('会说会唱会rap。。。')

obj = Demo()
obj.san = 'aaa'

# 获取类/对象的所属成员 类/对象.__dict__
res = Demo.__dict__  # 获取当前类的所属成员
res = obj.__dict__   # 获取当前对象的所属成员

# 获取类的文档信息 类/对象.__doc__
res = Demo.__doc__
res = obj.__doc__

# 获取类名称组成的字符串
res = Demo.__name__

# 获取类所在的文件名称，如果是当前文件，显示为__main__
res = Demo.__module__

# __bases__ 获取当前类的父类列表
res = Demo.__base__ # 获取继承的第一个父类
res = Demo.__bases__ # 获取继承的所有的父类列表

# MRO列表  获取当前类的继承链
res = Demo.__mro__

print(res)

####################################
'''2.方法的分类
1. 对象方法
    特征：
        1. 在类中定义的方法，含有self参数
        2. 含有self的方法，只能使用对象进行调用
        3. 该方法会把调用的对象传递进来

2. 类方法
    特征：
        1。在类中定义的方法，使用装饰器 @classmethod 进行了装饰
        2。方法中有cls这个行参。不需要实例化对象，直接使用类进行调用
        3。会把调用这个方法的类传递进来

3. 绑定类方法
    特征：
        1。在类中定义的方法
        2。只能使用类进行调用
        3。不会传递对象或者类进来

4. 静态方法
    特征：
        1。在类中定义的方法，使用了 装饰器 @staticmethod 进行了装饰
        2。可以使用对象或者类进行调用
        3。不会传递对象或者类进来
'''

class Demo():

    # 对象方法
    def func1(self):
        print(self)
        print('this is object function func1')

    # 类方法
    @classmethod
    def func2(cls):
        print(cls)
        print(' this is class function  func2')

    # 绑定类方法
    def func3():
        print('this is bind class function func3')


    # 静态方法
    @staticmethod
    def func4():
        print('this is static method func4')


# 实例化对象
obj = Demo()

# 对象方法 调用
# obj.func1()
# Demo.func1() # 不能直接使用类调用 对象方法，
# Demo.func1('a')  # 除非传递一个对象进去，不推荐

# 类方法  调用
# Demo.func2() # 可以使用类直接调用
# obj.func2()   # 即便使用对象进行调用，传递进去的依然是类

# 绑定类方法
# Demo.func3()   # 可以使用类调用绑定类方法
# obj.func3()  # 不能使用对象调用绑定类方法


# 静态方法的调用
# Demo.func4()
# obj.func4()

####################################
# 3.面向对象 常用函数

class Demo():
    pass
class A():
    pass
class B(A):
    pass
class C(A):
    ccc = 'abc'

class D(B,C):
    name = 'a'
    __age = 20

    def say(self):
        pass


d = D()


# 检测类和对象相关
# issubclass(子类,父类) # 检测一个类是否为另一个类的子类
# res = issubclass(D,B)

# isinstance(对象,类) # 检测一个对象是否是该类或该类的子类的实例化结果
# res = isinstance(d,A)

# 操作类和对象成员相关
# hasattr(对象/类,'成员名称')  检测类/对象是否包含指定名称的成员
# res = hasattr(d,'name')

#getattr(对象/类,'成员名称') # 获取类/对象的成员的值
# res = getattr(d,'say')

# setattr(对象/类,'成员名称','成员的值') 设置类/对象的成员的属性值
res = setattr(d,'name','ooo')
# print(d.name)

#delattr(类/对象,'成员名称') 删除类/对象的成员属性 和 del 直接删除对象的成员是一样的结果
# delattr(D,'name')

# dir() #获取当前对象所以可以访问的成员的列表
res = dir(d)
print(res)

####################################
# 4.魔术方法
'''
1. __init__ 初始化方法  *****
    触发机制：当实例化对象之后就会立即触发的方法
    作用：   为当前创建的对象完成一些初始化的操作，比如：成员属性的赋值，方法的调用，打开或创建一些资源。。
    参数：   一个self，接受当前对象，其它参数根据需求进行定义即可
    返回值： 无
    注意事项：无

2. __new__ 构造方法    ****
    触发机制：实例化对象时自动触发（在__init__之前触发）
    作用：   管理控制对象创建的过程
    参数：   一个cls 接收当前类，其它参数根据初始化方法的参数进行决定
    返回值： 必须返回object.__new__(cls)进行对象的创建，如果没有返回值，则实例化对象的结果为None
    注意事项：
            __new__方法的参数和__init__方法的参数要保持一致，除了第一个参数
            必须返回object.__new__(cls)进行对象的创建，如果没有返回值，则实例化对象的结果为None
    应用场景：设计模式中的单例设计模式


3. __del__ 析构方法    *****
    触发机制：当该类对象被销毁时，自动触发
    作用： 关闭或释放对象创建时打开或创建的一些资源
    参数： 一个self，接受当前的对象
    返回值：无
    注意事项： 无

4. __call__
    触发机制： 把对象当作函数直接调用时自动触发
    作用：    一般用于归纳类或对象的操作步骤，方便调用
    参数：   一个self接收当前对象，其它参数根据调用需求缺点
    返回值：  可有可无


'''

# 定义一个人类
class Person():

    # 构造方法
    def __new__(cls, *args):
        print('触发了构造方法')

        # 如果在该方法中没有返回如下格式，则无法创建对象
        return object.__new__(cls)


    # 初始化方法
    def __init__(self,name,age,sex):
        print('触发了初始化方法')
        self.name = name
        self.age = age
        self.sex = sex

    def __call__(self, *args, **kwargs):
        print('你把对象当成了函数进行调用')

    # 析构方法
    def __del__(self):
        print('触发了析构方法')

# 实例化对象
zs = Person('张三丰',180,'男')
# print(zs)

zs()

####################################
# 5.


'''
__len__
    触发机制： 当使用len函数去检测当前对象的时候自动触发
    作用：    可以使用len函数检测当前对象中某个数据的信息
    参数：    一个self 接收当前对象
    返回值：  必须有，并且必须是一个整型
    注意事项：len要获取什么属性的值，就在返回值中返回哪个属性的长度即可

__str__
    触发机制： 当使用str或者print函数对对象进行操作时自动触发
    作用：   代码对象进行字符串的返回，可以自定义打印的信息
    参数：  一个self，接收当前对象
    返回值： 必须有，而去必须是字符串类型的值

__repr__
    触发机制：在使用repr方法对当前对象进行转换时自动触发
    作用： 可以设置repr函数操作对象的结果
    参数：  一个self，接收当前对象
    返回值： 必须有，而去必须是字符串类型的值
    注意：正常情况下，如果没有__str__这个魔术方法，__repr__方法就会代替__str__魔术方法

__bool__
    触发机制： 当前使用bool函数转换当前对象时，自动触发.默认情况下，对象会转为True
    作用：    可以代替对象进行bool类型的转换，可以转换任何数据
    参数 ：   一个self 接收对象
    返回值： 必须是一个布尔类型的返回值

'''

class Demo():
    listurl = []

    # 可以代替对象使用len函数，并返回一个指定的整型
    def __len__(self):
        return len(self.listurl)

    # 可以代替对象进行str或者print的字符串信息返回
    def __str__(self):
        return '这是当前脚本中的一个_对象 str'


    def __repr__(self):
        return '这个是一个对象'

    def __bool__(self):
        return bool(self.listurl)

# 实例化对象
obj = Demo()
# res = len(obj)

# print(obj)

# res = repr(obj)

res = bool(obj)
# print(res)

####################################
# 6.str  repr 和对应魔术方法的区别

# 认识 str 和 repr 的区别

num = 521
r1 = str(num)
r2 = repr(num)

# str和repr函数都可以把其它类型的值转为字符串
# print(r1,type(r1))
# print(r2,type(r2))
# 521 <class 'str'>
# 521 <class 'str'>

s = '521'
r1 = str(s)
r2 = repr(s)
print(r1,type(r1))
print(r2,type(r2))

# repr解析的结果带了引号
# 521 <class 'str'>
# '521' <class 'str'>

'''
str和repr函数都能够把其它类型的数据转为字符串类型
str函数会把对象 转为 更适合人类阅读的形式
repr函数会把对象 转为 解释器读取的形式
如果数据对象并没有更明显的区别的化，str和repr的结果是一样的
'''

class Demo():

    def __str__(self):
        return '123'

    def __repr__(self):
        return '123'


obj = Demo()
r1 = str(obj)
r2 = repr(obj)

print(r1,type(r1))
print(r2,type(r2))

####################################
#  7.成员相关魔术方法

'''
1. __getattribute__   优先级最高
    触发机制：当访问对象成员时，自动触发，无论当前成员是否存在
    作用：   可以在获取对象成员时，对数据进行一些处理
    参数：   一个self接收对象，一个item接收当前访问的成员名称
    返回值： 可有可无，返回的值就是访问的结果
    注意事项：在当前的魔术方法中，禁止对当前对象的成员进行访问，会触发递归。
            如果想要在当前魔术方法中访问对象的成员必须使用 object 来进行访问
            格式： object.__getattribute__(self,item)

2. __getattr__
    触发机制： 当访问对象中不存在的成员时，自动触发
    作用：  防止访问不存在的成员时报错，也可以为不存在的成员进行赋值操作
    参数：  一个self接收当前对象，一个item接收当前访问的成员名称
    返回值： 可有可无
    注意事项： 当存在 __getattribute__ 方法时，会去执行 __getattribute__ 方法

3. __setattr__
    触发机制： 当给对象的成员进行赋值操作时会自动触发（包括添加，修改）
    作用：   可以限制或管理对象成员的添加和修改操作
    参数： 1。self 接收当前对象  2。key 设置的成员名  3。val 设置的成员值
    返回值： 无
    注意事项：在当前的魔术方法中禁止给当前对象的成员直接进行赋值操作，会触发递归操作
            如果想要给当前对象的成员进行赋值，需要借助 object
            格式： object.__setattr__(self,key,value)

4. __delattr__
    触发机制： 当删除对象成员时自动触发
    作用： 可以去限制对象成员的删除，还可以删除不存在成员时防止报错
    参数：1，self 接收当前对象  2。item 删除的成员名称
    返回值： 无
    注意事项： 在当前魔术方法中禁止直接删除对象的成员，会触发递归操作。
            如果想要删除当前对象的成员，那么需要借助 object
            格式： object.__delattr__(self,item)
'''

# 定义类
class Person():
    name = '名字'
    age = '年龄'
    sex = '性别'

    def __init__(self,n,a,s):
        self.name = n
        self.age = a
        self.sex = s

    def say(self):
        print('聊聊人生，谈谈理想。。。')
    def sing(self):
        print('高歌一曲。。。')

    # 获取对象成员时自动触发
    # def __getattribute__(self, item):
    #     try:
    #         # 在方法中使用 object来获取属性值
    #         res = object.__getattribute__(self,item)
    #         # 在方法中可以对访问的成员数据进行处理
    #         return res[0]+'*'+res[-1]
    #     except:
    #         return False

    # 当访问不存在的成员时时自动触发
    def __getattr__(self,item):
        print(item)
        return False

    # 当给对象成员进行赋值时触发，注意该方法中如果没有给对象成员赋值，那么对象成员赋值失败
    def __setattr__(self, key, value):
        # print(self,key,value)
        object.__setattr__(self,key,value)

    # 当删除对象的成员时自动触发
    def __delattr__(self, item):
        print(item)
        object.__delattr__(self,item)


# 实例化对象
zs = Person('张三疯',120,'男')
print(zs.name)
print(zs.abc)
zs.abc = 'aabbc'
print(zs.abc)

del zs.abc
print(zs.abc)

####################################