知识回顾
1.静态方法和类方法、对象方法
对象方法：
直接声明在类中
自带的self参数
对象来调用
实现函数的功能需要用到对象的属性
类方法：
声明在@classmethod的下面
自带cls参数
类来调用
实现函数的功能需要使用到类（类的字段）
静态方法：
声明在@staticmethod的下面
没有自带的参数
类来调用
实现函数功能既不需要对象属性也不需要类的字段
2.属性的私有化
在属性名或方法名前加__
3.对象属性的保护（添加getter和setter方法）
类的继承
python中的类支持继承，并且支持多继承
1.什么是继承
父类（超类）：被继承的类
子类：去继承父类的类
继承就是让子类去直接用父类的属性和方法（注意：继承后父类的东西不会减少）。
python中所有的类都是直接或者间接的继承自object类
2.怎么继承
class 类名(父类)：...
class 类名： == class 类名(object):
3.能继承那些东西
对象属性、对象方法、类的字段、类方法、静态方法都可以继承
注意：如果设置了__slots__会约束当前类的对象属性，并且会导致当前对象的__dict__属性不存在
继承后，__slots__的值不会约束到子类的对象属性，但是会导致子类的对象的__dict__只有在当前类中添加的属性
class Person:
num = 20
__numbers = 30
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))
@classmethod
def show_num(cls):
print('人类数量：%d' % cls.num)
@staticmethod
def func1():
print('person静态方法')
class Student(Person):
pass
# 创建Student类的对象
stu1 = Student()
print(stu1.name, stu1.age)
stu1.eat('面')
print(Student.num)
print(Student.show_num())
Student.func1()
print(stu1.__dict__)
重写
继承后子类会拥有父类的属性和方法，也可以添加属于自己的属性和方法
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()当前类的父类的对象
super().eat(food)
print('喝牛奶')
@staticmethod
def run():
print('学生在跑步')
@classmethod
def get_up(cls):
# super() --> 获取当前类的父类
# super().get_up() --> 调用父类的get_up的功能
super().get_up()
print('背书包')
stu1 = Student()
stu1.study()
p1 = Person()
Person.run()
stu1.run()
Person.get_up()
stu1.get_up()
p1.eat('面')
stu1.eat('面')
添加属性
添加属性：
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, color):
# 通过super()去调用父类的init方法，用来继承父类的对象属性
super().__init__(color)
self.horsepower = 0
print(Car.num)
print(SportsCar.num, SportsCar.wheel_count)
# 当子类中没有声明init方法，通过子类的构造方法创建对象的时候会自动调用父类的init方法
sp1 = SportsCar('红色')
print(sp1.color)
练习：
声明一个Person类，有属性名字、年龄和身份证号码。
要求创建Person的对象的时候，必须给名字赋值，年龄和身份证可以赋也可以不赋
声明一个学生类，有属性名字、年龄、身份证号号码和学号、成绩（用继承）
要求创建学生的时候必须给学号赋值，可以给年龄、名字赋值，不能给身份证号号和成绩赋值
class Person:
def __init__(self, name, age=0, p_id=''):
self.name = name
self.age = age
self.p_id = p_id
class Student(Person):
def __init__(self, stu_id, name='', age=0):
super().__init__(name, age)
self.stu_id = stu_id
self.score = 100
stu1 = Student('stu001')
stu2 = Student('stu002', '小明')
stu3 = Student('stu003', '小红', 20)
print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
运算符重载
运算符重载：通过实现类相应的魔法方法，来让类的对象支持相应的运算符
值1 运算符 值2 --> 值1.魔法方法(值2)
import copy
import random
10 > 20 # int类，实现了相应的魔法方法，__gt__
1 + 2
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
stu1 = Student('小明', 20, 90)
stu2 = Student('小花', 22, 89)
print(stu1 > stu2)
print(stu1 < stu1)
print(stu1 + stu2)
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 __repr__(self):
return str(self.__dict__)[1:-1]
def __gt__(self, other):
return self.age > other.age
# 同时创建10个人的对象
persons = Person() * 10
for p in persons:
p.age = random.randint(15, 30)
# 类表元素是类的对象，使用sort对列表进行排序
persons.sort()
print(persons)
print(max(persons))
class Dog:
def __init__(self):
self.name = '旺旺'
self.age = 0
def __mul__(self, other):
result = []
for _ in range(other):
result.append(copy.copy(self))
return result
dog1 = Dog()
print(dog1 * 4)
# 4 * dog1 实现不了
内存管理机制
python中的内存管理 --> 自动管理 --> 垃圾回收机制
内存结构中分栈区间和堆区间，栈区间中的内存是系统自动开启自动释放。堆区间的内存需要手动申请手动释放、
但目前绝大部分编程语言，都提供了一套属于自己的关于堆中的内存的管理方案 --> python中的垃圾回收机制是用来管理堆中的内存的释放
python中的数据都是在存在堆中的，数据的地址都是在栈区间。
1.内存的开辟
python中将值赋给变量的时候，会先在堆中开辟空间将数据存起来，然后再将数据对应的地址返回给变量，存在栈中。
但是如果数据是数字和字符串，会先在缓存区中查看这个数据之前是否已经创建过，如果没有就去创建空间存储数据，然后将地址返回
如果之前已经创建过就直接将之前的地址返回
2.内存的释放 --> 垃圾回收机制
系统每隔一定的时间就会去检测当前程序中所有的对象的引用计数值是否为0，
如果对象的引用计数是0对象对应的内存就会被销毁，如果不是0就不销毁
3.引用计数
每一个对象都有引用计数属性，用来存储当前对象被引用的次数。
可以通过sys模块中的getrefcount去获取一个对象的引用计数的值
增加引用计数：
from sys import getrefcount
aaa = [1, 2, 3]
print(getrefcount(aaa))
aaa1 = [1, 2, 3]
print(getrefcount(aaa1))
b = 10
print(getrefcount(b))
c = 10
print(getrefcount(c))
1.增加引用计数:增加引用（增加保存当前对象的地址的变量的个数）
a1 = ['abc']
b1 = a1
list1 = [a1, 100]
print(getrefcount(a1))
2.减少引用计数
del b1 # 删除存储对象地址的变量
print(getrefcount(a1))
list1[0] = 10 # 修改存储对象的地址变量的值
print(getrefcount(a1))
认识pygame
pygame是一个用python写2D游戏的第三方库
import pygame
### 1.游戏初始化
pygame.init()
### 2.创建游戏窗口
screen = pygame.display.set_mode((1000, 700))
# 显示一张图片
"""
pygame.image.load(图片地址) --> 打开一张图片，返回图片对象
"""
image = pygame.image.load('./files/1.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() # 程序结束(结束线程)
