python面向对象编程

面向对象编程

类：类是对象的蓝图和模板，有了类就可以创建对象 – 抽象 – 人类

定义类需要做两件事情：数据抽象和行为抽象
数据抽象 – 抽取对象共同的静态特征（名词） – 属性
行为抽象 – 抽取对象共同的动态特征（找动词） – 方法

定义类的关键字是 – class – 类名（每个单词首字母大写）

对象，具体，（人类中的每一个个体）（静态特征，动态特征）

我们定义一个类实际上是吧数据和操作数据的函数绑定到一起，形成一个逻辑上的整体，这个整体就叫做对象，而且将来任何时候想使用这种对象时直接服用这个类就可以了

# 1.定义类型：用class + 名字。（名字的首字母用大写）
class Student(object):       # 定义学生对象,

    # 构造方法（构造器/构造子 -- constructor）
    # 调用该方法的时候，不是直接使用方法的名字，而是使用类的名字
    def __init__(self, _name, _age):                # 初始化，指定对象的特征（指定学生的年龄和名字）
        # 给对象绑定属性
        self._name = _name  # self._name = name 不表示不允许更改name参数
        self._age = _age

    # 我们定义一个方法就代表对象可以接收这个消息
    # 对象的方法第一个参数统一用self
    # 它代表了接收消息的对象 -- 对象.消息（参数）
    def study(self, course):     # 类里面的方法，是学生对象的行为.self-->表示正在接收消息的对象。
        print('%s正在学习%s' % (self._name, course))

    def watch_tv(self):
        if self._age >= 16:
            print('%s正在观看电视' % self._name)
        else:
            print('我们推荐%s观看熊出没' % self._name)

def main():
    # 2.调用构造方法，创建学生对象
    # 实际上调用的是Student类找中——init——方法
    stu1 = Student('王大锤', 18)       # '='前是应用，后面是对象
    stu1._name = '白元芳'
    # 3.给对象发消息
    # 通过给对象发消息让对象完成某些工作
    # 解决任何问题都是通过让对象去做事情
    stu1.study('python程序设计')
    stu2 = Student('周星星', 15)
    stu2.study('HTML网页设计')
    stu2.watch_tv()

if __name__ == '__main__':
    main()

上面的过程总结一下就三个步骤：
1.定义类型：用class + 名字。（名字的首字母用大写）
2.调用构造方法，创建对象
3.给对象发消息

练习：模拟数字钟走动：

from time import sleep

class Clock(object):

    def __init__(self, _hour=0, _minute=0, _second=0):
        self._hour = _hour
        self._minute = _minute
        self._second = _second

    def run(self):
        """走字"""
        self._second += 1
        if self._second == 60:
            self._second = 0
            self._minute += 1
            if self._minute == 60:
                self._minute = 0
                self._hour += 1
                if self._hour == 24:
                    self._hour = 0

    # 下面的方法可以获得对象的字符串表示形式
    # 当我们用print打印对象时会自动调用该方法
    def __str__(self):
    #def show(self):
        return '%02d:%02d:%02d' % \
               (self._hour, self._minute, self._second)

def main():
    time1 = Clock(14, 23, 55)
    while True:
        print(time1)
        sleep(1)
        time1.run()

if __name__ == '__main__':
    main()

面向对象编写奥特曼打小怪兽游戏

# 奥特曼打小怪兽游戏
from abc import ABCMeta, abstractmethod
from random import randint, randrange


class Fighter(object, metaclass=ABCMeta):
    """战斗者"""

    # 通过__slots__魔法限定对象可以绑定的成员变量
    __slots__ = ('_name', '_hp')

    def __init__(self, name, hp):
        """
        初始化方法

        :param name: 名字
        :param hp: 生命值
        """
        self._name = name
        self._hp = hp

    @property
    def name(self):
        return self._name

    @property
    def hp(self):
        return self._hp

    @hp.setter
    def hp(self, hp):
        self._hp = hp if hp >= 0 else 0

    @property
    def alive(self):
        return self._hp > 0

    @abstractmethod
    def attack(self, other):
        """
        攻击

        :param other: 被攻击的对象
        """
        pass


class Ultraman(Fighter):
    """奥特曼"""

    __slots__ = ('_name', '_hp', '_mp')

    def __init__(self, name, hp, mp):
        """
        初始化方法

        :param name: 名字
        :param hp: 生命值
        :param mp: 魔法值
        """
        super().__init__(name, hp)
        self._mp = mp

    def attack(self, other):
        other.hp -= randint(15, 25)

    def huge_attack(self, other):
        """
        究极必杀技(打掉对方至少50点或四分之三的血)

        :param other: 被攻击的对象

        :return: 使用成功返回True否则返回False
        """
        if self._mp >= 50:
            self._mp -= 50
            injury = other.hp * 3 // 4
            injury = injury if injury >= 50 else 50
            other.hp -= injury
            return True
        else:
            self.attack(other)
            return False

    def magic_attack(self, others):
        """
        魔法攻击

        :param others: 被攻击的群体

        :return: 使用魔法成功返回True否则返回False
        """
        if self._mp >= 20:
            self._mp -= 20
            for temp in others:
                if temp.alive:
                    temp.hp -= randint(10, 15)
            return True
        else:
            return False

    def resume(self):
        """恢复魔法值"""
        incr_point = randint(1, 10)
        self._mp += incr_point
        return incr_point

    def __str__(self):
        return '~~~%s奥特曼~~~\n' % self._name + \
            '生命值: %d\n' % self._hp + \
            '魔法值: %d\n' % self._mp


class Monster(Fighter):
    """小怪兽"""

    __slots__ = ('_name', '_hp')

    def attack(self, other):
        other.hp -= randint(10, 20)

    def __str__(self):
        return '~~~%s小怪兽~~~\n' % self._name + \
            '生命值: %d\n' % self._hp


def is_any_alive(monsters):
    """判断有没有小怪兽是活着的"""
    for monster in monsters:
        if monster.alive > 0:
            return True
    return False


def select_alive_one(monsters):
    """选中一只活着的小怪兽"""
    monsters_len = len(monsters)
    while True:
        index = randrange(monsters_len)
        monster = monsters[index]
        if monster.alive > 0:
            return monster


def display_info(ultraman, monsters):
    """显示奥特曼和小怪兽的信息"""
    print(ultraman)
    for monster in monsters:
        print(monster, end='')


def main():
    u = Ultraman('孙悟空', 1000, 120)
    m1 = Monster('牛魔王', 250)
    m2 = Monster('铁扇公主', 500)
    m3 = Monster('红孩儿', 750)
    ms = [m1, m2, m3]
    fight_round = 1
    while u.alive and is_any_alive(ms):
        print('========第%02d回合========' % fight_round)
        m = select_alive_one(ms)  # 选中一只小怪兽
        skill = randint(1, 10)   # 通过随机数选择使用哪种技能
        if skill <= 6:  # 60%的概率使用普通攻击
            print('%s使用普通攻击打了%s.' % (u.name, m.name))
            u.attack(m)
            print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
        elif skill <= 9:  # 30%的概率使用魔法攻击(可能因魔法值不足而失败)
            if u.magic_attack(ms):
                print('%s使用了魔法攻击.' % u.name)
            else:
                print('%s使用魔法失败.' % u.name)
        else:  # 10%的概率使用究极必杀技(如果魔法值不足则使用普通攻击)
            if u.huge_attack(m):
                print('%s使用究极必杀技虐了%s.' % (u.name, m.name))
            else:
                print('%s使用普通攻击打了%s.' % (u.name, m.name))
                print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
        if m.alive > 0:  # 如果选中的小怪兽没有死就回击奥特曼
            print('%s回击了%s.' % (m.name, u.name))
            m.attack(u)
        display_info(u, ms)  # 每个回合结束后显示奥特曼和小怪兽的信息
        fight_round += 1
    print('\n========战斗结束!========\n')
    if u.alive > 0:
        print('%s奥特曼胜利!' % u.name)
    else:
        print('小怪兽胜利!')


if __name__ == '__main__':
    main()