Python面向对象高阶-内置成员方法

Python面向对象高阶

内置成员方法

# 内置成员

class Demo():
    # 这个位置定义类的文档说明
    """
    类的文档说明
    """
    name = 'python'

    def eat(self):
        print('吃海鲜')

    pass


class Demo1():
    pass


class Demo2(Demo, Demo1):
    pass


# 获取类/对象的所属成员
print(
    Demo.__dict__)  # {'__module__': '__main__', 'name': 'python', 'eat': <function Demo.eat at 0x000001F31EDDC820>。。。}
d = Demo()
# 实例化对象没有自己的成员
print(d.__dict__)  # {}
# 为实例化对象添加成员属性
d.age = 18
print(d.__dict__)  # {'age': 18}

print(Demo.__doc__)  # 类的文档说明

print(d.__doc__)  # 类的文档说明

print(Demo.__name__)  # Demo 获取类名称

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

print(Demo2.__bases__)  # 获取当前类的父类列表 (<class '__main__.Demo'>, <class '__main__.Demo1'>)

print(Demo2.__base__)  # 获取当前类的父类 <class '__main__.Demo'>

方法的分类

​

方法的分类：
    1.对象方法
        在类中定义的方法，含有self参数
        含有self的方法，只能使用对象进行调用
        该方法会把调用的对象传递进来
    2.类方法
        在类中定义方法时使用@classmethod装饰器进行装饰 
        不需要实例化对象，可直接使用类进行调用
        会把调用这个方法的类传递进来
    3.绑定类方法
        在类中定义的方法，可以传递参数，不会传递对象或者类
        只能使用类进行调用
        不会传递对象或者类
    4.静态方法
        在类中定义的方法，可以传递参数，不会传递对象或者类
        使用装饰器@staticmethod 进行转世
        可以使用对象或者类进行调用  

代码实现

# 对象方法
class Demo():
    def eat(self):
        print('对象方法：吃海鲜。。。')

    # 类方法
    @classmethod
    def eat2(cls):
        print('类方法：吃海鲜。。。。')

    # 绑定类方法
    def eat3():
        print('绑定类方法：吃海鲜。。。。')

    @staticmethod
    def eat4():
        print('静态方法：吃海鲜。。。')


d = Demo()
Demo.eat2()  # 只能使用类调用绑定类方法--self传递的是类  类方法：吃海鲜。。。。

# 静态方法调用
Demo.eat4()  # 静态方法：吃海鲜。。。
d.eat4()  # 静态方法：吃海鲜。。。

常用函数

# 面向对象常用函数

class A():
    pass


class B(A):
    name = 'java'


class C():
    age = 18
    __address = '北京'


class D(C):
    name = 'python'

    def eat(self):
        pass


# issubclass()检测一个类是否为另一个类的子类
print(issubclass(B, A))  # True
print(issubclass(A, object))  # True

# 检查一个对象是否是一个类的实例化对象
b = B()
print(isinstance(b, B))  # True
print(isinstance(b, A))  # B继承A，b是B的实例化对象，b也继承于A  True

# hasattr()检查类或对象是否包含指定名称的成员
print(hasattr(D, 'name'))  # True
print(hasattr(D, 'eat'))  # True
print(hasattr(D, 'age'))  # True
print(hasattr(D, 'address'))  # False address是C类的私有成员属性，D继承C但访问不到私有属性，所以返回False

# getattr() 获取类/对象的成员属性的值
print(getattr(b, 'name'))  # java

# setattr() 编辑类/对象的成员属性值
setattr(b, 'name', 'python')
setattr(b, 'age', '11')
print(getattr(b, 'age'))  # 11
print(getattr(b, 'name'))  # python

# delattr() 删除类/对象的成员属性
delattr(b, 'age')
print(b.__dict__)  # {'name': 'python'}

魔术方法

对象魔术方法

魔术方法就是不需要手动调用就可以自动执行的方法

__init__初始化方法就是魔术方法
触发机制：当实例化对象后就会立即触发的方法
作用 ：当创建对象后完成一些初始化的操作，比如：成员属性的复制，方法的调用，打开或创建资源等
参数 ：self，接收当前对象，其它参数根据需求定义即可
返回值 ：None
new 构造方法
触发机制：实例化对象时自动触发（在__init__之前触发）
作用：管理控制对象创建的过程
参数：一个cls接收当前类，其它参数根据初始化方法的参数进行决定
返回值：必须返回object.new(cls)进行对象的创建，如果没有返回值，则实例化对象结果为None
call
触发机制：把对象当做函数直接调用时自动触发
作用：用于归纳累活对虾的操作步骤，方便调用
参数：self接收当前对象，其它参数根据调用需求传参

len 获取长度信息
触发机制：使用len函数检测当前对象时
作用：可以使用此函数检测当前对象某个属性的信息
参数：self接收当前对象
返回值：必须是一个整型
str
触发机制：当时用str或者print函数对对象操作时自动触发
作用：对象进行字符串的返回，可以自定义返回信息
参数：self接收当前对象
返回值：返回字符串类型

del。。。。

代码实现

class Person():
    # 构造方法，魔术方法
    def __new__(cls, *args, **kwargs):
        print('触发构造方法')
        # 如果不加 return，创建对象失败
        return object.__new__(cls)

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

    # 析构方法，魔术方法
    def __del__(self):
        print('触发析构方法')


p = Person('python', '12', '男')
print(p)

class Demo():
    listurl = []
#可以返回长度
    def __len__(self):
        return len(self.listurl)
#可以diatribe<__main__.Demo object at 0x000002192C384FA0>，返回指定内容
    def __str__(self):
        return '<这是一个对象>'


obj = Demo()
obj.listurl = [1, 2, 3, 4, 5]
print('长度', len(obj))  # 长度 5
print(obj)  # <这是一个对象>

成员魔术方法

测试用不到。。。。