1.类的继承
python中类 支持继承，并且支持多继承（）
1.什么是继承
父类（超类）：被继承的类

子类：继承的类，去继承父类的类

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

2.怎么继承
class 类名（父类）:
class 类名：== class 类名（object）

3.能继承那些东西
对象属性，对象方法，类的字段，类方法，静态方法都可以继承

注意：如果设置了slots会约束了当前对象属性，并且会导致当前类的dict属性不存在
继承后，slots不会约束到子类的对象属性，但是会导致子类对象的dict
只有在继承后当前的类中新添加的属性才能被dict检测到
代码示例

class Person(object):
    num = 61
    __number = 61

    def __init__(self, name='小明', age=0):
        self.name = name
        self.age = age
        self.__sex = ''

    def eat(self, food: str):
        print('再吃%s' % food)

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

    @classmethod
    def show_num(cls):
        print('%d' % cls.num)


class Student(Person):
    pass


# 创建对象
stu = Student()
print(stu.name, stu.age)
stu.eat('面条')
Student.func1()
Student.show_num()
print(stu.__dict__)
运行结果
小明 0
再吃面条
Person的静态方法
61
{'name': '小明', 'age': 0, '_Person__sex': ''}

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

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('换衣服')


class Student(Person):

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

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

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

    @classmethod
    def get_up(cls):
        # super() --> 获取当前类的父类
        # super().get_up()  -->  调用父类的get_up方法
        print('类方法', super(), super)
        super().get_up()
        # cls.__bases__[0].get_up()
        print('背书包')


stu = Student()
stu.study()
Student.run()
print('=========')
Student.get_up()

stu.name = '小红'
stu.eat('面包')
运行结果
在学习
学生在跑步
=========
类方法 <super: <class 'Student'>, <Student object>> <class 'super'>
洗漱
换衣服
背书包
对象方法 <super: <class 'Student'>, <Student object>> <class 'super'>
小红再吃面包
喝一杯牛奶

3.添加属性
添加属性
1.添加字段
就直接在子类中声明新的字段

2.添加对象属性
子类是通过继承父类的init来继承的父类的对象属性
代码示例

class Car:
    num = 10

    def __init__(self, color):
        self.color = color
        self.price = 10


class SportsCar(Car):
    # 修改字段默认值
    num = 8
    # 添加字段
    weel_count = 4
    # 给子类添加新的对象属性

    def __init__(self, color, horsepower):
        # 通过super()去调用父类的init方法，用来继承父类的对象属性
        super().__init__(color)
        self.horsepower = horsepower


print(Car.num)
SportsCar.num = 19
print(SportsCar.num, SportsCar.weel_count)

当子类没有声明init方法，通过子类的构造方法创建对象的时候会自动调用父类的init方法

sp1 = SportsCar('白色', 4)
print(sp1.color)
print(sp1.__dict__)
print(sp1.horsepower)
运行结果
10
19 4
白色
{'color': '白色', 'price': 10, 'horsepower': 4}

4
练习
练习：声明一个Person类，有属性名字、年龄和身份证号码。要求创建Person的时候

必须给名字赋值，年龄和身份证可以赋值也可以不赋

声明一个学生类、有属性名字、年龄、身份证号码和学号，成绩（用继承）
要求创建学生的时候，必须给学号赋值，可以给年龄，名字赋值，不能给身份证号、成绩赋值
代码如下

class Person:

    def __init__(self, name, age=0, id='0000'):
        self.name = name
        self.age = age
        self.id = id


class Student(Person):

    def __init__(self, sno, age=0, name=''):
        self.sno = sno
        self.score = '45'
        super().__init__(name, age)


Person('小明')
Person('小红', 45)
Person('小红', 45, '0001')
Student('01')
Student('01', name='小华')
Student('01', 18, name='小华')

4.运算符的重载
运算符重载：通过实现类相应的魔法方法，来让类的对象支持相应的运算符（+，-，>，<等）

值1 运算符 值2 ----> 值1.魔法方法（值2）
代码示例

import copy
import random

10 > 20  # int类，实现 > 对应的魔法方法 __gt__


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

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

    # 小于符号对应的魔法方法，
    # 注意：__gt__和__lt__两个方法只需要实现一个就可以了
    # def __lt__(self, other):
    #     return self.age < other.age

    def __add__(self, other):
        return [self.name, other.name]

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


stu = Student('夏普', 23, 65)
stu1 = Student('选举', 56, 88)
print(stu > stu1)
print(stu < stu1)
print(stu + stu1)
student = stu * 10
print(student)
for stu in student:
    print(stu.name)


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

    def __mul__(self, other):
        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]


p1 = Person() * 10
for p in p1:
    p.age = random.randint(15, 35)
print(p1)
# 列表元素是类的对象，对列表进行排序
p1.sort()
print(p1)
print(max(p1))


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

    def __mul__(self, other):
        result = []
        for _ in range(other):
            result.append(copy.copy(self))
        return result
运行结果
夏普 选举
False
选举 夏普
True
['夏普', '选举']
[<__main__.Student object at 0x0000029CCDE3CBE0>, <__main__.Student object at 0x0000029CCDEB7320>, <__main__.Student object at 0x0000029CCDEB72E8>, <__main__.Student object at 0x0000029CCDEC0978>, <__main__.Student object at 0x0000029CCDEC0668>, <__main__.Student object at 0x0000029CCDEC0208>, <__main__.Student object at 0x0000029CCDEC06A0>, <__main__.Student object at 0x0000029CCDEC0940>, <__main__.Student object at 0x0000029CCDEC07F0>, <__main__.Student object at 0x0000029CCDEC0828>]
夏普
夏普
夏普
夏普
夏普
夏普
夏普
夏普
夏普
夏普
['name': '张三', 'age': 22, 'name': '张三', 'age': 29, 'name': '张三', 'age': 26, 'name': '张三', 'age': 23, 'name': '张三', 'age': 34, 'name': '张三', 'age': 28, 'name': '张三', 'age': 17, 'name': '张三', 'age': 16, 'name': '张三', 'age': 22, 'name': '张三', 'age': 15]
['name': '张三', 'age': 15, 'name': '张三', 'age': 16, 'name': '张三', 'age': 17, 'name': '张三', 'age': 22, 'name': '张三', 'age': 22, 'name': '张三', 'age': 23, 'name': '张三', 'age': 26, 'name': '张三', 'age': 28, 'name': '张三', 'age': 29, 'name': '张三', 'age': 34]
'name': '张三', 'age': 34

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

内存结构中分栈区间和堆区间，栈区间中的内存是系统自动开启自动释放
堆区间的内存需要手动申请，手动释放

但是目前绝大部分编程语言都提供了一套属于自己的关于堆中的内存管理方案
----> python中垃圾回收机制是用来管理堆中的内存的释放

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

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

2.内存的释放 ---> 垃圾回收机制
系统每隔一定的时间就会去检测当前程序中所有的对象的引用计数值是否为0，如果对象的引用计数
为0，对象对应的内存就会被销毁，如果不是就不会被销毁

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

增加引用计数：
代码示例

from sys import getrefcount

s1 = 100
s2 = 100
print(id(s1), id(s2))
s1 = 99
print(id(s1), id(s2))

aaa = [1, 2]
print(getrefcount(aaa))

b = 10
print(getrefcount(b))
c = 10
print(getrefcount(c))

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

a1 = ['abc']
b1 = a1
list1 = [a1, 100]
print(getrefcount(a1))

2.减少引用计数

del b1  # 删除存储对象地址的变量
list1[0] = 1  # 修改存储对象地址变量的值
print(getrefcount(a1))
运行结果
1471117424 1471117424
1471117392 1471117424
2
18
19
4
2
6.认识pygame
pygame是一个用python写2D游戏的第三方库
代码示例
import pygame

# 1.初始化游戏
pygame.init()

# 2.创建游戏窗口
screen = pygame.display.set_mode((480, 700))

# 显示图片
image = pygame.image.load('image/d.jpg')  # ---> 打开一张图片，返回图片对象

"""
窗口.blit(图片对象，位置) ---> 坐标：（x, y）
"""
screen.blit(image, (0, 0))

pygame.display.flip()  # 将数据展示在窗口上

# 3.创建游戏循环
flag = True
while flag:
    for event in pygame.event.get():  # 获取事件
        if event.type == pygame.QUIT:
            print('点了关闭按钮')
            # flag = False
            exit()  # 结束程序（结束线程）