一、介绍

        1、特点

            面向对象 

                   对象：对客观事物的抽象

                            对一个具体事务的存在，现实生活中可以看得见摸得着的

                            可以直接使用的

        2、类和对象的关系

                类：对对象的抽象

                        具有相似内部状态和运动规律的实体的集合(或统称为抽象)       

                        具有相同属性和行为事物的统称

                类∶是创建对象的模板
                对象︰是依据类产生的一个具体实例

二、类

           self的介绍

        1、类的定义

                在Python中，使用class关键字定义一个类。类名通常采用大驼峰命名法（即每个单词首字母大写，其余小写）。类可以包含属性（变量）和方法（函数）。

        2、类的创建

        示例

class Hero:         #定义一个类
    hp = "我快没血了"    #定义成员变量  不建议使用，只读不可修改
    def printmsg(self):        #定义一个成员函数 ， self相当于this指针
        print("我是提莫我快乐")    #函数体

#类的使用
timo = Hero()              #定义一个类对象
timo.printmsg()            #类对象调用函数
print(timo.hp)

        输出结果

          3.对象的添加

        示例

class Hero:         #定义一个类

    hp = "我快没血了"    #定义成员变量  不建议使用，只读不可修改
    def printmsg(self):  # 定义一个成员函数 ， self相当于this指针
        print("我是提莫我快乐")  # 函数体

timo = Hero()              #定义一个类对象
timo.printmsg()            #类对象调用函数
print(timo.hp)
#添加对象
timo.name = "提莫"
timo.age = 18
print("名字：{}, 年龄: {}".format(timo.name, timo.age))

        结果

        4、魔法方法

                1）定义

                在Python中，魔法方法（也称为特殊方法）是以双下划线（__）开头和结尾的方法，它们提供了一种方式来实现和修改对象的内置行为。这些方法允许开发者对Python的内置操作进行自定义实现，比如算术运算、项访问、属性访问、字符串表示等。

                2）魔法方法的使用

        a、__init__(self，[...]):   构造器

class Hero:         #定义一个类
    #魔法方法： __init__(self): 构造器，相当于析构函数
    def __init__(self):
        self.jn = "大招"


timo = Hero()
print("技能：{}".format(timo.jn))

    

class Hero:         #定义一个类
    #魔法方法： __init__(self): 构造器，相当于析构函数
    def __init__(self, name = "提莫", age = 18, hp = 1800):
        self.jn = "大招"
        self.name = name
        self.age = age
        self.hp = hp

timo = Hero()
print("姓名：{}， 年龄：{}， 血量：{}，技能：{}".format(timo.name, timo.age, timo.hp, timo.jn))

        b、__del__(self) :析构器

                它在对象生命周期结束时被调用，用于执行对象的清理工作。

class Hero:         #定义一个类
    #魔法方法： __init__(self): 构造器，相当于析构函数
    def __init__(self, name = "提莫", age = 18, hp = 1800):
        self.jn = "大招"
        self.name = name
        self.age = age
        self.hp = hp
        print("对象创建成功")
    def __del__(self):
        print("对象消除成功")
timo = Hero()
print("姓名：{}， 年龄：{}， 血量：{}，技能：{}".format(timo.name, timo.age, timo.hp, timo.jn))

三、类的继承

        1、单继承

        在面向对象编程中，单继承指的是一个子类（派生类）仅继承自一个父类（基类）。这种继承机制允许子类获取父类的属性和方法，同时也可以添加或修改属性和方法，以实现特定的功能

        示例

#定义父类
class Parent:         #定义一个类
    #魔法方法： __init__(self): 构造器，相当于析构函数
    def __init__(self):
        self.val = "我是父类属性"

    def __del__(self):
        print("父类对象消除成功")

    def show(self):
        print("{}".format(self.val))

#定义派生类确定继承关系
class Child(Parent):
    def __init__(self):
        # 调用父类的__init__方法
        super().__init__()
        self.childVal = "我是子类属性"

    def show1(self):
        print(self.childVal)
    def __del__(self):
        print("派生类对象消除成功")

# 创建子类实例
child = Child()
# 调用继承自父类的方法
child.show()  # 输出: 我是父类属性
# 调用子类的方法
child.show1()  # 输出: 我是子类属性

        在子类中，super()函数是一个特殊的函数，它返回的是一个临时对象，该对象允许你调用父类中定义的方法。最常见的用途是在子类中调用父类的初始化方法__init__，就像上面的示例那样。这样做可以确保父类被正确地初始化

        2、多继承

        虽然单继承使得继承关系更加简单和清晰，但它也有其局限性。在某些情况下，一个类可能需要从多个源继承属性和方法，单继承无法满足这种需求。Python 为此提供了多继承机制，允许一个类同时继承多个父类，以覆盖单继承的这一局限性。

        示例

#定义父类
class Parent1:
    def __init__(self):
        self.val = "我是父类属性一"
    def show1(self):
        print("{}".format(self.val))

class Parent2:
    def __init__(self):
        self.val = "我是父类属性二"
    def show2(self):
        print("{}".format(self.val))

#定义派生类确定继承关系
class Child(Parent1, Parent2):
    def __init__(self):
        # 调用父类的__init__方法
        super().__init__()
        self.childVal = "我是子类属性"

    def show(self):
        print(self.childVal)
    def __del__(self):
        print("派生类对象消除成功")

# 创建子类实例
child = Child()
# 调用继承自父类的方法
child.show1()  # 输出: 我是父类属性一
child.show2()  # 输出: 我是父类属性二
# 调用子类的方法
child.show()  # 输出: 我是子类属性

        3、私有继承

                在面向对象编程中，私有继承是一种特殊的继承方式，它允许子类继承父类的实现细节，包括私有成员和保护成员。私有继承并不常见，因为它通常会导致紧耦合的代码，使得子类与父类之间过于依赖。

                在Python中，没有直接支持私有继承的语法。Python中的继承是默认公有继承，即子类可以访问父类的公有成员（公有方法和属性），但不能直接访问父类的私有成员。

然而，通过一些技巧，可以模拟私有继承的效果

        示例

class Parent1:
    def __init__(self):
        self.public_var = "Public"  #公有
        self._protected_var = "Protected"   #保护
        self.__private_var = "Private"        #私有

    def public_method(self):
        print("This is a public method")

    def _protected_method(self):
        print("This is a protected method")

    def __private_method(self):
        print("This is a private method")


class Child(Parent1):
    def __init__(self):
        super().__init__()
    def access_base_members(self):
        # 可以访问父类的公有成员
        print(self.public_var)  # 输出: Public
        # 可以访问父类的保护成员
        print(self._protected_var)  # 输出: Protected
        # 不能直接访问父类的私有成员
        # print(self.__private_var)  # 报错
    def call_base_methods(self):
        self.public_method()  # 可以调用父类的公有方法
        self._protected_method()  # 可以调用父类的保护方法
        # self.__private_method()  # 报错，无法调用父类的私有方法

child = Child()
child.access_base_members()
child.call_base_methods()

        4、私有继承@property用法

                在 Python 中，@property 装饰器用于将类的方法转换为属性，从而实现对属性的访问和设置时可以执行特定的逻辑。使用 @property 装饰器可以使代码更具可读性和易用性。

           示例

class Demo:
    def __init__(self, name, age, sex):
        #__开头的变量名为 私有成员， 在类的外部不能被直接访问
        self.__name = name
        self.age = age
        self.sex = sex
    @property  #@property :修饰得函数，用来获取私有属性的值  类外部直接使用 obj.函数名 进行使用
    def value(self):
        return self.__name
    @value.setter  #@value.setter :修饰value函数，用来设置私有属性的值  类外部直接使用 obj.函数名 = 数值 进行使用
    def value(self, name):
        self.__name = name

if __name__ == '__main__':
    obj = Demo("盲僧", 18, "女")
    print(obj.age, obj.sex)

    #普通的访问操作私有属性
    obj.value = "蛮王"
    print(obj.value)