一、类的继承

python中的类支持继承，并且支持多继承(一般不使用)

1.什么是继承

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

---

2.怎么继承

class 类名(父类):...
class 类名: == class 类名(object)

---

3.能继承哪些东西

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

代码

class Person():
    num = 60
    __slots__ = ('name', 'age', '__sex')

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

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

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

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


class Student(Person):
    pass

#创建学生类的对象
stu1 = Student()
print(stu1.name, stu1.age)
stu1.eat('面条')

print(stu1.num)
stu1.show_num()
stu1.func1()

print(stu1.__dict__)
stu1.id = '001'

测试结果

1.PNG

---

二、重写

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

1.添加新的方法

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

2.重写

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

3.类中的函数的调用过程

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

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

代码

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

    def eat(self, food):
        # self = super()
        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():当前类的父类的对象
        super().eat(food)
        print('喝一杯牛奶！')

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

    @classmethod
    def get_up(cls):
        # super() -> 获取当前类的父类
        # super().get_up() -> 调用父类的get_up方法
        super().get_up() # 可以保留父类get_up的功能
        print('背书包')


p1 = Person()

p1.get_up()
p1.name = '小红'
p1.eat('面条')

stu1 = Student()

stu1.get_up()
stu1.study()
stu1.run()

stu1.name = '小花'
stu1.eat('面包')

测试结果

1.PNG

---

三、添加属性

1.添加字段

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

2.添加对象属性

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

代码

class Car:
    num = 10

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


class SportsCar(Car):
    # 修改字段的默认值
    num = 8
    # 添加字段
    wheel_count = 4

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


print(Car.num)
print(SportsCar.num, SportsCar.wheel_count)

# 当子类中没有声明init方法，通过子类创建对象的时候会自动调用父类的init方法。
sp1 = SportsCar(100, '黑色')
print(sp1.color)

测试结果

1.PNG

练习：

声明一个Person类，有属性名字、年龄和身份证号码。
要求创建Person的对象的时候，必须给名字赋值，年龄和身份证可以赋值也可以不赋。

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

代码

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


class Student(Person):
    def __init__(self, study_id, name='', age=0):
        super().__init__(name, age)
        self.study_id = study_id
        self.score = 95


stu1 = Student('张三', 20)
print(stu1.name, stu1.age, stu1.sid, stu1.score)

测试结果

2.PNG

---

四、运算符的重载

1.运算符的重载

运算符重载：通过实现类相应的魔法方法，来让类的对象支持相应的运算符。(+、-、*、/等)

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

代码

import copy
import random

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


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

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

    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))

测试结果

---

五、内存管理机制

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

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

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

1.内存的开辟

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

代码

c = [1, 2]
d = [1, 2]
print(id(c), id(d))

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

e = 'abc'
f = 'abc'
print(id(e), id(f))

测试结果

1.PNG

---

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

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

代码

from sys import getrefcount

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

bbb = 10
print(getrefcount(bbb))

ccc = 10
print(getrefcount(ccc))

测试结果

2.PNG

---

3.引用计数

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

代码

# 1.增加引用计数：增加引用(增加保存当前对象地址的变量的个数)
a1 = ['abc']
b1 = a1
list1 = [a1, 100]
print(getrefcount(a1))

# 2.减少引用计数
a1 = ['abc']
b1 = a1
list1 = [a1, 100]

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

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

测试结果

3.PNG

---

六、认识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/tp.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()  # 结束程序(结束线程)

测试结果

1.PNG

---

七、歌词解析器

代码

class Time_Lyric:
    def __init__(self, time, word):
        self.time = time
        self.word = word

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


class Analysis:
    def __init__(self, song_name):
        self.song_name = song_name
        self.all_lyric = []
        self.read_file()

    def get_time_word(self, content):
        contents = content.split(']')
        word = contents[-1]
        for time in contents[:-1]:
            times = time[1:].split(':')
            minute = float(times[0])
            second = float(times[1])
            new_time = minute * 60 + second
            time_lyric = Time_Lyric(new_time, word)
            self.all_lyric.append(time_lyric)

    def read_file(self):
        try:
            with open('./files/%s.txt' % self.song_name, 'r', encoding='utf-8')as f:
                line = f.readline()
                while line:
                    self.get_time_word(line)
                    line = f.readline()
                    self.all_lyric.sort(reverse=True)
        except FileNotFoundError:
            print('文件不存在！')

    def get_word(self, time):
        for lyric in self.all_lyric:
            if lyric.time <= time:
                return lyric.word


r1 = Analysis('蓝莲花')
print(r1.get_word(35))

测试结果

1.PNG

---