day15 - 面向对象和pygame(总结)

1.recode

1.1.类方法和静态方法
对象方法：
a.直接申明在类中
b.自带self参数
c.使用对象调用
类方法
a.申明在@classmethod后面
b.自带cls参数
c.使用类来调用
静态方法：
a.申明在@staticmethod后面
b.没有自带的参数
c.使用类来使用
1.2.私有化
加__
1.3.getter和setter
a.申明属性名前加一个_
b.@property后面申明函数，函数名就是不加下划线的属性名，没有其他参数，需要返回值
c.对象.属性（不带下划线）
a.属性名加_
[email protected]后面申明函数，函数名就是属性名，有一个参数，不需要返回值
c.对象.属性（不带_） = 值
1.4.继承

class 子类（父类）：
    类的内容

继承就是让子类直接拥有父类的属性和方法（除了slots）
5.添加方法和属性

2.多继承

2.1.多继承
多继承：让一个类同时继承多个类
注意:实际开发的时候，一般不使用多继承

#同时继承Animal和Fly
#两个类的字段都能继承
#两个类的方法都能继承
#对象属性只能继承第一个类的对象的属性


class Animal(object):
    num = 89
    def __init__(self, name= '1', age = 0 , color='2'):
        self.name = name
        self.age = age
        self.color = color
    # def show_info(self):
    #     print(name,age,color)


class Fly(object):
    num = 77
    in_fo = '飞'
    def __init__(self,distance = 0, speed=0):
        self.distance = distance
        self.speed = speed
    @staticmethod
    def show():
        print('huifei')

2.2.多态
类的特点：封装、继承和多态
封装：可以多多条数据(属性)和多个功能(方法)进行封装
继承：支持继承，可以让一个类拥有另外一个类的属性和方法
多态：有继承就有多态（一个事物的多个形态）

3.运算符重载

3.1.别的语言的函数和函数的重载
c++/java申明函数的语法:
返回值类型 函数名（参数列表）{函数体}
int func1(){}
void func1(int a){}
int func1(int a,int b){}
上面几个函数是不同的函数，并且可以同时存在

python中的函数不支持重载，

def func1():
    pass
def func1(a):
    pass
def func1(a,b):
    pass

最终只保留最后这个一个func1,前面的会被覆盖
2.运算符重载
python中使用运算符的时候，实质是在调用相应的魔法方法（python中每个运算符都对应一个魔法方法）
运算符重载：在不同的类中实现同一个运算符对应的魔法方法，来让类的对象支持相应的运算

class Student(object):
    def __init__(self, name='', score= 0, age=0):
        self.name = name
        self.age = age
        self.score =score
    #数据1 + 数据2 -- 数据1会传给self ,后面的数据2传给other

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

    def __sub__(self, other):
        return self.age - other.age
    #注意：大于和小于一般情况下只需要重载一个，另外一个自动支持

    def __lt__(self, other):
        return self.score < other.score

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

    def __repr__(self):
        return str(self.__dict__)[1:-1]+'\n'


stu1 = Student('小花', 90, 16)
stu2 = Student('小明', 80, 18)
stu3 = Student('小', 8, 8)
stu4 = Student('明', 85, 19)
print(stu1 + stu2)
print(stu1 - stu2)
all_student = [stu1, stu2, stu3, stu4]
all_student.sort()
print(all_student)
print(stu1 != stu2)

4.内存管理机制

4.1.堆和栈
内存区域中分为堆区间和栈区间；栈区间的内存的开辟和释放是自动的，堆区间的内存是手动开辟和释放的,内存管理管理的是堆区间的内存；
4.2.数据的存储
a.python中所有的数据都是对象，都是保存在堆中的
b.Python中所有的变量存储的都是存在堆中的数据的地址，存了对象的地址的变量又叫对象的引用
c.默认情况下创建对象就会在堆区间开辟空间存储数据，并且将地址返回；如果对象是数字或者字符串会做缓存，而且使用的时候会先去缓存中看之前有没有存过，如果有直接返回之前的数据的地址，没有才开辟新的空间存储数据
4.3.数据的销毁
python中通过“垃圾回收机制”来管理内存的释放
原理：看一个对象是否销毁，就看这个对象的引用计数是否为0，为0就销毁，不为0就不销毁
引用计数：对象的引用个数
注意：垃圾回收其实就是回收引用计数是0的时候，但是系统不会时时刻刻去检测对象的引用计数是否是0,而是隔一段时间检测一次，如果检测到垃圾就回收

# 1.增加引用计数:使用变量存对象的地址
from sys in gerefcount
getrefcount(对象) - 获取指定对象的引用计数
from sys import getrefcount
list1 = [1]  # 对象[1]的引用计数是1
print(getrefcount(list1))
list2 = list1  # 对象[1]的引用计数是2
print(getrefcount(list2))
list3 = [list1, 100]  # 对象[1]的引用计数是3
print(getrefcount(list3))
# 2. 减少引用计数
"""
a.删除引用
b.让当前对象的引用成为别的对象的引用
"""
del list3[0]
list2 = 100
print(getrefcount(list2))
print(id(list2))
# 3.
list2 = 100
print(getrefcount(list2))
print(id(list3))
print(id([]), id({}), id(()))

5.pygame的最小系统

set_mode(窗口的大小) - 窗口大小是一个元组，有两个元素，分别是width,height
set_mode((宽度，高度）) - 宽度和高度的单位是像素
fill(颜色) - fill((r,g,b))
计算机颜色：计算机三原色 - 红，绿，蓝（r,g,b)
颜色值就是由三个数字组成，分别代表红，绿，蓝;数字范围是：0-255
python中的颜色是一个元组，元组中有三个颜色，分别是r,g,b
(255,255,255) - 白色
（0,0,0） - 黑色
（255,0,0） - 红色
（0,255,0） - 绿色

import pygame
# 1.游戏初始化
pygame.init()
# 2.创建游戏窗口
window = pygame.display.set_mode((400, 400))
# 将窗口填充成指定的颜色
window.fill((255, 255, 255))
# 将窗口展示在屏幕上
pygame.display.flip()
# 3.创建游戏循环
while 1:
    # 4.检测事件
    for event in pygame.event.get():
        # 5.区分不同的事件，做出不同的反应
        # 判断关闭按钮点击事件是否发生
        if event.type == pygame.QUIT:
            exit()
        # print(event)

6.在窗口上显示图片

6.1.加载图片
pygame.image.load(图片地址) - 加载指定路径下的图片，返回一个图片对象

image_obj = pygame.image.load('1/IMG20181104100829.jpg')

6.2.渲染图片
window.blit(渲染对象，渲染位置)
渲染对象 - 图片对象（显示什么）
位置 - 元组(x,y)
6.3.获取图片大小
对象.get_size() - 获取图片大小，返回值是一个元组：（width,height）

image_w, image_h = image_obj.get_size()

window.blit(image_obj, (400-image_w*0.5, 400-image_h*0.5))

6.4.图片缩放和旋转
a.缩放
pygame.transform.scale(缩放对象，（x,y）) - 将指定的图片缩放到指定的大小,返回新的图片
b.旋转缩放
pygame.transform.rotozoom(缩放对象，旋转角度，缩放比例)

new_image1 = pygame.transform.rotozoom(image_obj, 0, 0.2)
new_image = pygame.transform.scale(image_obj, (200, 200))
window.blit(new_image, (200, 200))
window.blit(new_image1, (100, 200))

7.在窗口上显示文字

7.1.创建字体对象（选笔）
a.系统字体
pygame.font.SysFont(字体名，字体大小，是否加粗bold=False,是否倾斜italic=False) - 返回字体对象
b.自定义字体
pygame.font.Font(字体文件路径，字体大小)

font = pygame.font.SysFont('Times', 20, bold=True, italic=True)
font1 = pygame.font.Font('1/aa.ttf', 40)

7. 2.根据字体创建文字对象
   render(文字内容，是否平滑，文字颜色) -

text1 = font1.render('hello,pygame您好', True, (255, 0, 0))
text = font.render('hello,pygame', True, (255, 0, 0))
text2 = font1.render('hello,pygame', False, (255, 0, 0))

7. 3.将文字渲染到窗口上

window.blit(text, (100, 100))
window.blit(text1, (200, 200))
window.blit(text2, (300, 300))

8.显示图形

8. 1.画直线
   line(位置，线的颜色, 起点， 终点， 线宽)
   lines(位置，线的颜色， 是否闭合， 点列表 ,线宽)
   一次连接点列表中所有的点（是否闭合决定是否连接起点和终点）

points = [(10, 10), (100, 20), (100, 100), (60, 230), (100, 520)]
pygame.draw.line(window, Color.green, (0, 0), (400, 400), 10)
pygame.draw.lines(window, Color.red, True, points, 5)

8.2.画圆

circle(位置，颜色，圆心坐标，半径, 线宽)
注意：线宽为0的时候画的是实心圆

pygame.draw.circle(window, Color.red, (400, 400), 50, 25)

8. 3.画圆弧
   arc(位置，颜色，矩形框，起始弧度，终止弧度，线宽)
   矩形 - （x,y,width,height）x,y是矩形左上角的坐标，width,height是矩形的宽和高

# pygame.draw.ellipse()
pygame.draw.rect(window,Color.black,(100,100,50,50),5)
pygame.draw.arc(window, Color.blue, (300, 500, 200, 100), math.pi*1/4, math.pi*7/4,20)

9.事件和动画

不同的type值对应不同类型的事件
QUIT - 关闭按钮被点击事件
a.鼠标相关事件 - 按的位置
MOUSEMOTION - 鼠标移动
MOUSEBUTTONDOWN - 鼠标按下
MOUSEBUTTOUP - 鼠标弹起
event.pos - 获取鼠标事件产生的位
b.键盘事件 - 按的是哪个键
KEYDOWN - 按键按下
KEYUP - 按键弹起
event.key - 被按的键对应的字符的编码值

x = 100
y = 100
width = 100
height = 80
pygame.draw.rect(window, Color.green, (x, y, width, height))

pygame.display.flip()

while True:

    y += 3
    # width -= 2
    window.fill(Color.white)  # 覆盖原来的状态
    pygame.draw.rect(window, Color.rand_color(), (x, y, width, height))
    pygame.display.update()   # 重新显示

    # 有事件产生的时候才会进入for循环
    for event in pygame.event.get():
        # 1.type属性
        """
       
        """
        if event.type == pygame.QUIT:
            exit()

        elif event.type == pygame.MOUSEMOTION:
            # print('鼠标移动', event.pos)
            # pygame.draw.circle(window, Color.rand_color(), event.pos, 30)
            # pygame.display.flip()
            pass
        elif event.type == pygame.MOUSEBUTTONDOWN:
            # 鼠标按下要做什么就写在这儿
            print('鼠标按下', event.pos)
            pygame.draw.circle(window, Color.rand_color(), event.pos, 30)
            pygame.display.flip()
        elif event.type == pygame.MOUSEBUTTONUP:
            print('鼠标弹起!', event.pos)

        elif event.type == pygame.KEYDOWN:
            print('按键按下')
            print(event.key, chr(event.key))

        elif event.type == pygame.KEYUP:
            print('按键弹起')
            print(event.key, chr(event.key))
···