Python类的学习，看这一篇文章就够了！

PS：我是写C++ 的，并且之前Python基础也看过很多遍了，这次只是做一个简单的笔记，方便以后复习时查看。所以如果你是0基础就不要再来浪费时间了。

1、构造函数、析构函数、类属性、类方法、静态方法的使用。

class Cat:
    # 使用赋值语句定义类属性，记录所有对象的数量
    count = 0

    # 类方法
    @classmethod
    def show_cat_count(cls):
        print("猫对象的数量为：%d." % Cat.count)

    # 静态方法
    @staticmethod
    def run():
        # 不访问实例属性/类属性
        print("我是一只乱跑的小猫！")

    def __init__(self):
        print("我是构造函数！")
        # 让类属性的值+1
        Cat.count += 1

    def eat(self):
        # 哪一个对象调用的方法，self就是哪一个对象的引用
        print("%s 爱吃鱼" % self.name)

    def drink(self):
        print("%s 要喝水" % self.name)

    def __del__(self):
        print("我是析构函数！")


# 创建猫对象(会调用构造函数)
tom = Cat()
# 可以使用　.属性名　利用赋值语句设置对象属性（不推荐在类的外部给对象增加属性）
tom.name = "Tom"
tom.eat()
tom.drink()
# 输出猫对象的总数
print("工具对象总数 %d" % tom.count)  # 不推荐使用
print("===> %d" % Cat.count)
# 调用类方法
Cat.show_cat_count()
# 通过类名.调用静态方法 - 不需要创建对象
Cat.run()
# del 关键字可以删除一个对象(会调用构造函数)
del tom

2、私有属性、私有方法、公有属性、公有方法、__str__(self)方法的使用

class Cat:
    def __init__(self, new_name):
        print("我是构造函数！")
        # 公有属性
        self.name = new_name
        # 私有属性
        self.__color = "白色"

    def __str__(self):
        print("利用print函数打印类对象的时候执行！")
        # 必须返回一个字符串
        return "我是小猫%s！" % self.name

    # 私有方法
    def __eat(self):
        # 哪一个对象调用的方法，self就是哪一个对象的引用
        print("%s 爱吃鱼" % self.name)

    # 公有方法
    def drink(self):
        print("%s 要喝水" % self.name)


tom = Cat("小白")
print(tom.name)  # 打印类的公有属性
tom.drink()
# 伪私有属性，在外界不能够被直接访问
print(tom._Cat__color)
# 伪私有方法，同样不允许在外界直接访问
tom._Cat__eat()
print(tom) # 会执行类的 __str__（）函数

3、类的单继承、重写父类方法、调用父类方法

class Dog(object):
    # 构造函数
    def __init__(self, name):
        # 公有变量
        self.name = name

    def game(self):
        print("%s 蹦蹦跳跳的玩耍..." % self.name)

    def bark(self):
        print("汪汪叫！")


class XiaoTianDog(Dog):

    def game(self):
        print("%s 飞到天上去玩耍..." % self.name)

    def bark(self):
        print("神一样的叫唤...")
        # 2. 使用 super(). 调用原本在父类中封装的方法
        super().bark()
        # 父类名.方法(self)
        Dog.bark(self)
        # 注意：如果使用子类调用方法，会出现递归调用 - 死循环！
        # XiaoTianQuan.bark(self)


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

    def game_with_dog(self, dog):
        print("%s 和 %s 快乐的玩耍..." % (self.name, dog.name))
        # 让狗玩耍
        dog.game()


# 1. 创建一个狗对象 使用类名()创建对象的时候，会自动调用初始化方法 __init__
# wang_cai = Dog("旺财")
wang_cai = XiaoTianDog("飞天旺财")
# 如果子类中，重写了父类的方法,在使用子类对象调用方法时，会调用子类中重写的方法
wang_cai.bark()
# 2. 创建一个小明对象
xiao_ming = Person("小明")
# 3. 让小明调用和狗玩的方法
xiao_ming.game_with_dog(wang_cai)

4、类的多继承、类对象调用方法的顺序

class A:
    def test(self):
        print("A --- test 方法")

    def demo(self):
        print("A --- demo 方法")


class B:
    def test(self):
        print("B --- test 方法")


#class C(A, B)
class C(B, A):
    """多继承可以让子类对象，同时具有多个父类的属性和方法"""
    pass


c = C()
c.test()
c.demo()
# 确定C类对象调用方法的顺序
print(C.__mro__)

5、类的单例模式

class MusicPlayer(object):
    # 记录第一个被创建对象的引用
    instance = None
    # 记录是否执行过初始化动作
    init_flag = False

    # 1. 创建对象时，new方法会被自动调用
    def __new__(cls, *args, **kwargs):
        # 1. 判断类属性是否是空对象
        if cls.instance is None:
            # 2. 调用父类的方法，为第一个对象分配空间
            cls.instance = super().__new__(cls)
        # 3. 返回类属性保存的对象引用
        return cls.instance

    def __init__(self):
        # 1. 判断是否执行过初始化动作
        if MusicPlayer.init_flag:
            return
        # 2. 如果没有执行过，在执行初始化动作
        print("初始化播放器")
        # 3. 修改类属性的标记
        MusicPlayer.init_flag = True


# 创建多个对象
player1 = MusicPlayer()
print(player1)
player2 = MusicPlayer()
print(player2)