一、对象和类
类(Class)是现实或思维世界中的实体在计算机中的反映,它将数据以及这些数据上的操作封装在一起。
对象(Object) 是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。
类是一个比较抽象的概念,对象是一个具体化的结果。也可以说类(Class)是创建实例的模板;对象(Object)是一个一个具体的实例。例如:类和对象的区别就是鱼和三文鱼的区别; 就是猫和蓝猫的区别。
·1如何定义类?
class 类(): pass
·2如何将类转换成对象?
实例化是指在面向对象的编程中,把用类创建对象的过程称为实例化。是将一个抽象的概念类,具体到该类实物的过程。实例化过程中一般由对象名 = 类名(参数1,参数2…参数n)构成。
类的定义和对象的创建:
#class 类名称: 定义类的方式 :class 类(): pass
class Person:
#占位关键字,不做任何操作
pass
print(Person) #类,<class '__main__.Person'>,存储于当前脚本的person类
#对象:将实例化/具体化产生的值
#<__main__.Person object at 0x7effcb5c2610>
#存储于当前脚本的person类实例化出来的对象存储于内存地址0x7effcb5c2610中
person0bj = Person() #对象名 = 类名(参数1,参数2...参数n)
print(person0bj)
二、封装的特性
面对对象的三大特性是指:封装、继承、多态
1、封装
封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。
所以,在使用面向对象的封装特性时,需要:
1). 将内容封装到某处
2). 从某处调用被封装的内容
(1). 通过对象直接调用被封装的内容: 对象.属性名
(2). 通过self间接调用被封装的内容: self.属性名
(3). 通过self间接调用被封装的内容: self.方法名()
构造方法:init
构造方法__init__与其他普通方法不同的地方在于,当一个对象被创建后,会立即调用构造方法。自动执行构造方法里面的内容。
封装特性–构造方法的理解
#构造方法__init__和其他方法不同的地方在于,当一个对象被创建之后(实例化),
#会自动执行构造方法里面的内容
#创建类
class Student:
#实例化对象的过程中自动执行构造方法里面的内容
def __init__(self): #self为形参,此处为定义函数
#self可以任意修改,默认使用self
#self实质指的是实例化出来的对象,系统自动将示例化的对象传递给构造方法
print('self:',self) #self <__main__.Student object at 0x7ff8f9089dd0>
print("正在执行构造方法......")
print(Student) #<class '__main__.Student'>
#创建对象
stu1 = Student() #stu1 <__main__.Student object at 0x7ff8f9089dd0>
print('stu1:',stu1)
正在执行构造方法......
stu1: <__main__.Student object at 0x0000025E78FAEE48>
注意:对于面向对象的封装来说,其实就是使用构造方法将内容封装到对象中,然后通过对象直接或者self间接获取被封装的内容。
类和对象练习题
创建一个类People,拥有的属性为姓名,性别和年龄,拥有的方法为购物,玩游戏,学习;实例化对象,执行相应的方法。显示如下:
小明,18岁,男,去西安赛格购物广场购物
小王,22岁,男,去西安赛格购物广场购物
小红,10岁,女,在西部开源学习
class People:
print("定义的类正在执行......") #和定义函数不同,定义类会执行类的内容,不会执行内里面定义的函数
def __init__(self, name, gender, age):
# 将对象和属性封装在一起
self.name = name
self.gender = gender
self.age = age
def shopping(self):
#通过self.属性名/对象名.属性名(self = 对象)获取封装的属性信息
return self.name + ',' + self.age + '岁' + ',' + self.gender + ',' + "去西安赛格购物广场购物"
def playGame(self):
return self.name + ',' + self.age + '岁' + ',' + self.gender + ',' + "去网咖玩游戏"
def learning(self):
return self.name + ',' + self.age + '岁' + ',' + self.gender + ',' + "去西部开源学习"
stu1 = People(name='小明', age='18', gender='男')
stu2 = People(name='小王', age='22', gender='男')
stu3 = People(name='小红', age='10', gender='女')
#对象名.方法名调用方法
print(stu1.shopping()) #此处不需要传递参数,系统自动将参数传递过来
print(stu2.playGame())
print(stu3.learning())
定义的类正在执行......
小明,18岁,男,去西安赛格购物广场购物
小王,22岁,男,去网咖玩游戏
小红,10岁,女,去西部开源学习
三、继承特性
(1)、什么是继承?
继承描述的是事物之间的所属关系,当我们定义一个class的时候,可以从某个现有的class 继承,新的class称为子类、扩展类(Subclass),而被继承的class称为基类、父类或超类(Baseclass、 Superclass)。
(2)、如何让实现继承?
子类在继承的时候,在定义类时,小括号()中为父类的名字
(3)、继承的工作机制是什么?
父类的属性、方法,会被继承给子类。 举例如下: 如果子类没有定义__init__方法,父类有,那 么在子类继承父类的时候这个方法就被继承了,所以只要创建对象,就默认执行了那个继承过来的 __init__方法。
1、单继承
单继承指的是在创建类的过程中只继承了一个父类。当python中没有指定父类,默认继承的是object
#在python中没有指定父类,默认继承的是object
#父类:object 子类:Student
class Student(object):
#将对象和属性封装在一起
def __init__(self,name,age,gender):
self.name = name
self.age = age
self.gender = gender
def learn(self):
print("%s正在学习...." %(self.name))
#父类:Student 子类:MathStudent
#继承了父类的属性和方法(构造方法和定义的方法)
class MathStudent(Student):
pass
#实例化对象的过程会执行构造方法里面的内容
stu1 = MathStudent(name='牛顿', age='1000', gender='male')
#MathStudent没有构造方法,继承并执行父类Student的构造方法
stu1.learn()
牛顿正在学习....
2、重写父类方法
重写父类方法: 就是子类中,有一个和父类相同名字的方法,在子类中的方法会覆盖掉父类中同名的方法。
调用父类的方法:
1. 父类名.父类的方法名()
2. super(): py2.2+的功能
重写父类方法
#在python中没有指定父类,默认继承的是object
#父类:object 子类:Student
class Student(object):
#将对象和属性封装在一起
def __init__(self,name,age,gender):
self.name = name
self.age = age
self.gender = gender
def learn(self):
print("%s正在学习...." %(self.name))
#父类:Student 子类:MathStudent
#继承了父类的属性和方法(构造方法和定义的方法)
class MathStudent(Student):
#重写父类learn方法
def learn(self):
#执行子类中重写的父类方法learn,不再执行父类中的learn方法
#方法一:调用父类的方法
#Student.learn(self)
#方法二:调用父类的方法,自动帮助当前类寻找父类的名称
super(MathStudent, self).learn()
print("%s正在学习英语......" %(self.name))
#实例化对象的过程会执行构造方法里面的内容
stu1 = MathStudent(name='牛顿', age='1000', gender='male')
#MathStudent没有构造方法,继承并执行父类Student的构造方法
stu1.learn()
牛顿正在学习....
牛顿正在学习英语......
3、私有方法和私有属性
默认情况下,属性在 Python 中都是“public”, 大多数 OO 语言提供“访问控 制符”来限定成员函数的访问。
在 Python 中,实例的变量名如果以 __ 开头,就变成了一个私有变量/属性 (private),实例的函数名如果以 __ 开头,就变成了一个私有函数/方法(private)只 有内部可以访问,外部不能访问。
私有属性一定不能从外部访问吗?
python2版本不能直接访问 __属性名 是因为 Python 解释器对外把 __属性名改成了 _类名__属性名 ,所以,仍然可以通过 _类名__属性名来访问 __属性名 。
需求:学生成绩保密,外部不可以访问分数,只可以访问等级
class Student(object):
"""
需求:学生成绩保密,外部不可以访问分数,只可以访问等级
"""
def __init__(self,name,age,score):
self.name = name
self.age = age
#self.__score是私有属性,只能在类的内部访问,外部不可以访问
self.__score = score
#__get_level是私有方法,只能在类的内部进行访问,外部不可以进行访问
def __get_level(self):
if 90<= self.__score <=100:
return "优秀"
elif 60<= self.__score < 90:
return "合格"
else:
return '不及格'
stu1 = Student(name='开心',age=10,score= 59)
#print(stu1.__score)
#print(stu1.get_level())
#Python解释器自动将私有属性和私有方法重命名了.命名格式一般为_类名__属性名、_类名__方法名
print(stu1._Student__score)
print(stu1._Student__get_level())
59
不及格
私有属性和私有方法的优势
1、确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护,代码更加的强壮。
2、如果又要允许外部代码修改属性怎么办?可以给类增加专门设置属性方法。
4、多继承
多继承,即子类有多个父类,并且具有它们的特征。
#定义一个类
class TeacherMajor(object):
def __init__(self, student_count):
self.student_count = student_count
#定义另外一个类
class DoctorMajor(object):
def __init__(self,patient_count):
self.patient_count = patient_count
#新定义的类继承多个父类
class Student(TeacherMajor,DoctorMajor):
def __init__(self,name,students_count,patient_count):
self.name = name
#继承父类的执行方法
TeacherMajor.__init__(self,students_count)
DoctorMajor.__init__(self,patient_count)
#实例化对象
stu1 = Student('fentiao',0,0)
print(stu1.patient_count)
print(stu1.student_count)
0
0
新式类和经典类:在Python 2及以前的版本中,由任意内置类型派生出的类,都属于“新式 类”,都会获得所有“新式类”的特性;反之,即不由任意内置类型派生出的类, 则称之为“经典类”。Python3中全部为新式类,因为所有的类都派生自内置类型object(即使没有显示的继承 object类型),即所有的类都是“新式类”。。
新式类和经典类:
新式类和经典类的区别:
最明显的区别在于继承搜索的顺序不同,即:
经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找,然后再返回,开始查找右侧。
新式类多继承搜索顺序(广度优先算法):先在水平方向查找,然后再向上查找。
新式类的理解
# 注意: Python3环境中做实验
# 类D新式类.
class D(object):
def hello(self):
print("D...... hello")
class C(D):
def hello(self):
print("C...... hello")
class B(D):
pass
class A(B, C):
pass
# 新式类多继承搜索顺序(广度优先算法):先在水平方向查找,然后再向上查找,
a = A()
a.hello()
C...... hello
经典类理解
#coding:utf-8
# 注意: Python2环境中做实验
# 类D经典类.
class D:
def hello(self):
print("D...... hello")
class C(D):
def hello(self):
print("C...... hello")
class B(D):
pass
class A(B, C):
pass
# 经典类多继承搜索顺序(深度优先算法):先深入继承树左侧查找,然后再返回,开始查找右侧。
a = A()
a.hello()
D...... hello
四、多态特性
多态(Polymorphism)按字面的意思就是“多种状态”。在面向对象语言中,接口的多种不同的实现方式即为多态。通俗来说: 同一操作作用于不同的对象,可以有不同的解释,产生不同的执行结果。
多态的好处就是,当我们需要传入更多的子类,只需要继承父类就可以了,而方法既可以直接 不重写(即使用父类的),也可以重写一个特有的。这就是多态的意思。调用方只管调用,不管 细节,而当我们新增一种的子类时,只要确保新方法编写正确,而不用管原来的代码。这就是著 名的“开闭”原则:
对扩展开放(Open for extension):允许子类重写方法函数
对修改封闭(Closed for modification):不重写,直接继承父类方法函数
五、项目案例:栈的封装
什么是栈?
栈是限制在一端进行插入操作和删除操作的线性表(俗称堆栈),允许进行操作的一端称为“栈顶”, 另一固定端称为“栈底”,当栈中没有元素时称为“空栈”。向一个栈内插入元素称为是进栈,push; 从一个栈删除元素称为是出栈,pop。特点 :后进先出(LIFO)。
class Stack(object):
"""
根据列表的数据结构封装栈的数据结构
属性:栈元素stack
方法:
get_top()
get_bootom()
push()
pop()
"""
def __init__(self):
#创建一个空栈
self.stack = []
# 返回最后进入栈的元素,也就是栈顶
def top(self):
return self.stack[-1]
# 返回栈的第一个元素
def bootom(self):
return self.stack[0]
#往栈里面加入元素
def push(self,item):
return self.stack.append(item)
# 出栈
def pop(self):
item = self.stack.pop()
return item
#显示栈里面的元素
def show(self):
return self.stack
#魔术方法,使得代码更加的简洁
def __len__(self):
return len(self.stack)
if __name__ == '__main__':
stack = Stack()
print(stack.show()) #显示栈,此时为空
stack.push(1) #入栈
stack.push(2)
stack.push(3)
print("入栈之后:",stack.show())
item = stack.pop() #出栈
print("出栈后:",stack.show())
print("栈元素的个数:",len(stack)) #显示元素个数
print("栈元素的个数:",len(stack.show()))
#print("栈元素的个数:",stack.__len__())
[]
入栈之后: [1, 2, 3]
出栈后: [1, 2]
栈元素的个数: 2
栈元素的个数: 2
案例:吃热狗游戏
import random
import pygame
class SiCong(object):
"""
sicong类:
属性:(x,y),power
方法:move(),eat()
"""
def __init__(self):
self.power = 100
self.x = random.randint(50, width - 50) #避免图片出现在背景之外
self.y = random.randint(50, height - 50)
# BaseAnimal.move(self,move_skills = (-2, -1, 1, 2))
# super(Turtle, self).__init__()
def move(self,new_x,new_y):
"""
热狗的移动方法
:return:
"""
# 超出边界后的处理方法
self.x = new_x % width
self.y = new_y % height
def eat(self):
"""sicong吃热狗"""
self.power += 10
print("思聪吃热狗,能量+10!")
class HotDog(object):
"""
鱼类:
属性:(x,y)
方法:move()
"""
def __init__(self):
self.x = random.randint(50, width - 50)
self.y = random.randint(50, height - 50)
def move(self):
"""
鱼的移动方法
:return:
"""
move_skills = [-10]
# 计算新坐标
new_x = self.x + random.choice(move_skills) #使鱼在x轴上移动
#new_y = self.y + random.choice(move_skills)
# 超出边界后的处理方法
self.x = new_x % width
#self.y = new_y % height
def main():
pygame.init()
#显示游戏界面
screen = pygame.display.set_mode((width,height))
#设置界面标题
pygame.display.set_caption("思聪吃热狗")
#加载游戏中需要的图片
bg = pygame.image.load("./img/bigger_bg1.jpg").convert()
hotdogImg = pygame.image.load("./img/hot-dog.png").convert_alpha() #_alpha去除图片边框
sicongImg = pygame.image.load("./img/sicong.png").convert_alpha()
#加载游戏音乐(背景音乐和吃掉热狗的音乐)
pygame.mixer.music.load('./img/game_music.mp3')
pygame.mixer.music.play(loops = 0,start = 0.0)
#设置分数显示参数信息(显示位置,字体颜色,字体大小)
scoreCount = 0
font = pygame.font.SysFont('arial',20)
score = font.render('Score: %s' %(scoreCount),True,(0,0,0))
#创建一个Clock对象,跟踪游戏运行时间
fpsClock = pygame.time.Clock()
#创建1个sicong和20个热狗
sicong = SiCong()
hotdogs = [HotDog() for item in range(20)]
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
print("游戏结束......")
exit(0)
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_UP: #键盘的上键,x坐标不变,y轴坐标减小
#移动sicong多少个像素
sicong.move(sicong.x,sicong.y - 10)
elif event.key == pygame.K_DOWN:
sicong.move(sicong.x,sicong.y + 10) #键盘的下键,x坐标不变,y轴坐标增大
if event.key == pygame.K_LEFT:
sicong.move(sicong.x - 10,sicong.y) #键盘的左键,y坐标不变,x轴坐标减小
elif event.key == pygame.K_RIGHT:
sicong.move(sicong.x + 10,sicong.y) #键盘的右键,y坐标不变,x轴坐标增大
# elif event.key == pygame.K_q:
# print('over')
#绘制背景和分数
screen.blit(bg,(0,0))
screen.blit(score, (200,20))
#绘制热狗,并实现热狗的移动
for hd in hotdogs:
screen.blit(hotdogImg,(hd.x,hd.y))
hd.move()
#绘制sicong
screen.blit(sicongImg,(sicong.x,sicong.y))
#判断游戏是否结束,当人物的体力为0或者热狗的数量为0游戏结束
if sicong.power == 0:
print("游戏结束:sicong power is 0")
exit(1)
if len(hotdogs) == 0:
print("游戏结束:hot-dog count is 0")
exit(2)
#判断人物是否吃到热狗:人物和热狗的坐标值相同,则认为吃掉
for hd in hotdogs:
if 0< sicong.x - hd.x < 50 and 0 < sicong.y - hd.y < 50:
#增加思聪体力
sicong.eat()
#删除被吃掉的热狗
hotdogs.remove(hd)
#分数增加
scoreCount += 10
#重新设置分数信息,打印分数
score = font.render("Score: %s" %(scoreCount),True,(0,0,0))
#更新内容到游戏窗口
pygame.display.update()
fpsClock.tick(10) #每10帧更新一次
if __name__ == '__main__':
width = 1000 #取决于背景的像素大小
height = 666
main()