面向对象编程脚本实例

• 计算器对象的编写实例

  # 通过面相对象实现一个计算器
  
  class Caculator:
      #定义一个装饰器判断数据类型
      def __judge(func):
          def judge2(self,num):
              if not isinstance(num,int):
                  raise TypeError('当前数据类型有问题，应该是整型数据')
              return func(self,num)
          return judge2
  		#初始化
      def __init__(self):
          self.__result=0
  		#装饰器实现语音播报
      def outer(x=''):
          def __say(func):
              def inner(self,num):
                  print('%s%d'%(x,num))
                  return func(self,num)
              return inner
          return __say
  
      @__judge
      @outer()
      def first_value(self, v):
          self.__result = v
  
      @__judge
      @outer('+')
      def jia(self, n):
          self.__result += n
          return self
  
      @__judge
      @outer('-')
      def jian(self, n):
          self.__result -= n
          return self
  
      @__judge
      @outer('*')
      def cheng(self, n):
          self.__result *= n
          return self
  
      def show(self):
          print('计算的结果是：%d'%self.__result)
          return self
  		#实现可以直接查询结果
      @property
      def result(self):
          return self.__result
      #清除数据
      def clear(self):
          self.__result=0
          return self
  
  c1=Caculator()
  print(c1.jia(5).jian(2).show())
  print(c1.result)
  

• 一个数字时钟类

  #定义一个类描述数字时钟
  
  from time import sleep
  
  class Clock:
      '''
      数字时钟
      '''
      def __init__(self,hour=0,minute=0,second=0):
          self._hour=hour
          self._minute=minute
          self._second=second
  
      def run(self):
          '''
          走字
          :return:
          '''
          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
  
      def show(self):
          '''
          显示时间
          :return:
          '''
          return '%02d:%02d:%02d'%(self._hour,self._minute,self._second)
  
  def main():
      clock=Clock(23,59,58)
      while True:
          print(clock.show())
          sleep(1)
          clock.run()
  
  if __name__ == '__main__':
      main()
  

• 打怪兽游戏

  from abc import ABCMeta,abstractmethod
  from random import randint,randrange
  
  class Fighter(metaclass=ABCMeta):
      '''
      战斗者
      '''
      #通过魔法方法限定绑定的属性
      __slots__ = ('_name','_hp')
  
      def __init__(self,name,hp):
          self._name=name
          self._hp=hp
      #将名字设置为只读属性
      @property
      def name(self):
          return self._name
      #将hp设置为读写属性
      @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):
          pass
  
  #奥特曼类，是Fighter类的子类
  class Ultraman(Fighter):
      #有血量、蓝量、名字
      __slots__ = ('_name','_hp','_mp')
  
      def __init__(self,name,hp,mp):
          super().__init__(name,hp)
          self._mp=mp
  
      def attack(self,other):
          other.hp-=randint(15,25)
  
      def huge_attack(self,other):
          '''
          必杀技：打掉对面四分之三的血量，最少也打五十，蓝量不足会失败
          :param other: 被攻击对象
          :return: 是否释放大招成功
          '''
          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: 是否施法成功
          '''
          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):
          '''
          回蓝
          :return:回蓝量
          '''
          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_alive(monsters):
      '''
  
      :param monsters:
      :return: 是否还活着
      '''
      for monster in monsters:
          if monster.alive:
              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:
              return monster
  
  #显示信息
  def display_info(ultraman,monsters):
      print(ultraman)
      for monster in monsters:
          print(monster,end='')
  
  def main():
      u=Ultraman('顺利',1000,120)
      m1=Monster('001',250)
      m2=Monster('002',550)
      m3=Monster('003',1050)
      m4=Monster('004',800)
      monsters=[m1,m2,m3,m4]
      fight_round=1
      while u.alive and is_alive(monsters):
          print('===第%d回合==='%fight_round)
          #选中一只小怪
          m=select_alive_one(monsters)
          # 通过随机数选择使用技能
          skill_rate=randint(1,10)
          if skill_rate<=6:
              print('%s使用普通攻击打了%s'%(u.name,m.name))
              u.attack(m)
              print('%s恢复魔法值%d点'%(u.name,u.resume()))
          elif skill_rate<=9:
              if u.magic_attack(monsters):
                  print('%s使用魔法攻击' % u.name)
              else:
                  print('%s使用魔法失败' % u.name)
          else:
              if u.huge_attack(m):
                  print('%s使用大招打了%s' % (u.name, m.name))
              else:
                  print('%s使用普通攻击打了%s' % (u.name, m.name))
                  u.attack(m)
                  print('%s恢复魔法值%d点' % (u.name, u.resume()))
          if m.alive:
              print('%s回击了%s.' % (m.name, u.name))
              m.attack(u)
          display_info(u,monsters)
          fight_round+=1
      print('---战斗结束！---')
      if u.alive:
          print('奥特曼胜利')
      else:
          print('小怪胜利')
  
  if __name__ == '__main__':
      main()
  

• 扑克游戏

  import random
  
  class Card():
      '''
      单张牌类
      '''
      def __init__(self,suite,number):
          '''
  
          :param suite:花色
          :param number: 牌面
          '''
          self._suite=suite
          self._number=number
  
      #将牌面和花色都设置为只读属性
      @property
      def number(self):
          return self._number
  
      @property
      def suite(self):
          return self._suite
  
      def __str__(self):
          if self._number==1:
              num_str='A'
          elif self._number==11:
              num_str='J'
          elif self._number==12:
              num_str='Q'
          elif self._number==13:
              num_str='K'
          else:
              num_str=str(self._number)
          return '%s%s'%(self._suite,num_str)
  
      __repr__=__str__
  
  class Poker():
      '''
      一副牌
      '''
      def __init__(self):
          self._cards=[Card(suite,number) for suite in '????' for number in range(1,14)]
          #现在发的是第几张牌
          self._current=0
  
      #牌面设置为只读属性
      @property
      def cards(self):
          return self._cards
  
      #洗牌
      def shuffle(self):
          self._current=0
          random.shuffle(self._cards)
  
      #发牌
      @property
      def next_card(self):
          '''
          发牌
          :return:
          '''
          card=self._cards[self._current]
          self._current+=1
          return card
  
      @property
      def has_next(self):
          '''
          还有牌吗
          :return:
          '''
          return self._current

• 工资结算系统

  #工资结算系统
  """
  某公司有三种类型的员工 分别是部门经理、程序员和销售员
  需要设计一个工资结算系统 根据提供的员工信息来计算月薪
  部门经理的月薪是每月固定15000元
  程序员的月薪按本月工作时间计算 每小时150元
  销售员的月薪是1200元的底薪加上销售额5%的提成
  """
  from abc import ABCMeta,abstractmethod
  
  class Eployee(metaclass=ABCMeta):
      '''
      员工类
      '''
      def __init__(self,name):
          self._name=name
  
      @property
      def name(self):
          return self._name
  
      @abstractmethod
      def salary(self):
          pass
  
  class Manager(Eployee):
      def salary(self):
          return 15000.0
  
  class Programmer(Eployee):
      def __init__(self,name,working_time=0):
          super().__init__(name)
          self._working_time=working_time
  
      @property
      def working_time(self):
          return self._working_time
  
      @working_time.setter
      def working_time(self,working_time):
          self._working_time=working_time if working_time>0 else 0
  
      def salary(self):
          return 150.0*self._working_time
  
  class Salesman(Eployee):
      def __init__(self, name, sales=0):
          super().__init__(name)
          self._sales = sales
  
      @property
      def sales(self):
          return self._sales
  
      @sales.setter
      def sales(self, sales):
          self._sales = sales if sales > 0 else 0
  
      def salary(self):
          return 1200.0+self._sales*0.05
  
  def main():
      emps = [
          Manager('刘备'), Programmer('诸葛亮'),
          Manager('曹操'), Salesman('荀彧'),
          Salesman('吕布'), Programmer('张辽'),
          Programmer('赵云')
      ]
      for emp in emps:
          if isinstance(emp,Programmer):
              emp.working_time=int(input('请输入%s本月工作时间: ' % emp.name))
          elif isinstance(emp,Salesman):
              emp.sales=float(input('请输入%s本月销售额: ' % emp.name))
          print('%s本月工资为: ￥%s元' %
                (emp.name, emp.salary()))
  
  if __name__ == '__main__':
      main()