一、类的继承

python中类支持继承，并且支持多继承

1.什么是继承

父类（超类）：被继承的类
子类：去继承父类的类
继承就是让子类直接拥有父类的属性和方法（注意：继承后父类的东西不会减少）
python中所有的类都是直接或者间接继承自object

2.怎么继承

class 类名（父类）：……
class 类名: == class 类名(object):

3.能继承哪些东西

对象属性、对象方法、类的字段、类方法、静态方法都可以继承
注意：如果设置了slots会约束当前类的对象属性，并且会导致当前类的对象的dict属性不存在；
继承后，slots的值不会约束到子类的对象属性，但是会导致子类对象的dict只有在当前类中添加的属性

class Person:
    num = 61
    __numbers = 61

    # __slots__ = ('name', 'age', '__gender')

    def __init__(self, name='小明', age=18):
        self.name = name
        self.age = age
        self.__gender = 'male'

    def eat(self, food: str):
        print('%s在吃%s' % (self.name, food))

    @staticmethod
    def func1():
        print('Person的静态方法')

    @classmethod
    def show_num(cls):
        print('人类的数量：%d亿' % cls.num)

class Student(Person):
    pass


# 创建Student类的对象
stu1 = Student()
# 对象属性可以继承
print(stu1.name, stu1.age)  # 小明 18
# 对象方法可以继承
stu1.eat('面条')  # 小明在吃面条

# 类的字段可以继承
print(Student.num)  # 61
# 类方法可以继承
Student.show_num()  # 人类的数量：61亿
# 静态方法可以继承
Student.func1()  # Person的静态方法

# 私有属性也可以继承
print(stu1.__dict__)  # {'name': '小明', 'age': 18, '_Person__gender': 'male'}

# stu1.id = 100  # 父类添加__slots__后，子类添加id属性不会报错

二、重写

继承后子类会拥有父类的属性和方法，也可以添加属于自己的属性和方法

1.添加新的方法

直接在子类中声明新的方法，新的方法只能通过子类来使用

2.重写

a. 子类继承父类的方法，在子类中去重新实现这个方法的功能 --> 完全重写
b. 在子类方法中通过super().父类方法去保留父类对应的方法的功能
3.类中的函数的调用过程

类.方法(), 对象.方法()

先看当前类是否有这个方法，如果有就直接调用当前类中相应的方法；
如果没有就去当前的父类中去看有没有这个方法，如果有就调用父类的这个方法；
如果父类中也没有这个方法，就去父类的父类中找，依次类推，直到找到为止。
如果找到基类object，还没有找到这个方法，程序才异常。

class Person:

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

    def eat(self, food):
        print('%s在吃%s' % (self.name, food))

    @staticmethod
    def run():
        print('人在跑步')

    @classmethod
    def get_up(cls):
        print('==========')
        print('洗漱')
        print('换衣服')


class Student(Person):

    def study(self):
        print('%s正在学习' % self.name)

    def eat(self, food):
        # super():当前类的父类的对象
        print('对象方法：', super())
        super().eat(food)
        print('喝一杯牛奶')

    @staticmethod
    def run():
        print('学生在跑步')

    @classmethod
    def get_up(cls):
        # super() -> 获取当前类的父类
        # super().get_up() -> 调用父类的get_up方法
        print('类方法：', super())
        super().get_up()  # 可以保留父类get_up的功能
        # cls.__bases__[0].get_up()  # __bases__用元组方式返回所有父类，此方式也可以保留功能
        print('背书包')


p1 = Person('小明')
stu1 = Student('小花')
stu1.study()  # 小花正在学习
# p1.study()  # AttributeError: 'Person' object has no attribute 'study'
Person.run()  # 人在跑步
Student.run()  # 学生在跑步

Person.get_up()
# ==========
# 洗漱
# 换衣服
Student.get_up()
# 类方法： <super: <class 'Student'>, <Student object>>
# ==========
# 洗漱
# 换衣服
# 背书包

p1.eat('面条')  # 小明在吃面条
stu1.eat('包子')
# 对象方法： <super: <class 'Student'>, <Student object>>
# 小花在吃包子
# 喝一杯牛奶

三、添加属性

添加属性

1.添加字段：

就直接在子类中声明新的字段

2.添加对象属性

子类是通过继承父类的init方法来继承的父类的对象属性

class Car:
    def __init__(self, color):
        print('Car:', self)
        self.color = color
        self.price = 10

    num = 10

class SportsCar(Car):

    # 修改字段的默认值
    num = 8
    # 添加字段
    wheel_qty = 4

    # 给子类添加新的对象属性
    def __init__(self, color, power):
        print('SpCar:', self)
        # 通过super()去调用父类的init方法，用来继承父类的对象属性
        super().__init__(color)  # Car对象.__init__('红色')
        self.power = power


print(Car.num)  # 10
print(SportsCar.wheel_qty, SportsCar.num)  # 4 8

# 当子类中没有什么init方法，通过子类的构造方法创建对象的时候，会自动调用父类的init方法
sp1 = SportsCar('红色', 100)
print(sp1.color, sp1.power)
# SpCar: <__main__.SportsCar object at 0x0000000002817390>
# Car: <__main__.SportsCar object at 0x0000000002817390>
# 红色 100
print(sp1)
# <__main__.SportsCar object at 0x0000000002817390>

# 练习：
# 声明一个Person类，有属性名字、年龄、和身份证号码，要求创建Person的对象的时候，
# 必须给这个名字赋值，年龄和身份证可以赋值，也可以不赋值
# 再声明一个学生类，有属性名字、年龄、身份证号码和学号、成绩,
# 要求创建学生的时候，必须给学号赋值，可以给年龄、名字赋值，不能给身份证号和成绩赋值

class Person:
    """人"""
    def __init__(self, name, age=0, identity_id=''):
        self.name = name
        self.age = age
        self.identity_id = identity_id

class Student(Person):
    """学生"""
    def __init__(self, stu_id, age=0, name=''):
        super().__init__(name, age)
        self.stu_id = stu_id
        # self.identity_id = ''  # 父类身份证号有设置默认值
        self.score = 0

stu1 = Student('stu001', 18, 'xiaoming')
stu2 = Student('stu002', 18)
stu3 = Student('stu003', name='xiaohua', age=20)
print(stu1.__dict__)  # {'name': 'xiaoming', 'age': 18, 'identity_id': '', 'stu_id': 'stu001', 'score': 0}
print(stu2.__dict__)  # {'name': '', 'age': 18, 'identity_id': '', 'stu_id': 'stu002', 'score': 0}
print(stu3.__dict__)  # {'name': 'xiaohua', 'age': 20, 'identity_id': '', 'stu_id': 'stu003', 'score': 0}

四、运算符的重载

运算符重载: 通过实现类响应的魔法方法，来让类的对象支持相应的运算符(+, -, > ,< 等)

值1 运算符 值2 ---> 值1.魔法方法(值2)

10 > 20   # int类，实现 > 对应的魔法方法 __gt__
10 < 20
['12', 2] > ['abc' , 1, 34]  # list类，实现 > 对应的魔法方法 __gt__

10 / 20   # __truediv__

20 % 10


import copy
import random

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

    #  __gt__就是 > 对应的魔法方法
    def __gt__(self, other):
        # self -> 指的是大于符号前面的值， other -> 指的是>符号后面的值
        return self.score > other.score

    # __lt__是 < 对应的魔法方法
    # 注意：gt和lt只需要实现一个就可以了
    def __lt__(self, other):
        return self.score < other.score

    def __add__(self, other):
        return self.score + other.score

    def __mul__(self, other: int):
        result = []
        for _ in range(other):
            result.append(copy.copy(self))
        return result


stu1 = Student('小哈', 23, 89)
stu2 = Student('小🌺', 19, 90)
print(stu1 > stu2)
print(stu1 < stu2)

print(stu1 + stu2)

students = stu1*10
print(students)
students[0].name = '小明'


class Person:
    def __init__(self, name='张三', age=0):
        self.name = name
        self.age = age

    def __mul__(self, other: int):
        result = []
        for _ in range(other):
            result.append(copy.copy(self))
        return result

    def __gt__(self, other):
        return self.age > other.age


    # 定制打印格式
    def __repr__(self):
        return str(self.__dict__)[1:-1]


# 同时创建10个人的对象
persons = Person()*10
# persons = 10 * Person()
# print(persons)

for p in persons:
    p.age = random.randint(15, 35)

print(persons)

# 列表元素是类的对象，使用sort对列进行排序
persons.sort()
print(persons)

print(max(persons))


class Dog:
    def __mul__(self, other):
        pass

dog1 = Dog()
dog1 * 4
# 4 * dog1  # 实现不了

五、内存管理机制

python中的内存管理 --> 自动管理 --> 垃圾回收机制

内存结构中分栈区间和堆区间，栈区间中内存是系统自动开启自动释放。堆区间的内存需要手动申请手动释放。
但是目前绝大部分编程语言，都提供了一套属于自己的关于堆中的内存的管理方案
--> python中垃圾回收机制是用来管理堆中的内存的释放

python中的数据都是存在堆中的，数据的地址都是在栈区间。

1.内存的开辟

python中将值赋给变量的是，会先在堆中开辟空间将数据存起来，然后再数据对应的地址返回给变量，存在栈中。
但是如果数据是数字和字符串，会先缓存区中查看这个数据之前是否已经创建过，如果没有就去创建空间（堆里面的缓存空间）存数据，然后将地址返回。
如果之前已经创建过就直接将之前的地址返回

注意：字符串是不可变数据，任何改变都需要先开辟空间创建一个新的字符串

2.内存的释放 --> 垃圾回收机制

系统每隔一定的时间就会去检测当前程序中所有的对象的引用计数值是否为0；
如果对象的引用计数是0对象对应的内存就会被销毁，如果不是0就不销毁

3.引用计数

每一个对象都有引用计数属性，用来存储当前对象被引用的次数。
可以通过sys模块中的getrefcount去获取一个对象的引用计数值

from sys import getrefcount
c = [1, 2]
d = [1, 2]
print(id(c), id(d))

a = 100
b = 100
print(id(a), id(b))

s1 = 'abc'
s2 = 'abc'
print(id(s1), id(s2))

aaa = [1, 2, 3]
print(getrefcount(aaa))  # 2(第一次赋给aaa,第二次通过aaa给getrecount的形参赋值，函数有参数指向列表）
print(getrefcount(aaa))  # 2（第二次调用函数，但是第一次调用的函数栈区间已经销毁，形参被销毁，引用计数减少）

1.增加引用计数：增加引用（增加保存当前对象地址的变量的个数）

a1 = ['a', 'b', 'c']
b1 = a1
list1 = [a1, 100]
print(getrefcount(a1))  # 4

2.减少引用计数

del b1  # 删除存储对象地址的变量
print(getrefcount(a1))  # 3

list1[0] = 10  # 修改存储对象地址变量的值
print(getrefcount(a1))  # 2

a1 = 100  # 列表['a', 'b', 'c']对象的引用计数减少为0，被垃圾回收机制销毁

六、认识pygame

pygame是一个用python写2D游戏的第三方库

import pygame

1.游戏初始化

pygame.init()

2.创建游戏窗口

screen = pygame.display.set_mode((600, 400))

显示一张图片

pygame.image.load(图片地址)  --> 打开一张图片，返回图片对象
"""
image = pygame.image.load('./files/luffy4.jpg')

"""
窗口.blit(图片对象,坐标) --> 坐标: (x坐标, y坐标)

"""
screen.blit(image, (100, 50))


"""
将内容贴出来
"""
pygame.display.flip()

3.创建游戏循环

flag = True
while flag:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            print('点了关闭按钮')
            # flag = False
            exit()  # 结束程序（结束线程）