python---面向对象编程三大特性

一、对象和类
类（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()