面向对象编程基础

  • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  • 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
  • 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
  • 实例变量：定义在方法中的变量，只作用于当前实例的类。
  • 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
  • 实例化：创建一个类的实例，类的具体对象
  • 方法：类中定义的函数。
  • 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
  1. from time import sleep
  3. class Clock(object):
  4.     def __init__ (self,hour=0,minute=0,second=0):
  5.         self._hour = hour
  6.         self._minute = minute
  7.         self._second = second
  9.     def run (self):
  10.         self._second += 1
  11.         if self._second == 60:
  12.             self._second = 0
  13.             self._minute += 1
  14.             if self._minute == 60:
  15.                 self._minute = 0
  17.                 self._hour += 1
  18.                 if self._hour == 24 :
  19.                     self._hour = 0
  21.     def show (self):
  22.         return '%02d:%02d:%02d' % (self._hour,self._minute,self._second)
  24. def main():
  25.     clock = Clock(23,59,58)
  26.     while True:
  27.         print(clock.show())
  28.         sleep(1)
  29.         clock.run()
  31. if __name__ == '__main__':
  32.     main()

其中 Clcok就是类，一个模板，抽象的概念，可以理解他为C语言中的结构体变量。

Clock里面的就是模板属性，def 函数就是行为。

clock 就是对象了

除特殊模块 init 之外，模块名称都使用不带下划线的小写字母。

特殊方法 ： 小写和两个前导下划线，两个后置下划线

面向对象 - 图1def add(self, other):
面向对象 - 图2 return int.add(other)

这种风格只应用于特殊函数，比如操作符重载等。

面向对象进阶

@property 装饰器可以在类外对对象内的属性进行访问，或者操作，getter（访问器），setter（修改器）

slots魔法可以对一些属性和行为进行绑定，或者解绑

在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）

继承与派生，被继承的叫做父类，基类或者超类，，继承的叫做子类了。子类从父类那里继承过来所有的属性和行为，并且可以派生出自己特有的属性和行为。这种继承更多的是一种“是”的关系，例如，人是动物，狗是动物，那么动物就可以被称作为父类，人和狗就被称为子类了。

  • 抽象：抽象即抽取类似或者说比较像的部分。是一个从具体到抽象的过程。
  • 继承：子类继承了父类的方法和属性
  • 派生：子类在父类方法和属性的基础上产生了新的方法和属性

抽象接口

  1. class Alipay:
  2.     '''
  3.     支付宝支付
  4.     '''
  5.     def pay(self,money):
  6.         print('支付宝支付了%s元'%money)
  8. class Applepay:
  9.     '''
  10.     apple pay支付
  11.     '''
  12.     def pay(self,money):
  13.         print('apple pay支付了%s元'%money)
  15. class Wechatpay:
  16.     def fuqian(self,money):
  17.         '''
  18.         实现了pay的功能，但是名字不一样
  19.         '''
  20.         print('微信支付了%s元'%money)
  22. def pay(payment,money):
  23.     '''
  24.     支付函数，总体负责支付
  25.     对应支付的对象和要支付的金额
  26.     '''
  27.     payment.pay(money)
  30. p = Wechatpay()
  31. pay(p,200)   #执行会报错

实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。

继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。

归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。

奥特曼大战小怪兽1.0版

带有升级的版本

  1. from abc import ABCMeta, abstractmethod
  2. from random import randint, randrange
  5. class Fighter(object, metaclass = ABCMeta):
  6.     __slots__ = ('_name','_hp','_exp')
  7.     """绑定属性 name hp exp"""
  8.     def __init__ (self,name,hp,exp,level):
  9.         self._name = name
  10.         self._hp = hp
  11.         self._exp =exp
  12.         self._level =level
  13.     """初始化属性"""   
  14.     @property
  15.     def name(self):
  16.         return self._name
  18.     @property
  19.     def hp(self):
  20.         return self._hp
  22.     @property
  23.     def exp(self):
  24.         return self._exp
  25.     @property
  26.     def level(self):
  27.         return self._level
  29.     @level.setter
  30.     def level(self,level):
  31.        self._level = level
  33.     @exp.setter
  34.     def exp(self,exp):
  35.        self._exp = exp
  37.     @name.setter
  38.     def name(self,name):
  39.        self._name = name
  41.     @hp.setter
  42.     def hp(self, hp):
  43.         self._hp = hp if hp >= 0 else 0
  45.     @property 
  46.     def alive(self):
  47.         if self._hp > 0:
  48.             return True
  50.     def attack(self):
  51.         pass
  53. """奥特曼的界面"""
  54. class  Ultraman(Fighter):   
  55.     __slots__ = ('_name','_hp','_mp','_exp','_level')
  56.     def __init__(self, name, hp, mp, exp, level):
  57.         super().__init__(name,hp,exp,level)
  58.         self._mp = mp
  60.     def attack(self,other):
  61.         """普通攻击"""
  62.         damage_point = randint(10,20)
  63.         other.hp -= damage_point
  64.         print('%s used a normal attack on %s causing %d normal damage point' \
  65.               %(self.name,other.name,damage_point))
  67.     def magic_attack(self,other):
  68.         """魔法攻击"""
  69.         if self._mp >= 50 :
  70.             self._mp -= 60
  71.             magic_damage_point = randint(20,40)
  72.             other.hp -= magic_damage_point
  73.             print('%s used a magic attack on %s causing %d magic damage point' \
  74.               %(self.name,other.name,magic_damage_point))
  75.         else :
  76.             self.attack(other)
  78.     def restore_mp(self) :
  79.         """恢复魔法值"""
  80.         incr_mp = randint(5,10)
  81.         self._mp += incr_mp
  82.         return incr_mp
  83.     def exp_value(self):
  84.         """每回合增加经验值，打死一只怪兽涨50经验"""
  85.         self._exp += 10
  86.         return self._exp
  88.     def __str__(self):
  89.         return '~~~%s奥特曼~~~' % self._name + \
  90.                'hp is %d ' % self._hp + \
  91.                 'mp is %d '% self._mp   + \
  92.                     'exp is %d ' %self._exp + \
  93.                         'level is %d ' %self._level
  95. """怪兽的界面"""
  96. class Monster(Fighter):
  97.     __slots__ = ('_name','_hp','_exp','_level')
  98.     def __init__(self, name, hp, exp, level):
  99.         super().__init__(name,hp,exp,level)
  101.     def attack(self,other):
  102.         damage_point = randint(5,10)
  103.         other.hp -= damage_point
  104.         print('%s used a normal attack on %s causing %d normal damage point' \
  105.               %(self.name,other.name,damage_point))
  106.     def __str__(self):
  107.            return '~~~%s怪兽~~~' % self._name + \
  108.                   'hp is %d ' % self._hp
  110. def is_any_alive(monsters):
  111.     for monster in monsters :
  112.         if monster.alive :
  113.             return True
  114.         else:
  115.             return False        
  117. def select_alive_monster (monsters):
  118.     monsters_len = len(monsters)
  119.     while True:
  120.         index = randrange(monsters_len)
  121.         monster = monsters[index]
  122.         if monster.alive :
  123.             return monster
  124. """显示信息的界面，这里面可以加入每回合固定要发生的事情
  125.     比如固定涨经验，固定恢复魔法值"""       
  126. def display_info (ultraman,monsters):
  127.     print('%s restore %d mana value and  %d exp'%(ultraman.name, ultraman.restore_mp() \
  128.                                        ,ultraman.exp_value()))
  129.     print(ultraman)
  130.     for monster in monsters:
  131.         print(monster)
  132.     print()
  134. def level_up (ultraman):
  135.     if ultraman.exp_value() >= 100:
  136.         ultraman.exp -= 100
  137.         ultraman.level += 1
  138.         print("you are upgrade ! choose one skill : incrase mp for 0 or restore hp for 1 ")
  139.         up_options = int(input('options = '))
  140.         if up_options == 1 :
  141.             ultraman.hp += 100
  142.         else :
  143.             ultraman.mp += 100
  144. def main():
  145.     ren = Ultraman('renyu',1000,100,10,1)
  146.     m1 = Monster('bartan',100,0,1)
  147.     m2 = Monster('sabotan',100,0,1)
  148.     ms = [m1,m2]
  149.     counter_round = 0
  151.     while is_any_alive(ms) and ren.alive:
  152.         counter_round += 1
  153.         m = select_alive_monster(ms)
  154.         print('========%02d round========' % counter_round)
  155.         """奥特曼选择攻击方式"""
  156.         skill = randint(1,10)
  157.         if skill <= 6 :             #普通攻击
  158.             ren.attack(m)
  160.         elif skill <= 10:           #魔法攻击
  161.             ren.magic_attack(m)
  163.         """怪兽的攻击"""
  164.         m.attack(ren)
  165.         """升级涨经验"""
  166.         level_up(ren)
  168.         display_info(ren,ms)     
  169. if __name__ == '__main__':
  170.     main()

str 和 repr 的区别和联系

  1. import datetime
  2. s = 'hello'
  3. d = datetime.datetime.now()
  4. print(str(s))
  5. print(repr(s))
  6. print(str(d))
  7. print(repr(d))

输出结果：

hello 'hello' 2018-11-29 22:39:18.014587 datetime.datetime(2018, 11, 29, 22, 39, 18, 14587)

可以看出repr()更能显示出对象的类型、值等信息，对象描述清晰的。 而str()能够让我们最快速了解到对象的内容，可读性较高。