案例驱动式Python学习笔记【第六篇】电子宠物

驱动案例

设计多只电子宠物，它们具有名字，性别，能力，体重等属性，可以完成吃饭、运动、显示状态的动作。

类与对象

通过类（模板）可以生产多个具有相同属性和方法（行为）的对象，对象是类的实例化

class Pet:
    def __init__(self,name,gender,energy,weight):
     //构造方法
    def eat(self,food):
    //吃饭方法
    def display(self):
     //显示当前状态方法
    def run(self,time):
     //跑步方法

class Pet:
    def __init__(self,name,gender,energy,weight):
        self.name=name
        self.gender=gender
        self.energy=energy
        self.weight=weight
        print('你好！我的名字是{0},我是{1},很高兴成为你的小伙伴'.format(self.name,self.gender))
    def  eat(self,food):
        if(food=='hanberger'):
            self.energy=self.energy+10
            self.weight=self.weight+5
            print("汉堡包真好吃,但是别给我吃太多!")
        else:
       self.weight=self.weight+2
            print("好美味呀！我又充满能量了")
    def display(self):
        print("我当前的能量值为{0}".format(self.energy))
        print("我当前的体重为{0}".format(self.weight))
        if  self.energy<70:
            print("我累了，快为我补充能量吧！")
        elif  self.weight>60:
            print("我有点超重了，让我做做运动吧！")
        else:
            print("我很健康，谢谢主人！")
    def run(self,time):
        if time>5:
            self.energy=self.energy-20
            self.weight=self.weight-10
            print("我运动了{0}分钟".format(time))
        elif time>3:
            self.energy=self.energy-10
            self.weight=self.weight-5
            print("我运动了{0}分钟".format(time))
        else:
            self.energy=self.energy-5
            self.weight=self.weight-2
            print("我运动了{0}分钟".format(time))

继承(Inheritance)

• 继承是面向对象方法学中的核心概念，它是指一个类的定义中可以派生出另一个类的定义，派生出的类(子类)可以自动拥有父类的全部属性和服务。
• 继承简化了人们对现实世界的认识和描述，在定义子类时不必重复定义已在父类中定义的属性和服务，只要说明它是某个父类的子类，并定义自己特有的属性和服务即可。

定义子类

class NewPet(Pet):
    def calculate(self):
        a=eval(input("请给我出题:"))
        print("={0}".format(a))

p2=NewPet('瓦力','男孩',100,50)
p2.calculate()

执行继承父类的方法

p2.eat('hanberger')
p2.display()
p2.run(15)
p2.display()

补充知识

面向对象编程

面向对象是程序开发领域中的重要思想，这种思想模拟了人类认识客观世界的逻辑，是当前计算机软件工程学的主流方法。
类是面向对象的实现手段。
面向过程编程的基本思想是：分析解决问题的步骤，使用函数实现步骤相应的功能，按照步骤的先后顺序依次调用函数。
面向对象编程的基本思想是：首先会从问题之中提炼出问题涉及的角色，将不同角色各自的特征和关系进行封装，以角色为主体，通过描述角色的行为去描述解决问题的过程。

对象

对象是现实世界中可描述的事物，它可以是有形的也可以是无形的，从一本书到一家图书馆，从单个整数到繁杂的序列等都可以称为对象。
对象是构成世界的一个独立单位，它由数据（描述事物的属性）和作用于数据的操作（体现事物的行为）构成一个独立整体。

类（class）

从具体的事物中把共同的特征抽取出来，形成一般的概念称为“归类”，忽略事物的非本质特牲，关注与目标有关的本质特征，找出事物间的共性，抽象出一个概念模型，就是定义一个类。
例如：猫和狗都属于动物类
在面向对象的方法中，类是具有相同属性和行为的一组对象的集合，它提供一个抽象的描述，其内部包括属性和方法两个主要部分，它就像一个模具，可以用它铸造一个个具体的铸件。

抽象（abstract）

抽象是抽取特定实例的共同特征，形成概念的过程。

例如苹果、香蕉、梨、葡萄等，抽取出它们共同特性就得出“水果”这一类，那么得出水果概念的过程，就是一个抽象的过程。

封装（encapsulation）

封装是面向对象的核心思想，将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。

继承（inheritance）

继承描述的是类与类之间的关系，通过继承，新生类可以在无需赘写原有类的情况下，对原有类的功能进行扩展。

多态（ polymorphism）

多态指同一个属性或行为在父类及其各派生类中具有不同的语义。
封装、继承、多态是面向对象程序设计的三大特征，它们的简单关系如下图所示。

类的定义

类中可以定义数据成员和成员函数，数据成员用于描述对象特征，成员函数用于描述对象行为，其中数据成员也被称为属性，成员函数也被称为方法。

class 类名:
     属性名 = 属性值
     def 方法名(self):
           方法体

对象的创建

创建对象的格式如下：
对象名 = 类名()   

访问对象成员

若想在程序中真正地使用对象，需掌握访问对象成员的方式。对象成员分为属性和方法，它们的访问格式分别如下：

对象名.属性
对象名.方法()

单继承

Python中类与类之间具有继承关系，其中被继承的类称为父类或基类，继承的类称为子类或派生类。单继承指的是子类只继承一个父类，其语法格式如下：class 子类(父类)

多继承

多继承指的是一个子类继承多个父类，其语法格式如下：
class 子类（父类A, 父类B, …）:

方法的重写

子类可以继承父类的属性和方法，若父类的方法不能满足子类的要求，子类可以重写父类的方法，以实现理想的功能。

父类定义如下：
class Felines:
    def speciality(self):
        print("猫科动物特长是爬树")
子类定义如下：
class Cat(Felines):
    name = "猫"
    def speciality(self):
        print(f'{self.name}会抓老鼠')
        print(f'{self.name}会爬树')
cat = Cat() #猫会抓老鼠
cat.speciality() #猫会爬树

super()函数

如果子类重写了父类的方法，但仍希望调用父类中的方法，那么可以使用super()函数实现。

super().方法名()

多态

Python中并不需要显式指定对象的类型，只要对象具有预期的方法和表达式操作符，就可以使用对象。

rabbit = Rabbit()
test(rabbit)    # 接收Rabbit类的对象
snail =  Snail()
test(snail)      # 接收Snail类的对象

案例源码

class Pet:
    def __init__(self,name,gender,energy,weight):
        self.name=name
        self.gender=gender
        self.energy=energy
        self.weight=weight
        print('你好！我的名字是{0},我是{1},很高兴成为你的小伙伴'.format(self.name,self.gender))

    def eat(self,food):
        if(food=='hanberger'):
            self.energy=self.energy+10
            self.weight=self.weight+5
            print("汉堡包真好吃,但是别给我吃太多!")
        else:
            self.energy=self.energy+5
            self.weight=self.weight+2
            print("好美味呀！我又充满能量了")

    def display(self):
        print("我当前的能量值为{0}".format(self.energy))
        print("我当前的体重为{0}".format(self.weight))
        if(self.energy<70):
            print("我累了，快为我补充能量吧！")
        elif(self.weight>60):
            print("我有点超重了，让我做做运动吧！")
        else:
            print("我很健康，谢谢主人！")

    def run(self,time):
        if(time>5):
            self.energy=self.energy-20
            self.weight=self.weight-10
            print("我运动了{0}分钟".format(time))
        elif(time>3):
            self.energy=self.energy-10
            self.weight=self.weight-5
            print("我运动了{0}分钟".format(time))
        else:
            self.energy=self.energy-5
            self.weight=self.weight-2
            print("我运动了{0}分钟".format(time))


class NewPet(Pet):
    def calculate(self):
        a=eval(input("请给我出题:"))
        print("={0}".format(a))



p2=NewPet('瓦力','男孩',100,50)
p2.calculate()
p2.eat('hanberger')
p2.display()
p2.run(15)
p2.display()

总结

本章主要补充介绍了面向对象概述、类和对象的关系、类的定义与访问、对象的创建与使用、类成员的访问限制、构造方法与析构方法、类方法和静态方法、继承、多态等知识。