1.recode
1.1.三种方法比较
对象方法:
a.直接在类中声明
b.自带一个self参数
c.使用对象调用
类方法:
a.使用@classmethod装饰器修饰.
b.自带一个cls参数
c.使用类调用
静态方法:
a.使用@staticmethod装饰器修饰
b.没有自带参数
c.使用类调用
1.2.私有化
加__,实际上加的是_类名.
1.3.getter和setter
1).getter
a.属性明前加_
b.使用@property修饰,声明一个函数,函数名就是属性名,没有其它参数.需要返回值
c.对象.属性(不带_)(才会调用getter方法)
2).setter
a.属性名加_
b.使用@getter名.setter后面声明函数,函数名就是属性名,有一个参数,不需要返回值.
c.对象.属性 = 值(才会调用setter方法)
1.4.继承
class 子类(父类):
类的内容
继承就是让子类对象直接拥有父类的属性和方法
1.5.添加方法和属性
方法添加有两种,第一完全覆盖,第二覆盖部分,在方法里面就super(),保留父类的方法
在init初始化参数时,一定要记得使用super().init(参数列表),观察父类是否要继承对象属性.
2. 多继承
2.1.多继承就是让一个类同时继承多个类
注意:实际开发,一般不使用多继承
class Animal:
role = 'animal'
def __init__(self, name='', age=0, color=''):
self.name = name
self.age = age
self.color = color
def show_info(self):
print('名字:%s年龄:%d,颜色:%s' % (self.name, self.age, self.color))
class Fly:
role = 'fly'
def __init__(self, distance=0, speed=0):
self.distance = distance
self.speed = speed
@staticmethod
def show():
print('飞多远')
class Brid(Animal, Fly):
pass
两个类的字段都可以继承,两个类的方法都能继承,对象属性只能继承第一个类的对象属性.类字段同样的话,也只继承第一个
b = Brid()
b.show_info()
b.show()
print(b.name, b.speed)
2.2.多态
类的特点: 封装,继承,多态
封装:可以对多条数据和多个功能(方法)进行封装
继承:可以让一个类拥有另外一个类的属性和方法
多态:有继承就有多态(一个事物的多种形态)
3. 运算符重载
python中函数不支持重载
2.运算符重载
python中使用运算的时候,实质是在调用相应的魔法方法.(python中每个运算符都对应一个魔法方法)
运算符重载:在不同的类中实现同一个运算符对应的魔法方法,来让类的对象支持相应的运算.
class Student(object):
def __init__(self, name='', score=0, age=0):
self.name = name
self.score = score
self.age = age
# +:运算符重载
def __add__(self, other):
# self作为第一个对象,other 为第二个对象
return self.score + other.score
# 重载减号
def __sub__(self, other):
return self.score - other.score
# 重载小于符号,并且大于符号也会关联(注意:大于和小于一般情况下,只需要重载一个,另外一个自动支持.
# 如果需要比较最大,最小时,但是类型不同的时候就会重载两个符号)
def __lt__(self, other):
return self.score < other.score
def __repr__(self):
return str(self.__dict__)[1:-1]
s1 = Student('x', 88, 18)
s2 = Student('y', 99, 16)
数据1会传给self,数据2会传个other
print(s1 + s2)
print(s1 - s2)
s3 = Student('z', 79, 19)
s4 = Student('a', 89, 14)
s5 = Student('b', 69, 13)
s6 = Student('m', 91, 11)
all_student = [s1, s2, s3, s4, s5, s6]
all_student.sort()
print(all_student)
print(max(all_student))
4.内存管理机制
4.1.堆和栈
内存区域中分堆区间和栈区间;栈区间的内存的开辟和释放是自动的,堆区间的内存是手动打开和手动释放
内存管理的是堆区间的内存;
4.2.数据的存储
a. python中所有的数据都是对象,都是保存在堆中的
b. python中所有的变量存储的都是存在堆中的数据的地址.存了对象的地址的变量又叫类的引用
c. 默认情况下创建对象就会在堆中去开辟空间存储数据,并且将地址返回值;
d. 如果对象是数字,字符串会做缓存,而且使用的时候,回去缓存中去看之前有没有存过,
如果有就直接返回之前的数据的地址,没有才开辟新的空间存储数据
4.3.数据的销毁
python中通过垃圾回收机制来管理内存的释放.
原理:看一个对象是否销毁,就看这个对象的引用计数是否为 0 .为 0 就销毁,不为 0 就不销毁
引用计数:对象的引用个数
注意:垃圾回收其实就是回收引用计数是0的对象,但是系统不会时时刻刻的检测对象的引用计数是否为 0 而是隔一段时间检测一次,如果检测到垃圾就回收
from sys import getrefcount
"""
getrefcount(对象) - 获取指定对象的引用计数
"""
print(getrefcount([1]))
# 1.增加引用计数:使用变量存对象的地址'
list1 = [1] # 对象[1]的引用计数是 1
list2 = list1 # 对象[2]的引用计数是2
list3 = [list1, 10]
print(getrefcount(list1))
# 2.减少引用计数
"""
a.删除引用
b.让当前对象的引用成为别的对象的引用
"""
del list3 # 删除引用
print(getrefcount(list1))
# 引用其他类的对象,就会以前的对象的引用计数
list2 = [3]
print(getrefcount(list1))
# 循环引用
a = [1, 2]
b = [a, 100]
a.append(b)
print(a)
当对象进行循环引用时,python根据这个自带的有自己的特有方法处理:原理是模拟删除一个对象,看是否会影响另外的对象,然后又删除这一个对象,看是否影响这一个对象,如果相互影响,该机制也会把这个相互影响的对象视为垃圾,并进行处理
5.pygame的最小系统
代码:
import pygame
# 1.初始化游戏
pygame.init()
# 2.创建游戏窗口
"""
set_mode(窗口的大小) - 一个元组,有两个元素:width,height
set_mode((宽,高))
宽度和高度:px
"""
window = pygame.display.set_mode((400, 600))
# 将窗口填充指定的参数
"""
fill(颜色) - fill((r,g,b))
计算机颜色:
计算机三原色 - 红绿蓝 (rgb) - 颜色值就是由三个数字组成,分别代表红绿蓝,数字范围是(0,255)
python中颜色是一个元组,元组中有三个原色(r,g,b)
"""
window.fill((255, 255, 0))
# 将窗口显示到设备上
# pygame.display.flip() # update方法也可以更新
pygame.display.update()
# 3.创建游戏循环,
while True:
# 4.检测事件event代表所有时间
for event in pygame.event.get():
# 区分不同的事件,做出不同的反应
if event.type == pygame.QUIT:
exit() # 结束线程
6.在窗口显示图片
代码:
import pygame
pygame.init()
window = pygame.display.set_mode((960, 800))
window.fill((255, 255, 255))
# 显示图片
# 1.加载图片
"""
pygame.image.load("图片地址") - 加载指定路径下的图片,返回一个图片对象
"""
im_obj = pygame.image.load('file/2.jpg')
# 2.渲染图片
"""
blit(渲染对象,渲染位置)
渲染对象 - 图片对象(需要显示的对象)
渲染位置 - 元组,(x , y)
"""
# window.blit(im_obj, (0, 0))
# 3.获取图片的大小
"""
图片对象.get_size() -- 功能是获取图片大小,返回值是一个元组(宽,高)
"""
print(im_obj.get_size()) # 获取图片大小
print(window.get_size()) # 获取窗口大小
window_w, window_h = window.get_size()
img_w, img_h = im_obj.get_size()
# window.blit(im_obj, ((window_w - img_w) / 2, (window_h - img_h) / 2))
# 4.图片缩放和旋转
"""
a.缩放
pygame.transform.scale(缩放对象,(大小元组)) - 将指定的图片缩放在指定的大小,返回新的图片
b.旋转缩放
pygame.transform.rotozoom(图片对象,旋转角度,缩放比例) -
"""
new_img = pygame.transform.scale(im_obj, (200, 200))
new_img2 = pygame.transform.rotozoom(im_obj, 45, 0.3)
window.blit(new_img2, ((window_w - img_w) / 2, (window_h - img_h) / 2))
pygame.display.update()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
7.在窗口显示文字
代码:
import pygame
pygame.init()
window = pygame.display.set_mode((400, 600))
window.fill((255, 255, 0))
# ==========显示文字==========
# 1.创建字体对象
"""
a.系统字体
pygame.font.SysFont(字体名,字体大小,是否加粗,是否斜体) - 返回对象
b.自定义字体
pygame.font.Font(字体文件路径,字体大小)
"""
# font = pygame.font.SysFont('Times', 30, True, True)
font = pygame.font.Font('file/aa.ttf', 40)
# 2.创建文字对象
"""
render(文字内容(需要显示内容),是否平滑,文字颜色)
"""
text = font.render('Hello,Pygame.你好呀', True, (255, 0, 0))
# 3.将文字渲染到窗口上
window.blit(text, (0, 100))
pygame.display.update()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
8.显示图形
代码:
import pygame
from color import Color
import math
pygame.init()
window = pygame.display.set_mode((400, 600))
window.fill((255, 255, 0))
# ===============显示图形==============
# 1.画直线
"""
line(画的对象,线的颜色,起点,终点,线宽(默认为1))
"""
pygame.draw.line(window, Color.green, (0, 0), (100, 100), 20)
"""
lines(画的对象,线的颜色,是否闭合,点列表,线宽) - 依次连接点列表的所有点(是否闭合,就是决定是否连接终点和起点)
"""
points = [(10, 100), (10, 180), (100, 180), (300, 100), (30, 0)]
pygame.draw.lines(window, Color.red, True, points, 2)
# 2 画圆
"""
circle(画的对象,颜色,圆心,半径,线宽)
注意:线宽为0的时候画的是实心圆
"""
pygame.draw.circle(window, Color.black, (200, 200), 100, 0)
# 3.画弧线
"""
arc(画的对象,颜色,矩形,起始弧度,终止弧度,线宽 = 1)
矩形就是一个元组 - (x,y,宽,高)
"""
pygame.draw.arc(window, Color.blue, (150, 300, 100, 50), math.pi / 4 * 5, math.pi / 4 * 7, 2)
pygame.display.update()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()