【无标题】

1. 类和实例

类(Class):用来描述具有相同的属性和方法的对象的集合。定义了该集合中每个对象所共有的属性和方法。

类的实例：每个对象都属于特定的类，并被称为该类的实例(类的具体实体)封装

class Person:
    pass


print(Person, type(Person), id(Person))
# 结果:
# <class '__main__.Person'> <class 'type'> 2160244321968

# 实例一个对象
p1 = Person()
print(p1, type(p1), id(p1))
# 结果:
# <__main__.Person object at 0x00000220E6313A50> <class '__main__.Person'> 2340324194896

2.封装继承多态 

封装是指将数据（属性）和操作数据的方法（方法）捆绑在一起的机制。

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

    @property
    def p_name(self):
        print("执行获取")
        return self.name

    @p_name.setter
    def p_name(self, name):
        print("执行设置")
        if 2 <= len(name) <= 4:
            self.name = name
        else:
            print("名字不合法")

p = Person("msy", 22)
p.p_name = "xxx"
print(p.p_name)

继承：子类继承父类属性和方法

super().

class Person():
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f"名字:{self.name}"


class SuperPerson(Person):
    """
    子类SuperPerson 继承父类Person
    """

    def __init__(self, name, skill):
        super().__init__(name)
        self.skill = skill

    def __str__(self):
        return f"{super().__str__()} 技能:{self.skill}"


p1 = Person("msy")
print(p1)

sp1 = SuperPerson("懒洋洋", "睡觉")
print(sp1)

        多继承：一个子类可以同时继承多个父类的属性和方法。这使得子类可以具有多个父类的特性。

class Person1:
    def __str__(self):
        return "hhh"


class Person2:
    pass


class Person(Person2, Person1):
    pass


p1 = Person()
print(p1)
print(Person.mro())

#结果:

hhh
[<class '__main__.Person'>, <class '__main__.Person2'>, <class '__main__.Person1'>, <class 'object'>]

多态:

多态是指允许对象在不同的情况下表现出不同的行为,相同的方法调用可能会有不同的实现方式，具体取决于调用该方法的对象的类型或类的实现。

class Person:
    def log(self, *args):
        print(args)


p1 = Person()
print(p1.log("xxx", "hhh", 123))


class SuperPerson(Person):
    def log(self, *args, **kwargs):
        print(args, kwargs)


sp = SuperPerson()
print(SuperPerson.mro())
print(sp.log("msy", "abc", "123"))


class RobotPerson(Person):
    def log(self):
        print("机器人")


rb = RobotPerson()
print(rb.log())

3.构造函数:用于创建实例

class Manage:
    instance = None

    def __new__(cls, *args, **kwargs):
        """
        构造函数用于创建实例
        :param args:
        :param kwargs:
        """
        if not Manage.instance:
            Manage.instance = super().__new__(cls)
        return Manage.instance


m1 = Manage()
m2 = Manage()
print(id(m1), id(m2))

初始化函数：用于初始化实例 数据 ；self代表的就是未来构造出来的实例

        构造实例时会执行初始化函数，通过初始化函数初始化实例数据

class Person:
    def __init__(self, _name, _age):
        print("初始化函数", id(self))
        self.name = _name
        self.age = _age

析构函数: 用于内存之前的清理工作, 当实例不再被使用，执行实例的析构函数

    def __del__(self):
       
        print(f"析构函数执行")

转字符串函数：打印实例 打印str函数的返回值 只能返回字符串

    def __str__(self):
     
        return f"姓名:{self.get_name()}\t年龄:{self.get_age()}"

4. 实例属性：类内通过self.  类外通过 实例. 操作

实例方法: def... (self,) 第一个参数是self

类属性: 在类内直接设置的

类方法 ：使用@classmethod 装饰器 第一个参数 cls

静态方法：单纯通过类名调用的快捷方式

    # 类属性:
    NAME = "msy"
    AGE = 22

    # 类方法：
    @classmethod
    def init_get_name(cls):
        print("abc", cls.__name__, cls.__base__, cls.__doc__)

    # 静态方法
    @staticmethod
    def Say_Hi():
        print("Hi 我是静态方法")

    # 初始化函数 给实例添加实例属性：
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 实例方法：设置名字
    def init_name(self, name):
        self.name = name


print(Person.NAME, Person.AGE)  # 类访问类属性
Person.NAME = "xxx"  # 修改类属性
Person.AGE = 30
print(Person.NAME, Person.AGE)
Person.init_get_name()  # 类访问类方法
Person.Say_Hi()  # 类访问静态方法



p1 = Person("zh", "18")
print(p1.name, p1.age)

print(p1.NAME, p1.AGE)  # 实例访问类属性

p1.init_name("msy")
print(p1.name, p1.age)

5.普通成员：公开，所有位置都可以访问

保护成员：_   受保护 类内及子类可以访问 类外不推荐使用

私有成员: _ _   类外不能访问 封装成属性 可以访问

class Person:
    def __init__(self, name, age):
        # 私有 类外不能访问 封装成属性 可以访问
        self.__name = name
        # 受保护 类内及子类可以访问 类外不推荐使用
        self._age = age
        # 公开的 所有位置都可以访问
        self.address = None

    @property
    def name(self):
        return self.__name

    @name.setter
    def name(self, name):
        self.__name = name

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        self._age = age

    def __str__(self):
        return f"地址是{self.address}"


p1 = Person("msy", 22)
print(p1)
print(p1.name)
p1.name = "xxx"
print(p1.name)
print(p1.address)

print(p1.age)
p1.age = 30
print(p1.age)


class SuperPerson(Person):
    def set_age(self, age):
        self._age = age

    def get_age(self):
        return self._age


sp = SuperPerson("蜘蛛侠", 10)
sp.age = 20
print(sp.age)
print(sp.address)

6.多继承：子类继承多个父类 

单例类：一个类只能生成一个实例

class Manage:
    instance = None

    def __new__(cls, *args, **kwargs):
        """
        构造函数用于创建实例
        :param args:
        :param kwargs:
        """
        if not Manage.instance:
            Manage.instance = super().__new__(cls)
        return Manage.instance


m1 = Manage()
m2 = Manage()
print(id(m1), id(m2))


class AduioManage(Manage):
    pass


am1 = AduioManage()
am2 = AduioManage()
print(am1 is am2)

抽象类: