@property装饰器

上一篇基础篇中的建议是将属性命名以单下划线开头，通过这种方式来暗示属性是受保护的，不建议外界直接访问，那么如果想访问属性可以通过属性的getter（访问器）和setter（修改器）方法进行对应的操作。如果要做到这点，就可以考虑使用@property包装器来包装getter和setter方法，使得对属性的访问既安全又方便，代码如下所示。

  1. class Person():
  3.     def __init__(self, name, age):
  4.         self._name = name
  5.         self._age = age
  7.     # 访问器 - getter方法
  8.     @property
  9.     def name(self):
  10.         return self._name
  12.     # 访问器 - getter方法
  13.     @property
  14.     def age(self):
  15.         print("age1 called")
  16.         return self._age
  18.     # 修改器 - setter方法
  19.     @age.setter
  20.     def age(self, age):
  21.         print("age2 called")
  22.         self._age = age
  24.     def play(self):
  25.         if self._age <= 16:
  26.             print('%s正在玩飞行器' % self._name)
  27.         else:
  28.             print('%s正在玩斗地主' % self._name)
  31. def main():
  32.     person = Person('王大锤', 12)
  33.     person.play()
  34.     person.age = 22
  35.     person.play()
  36.     # person.name = '白元芳'  # AttributeError: can't set attribute
  39. if __name__ == "__main__":
  40.     main()
  42. """"" 输出
  43.     王大锤正在玩飞行器
  44.     age2 called
  45.     王大锤正在玩斗地主
  46. """""

slots魔法

Python是一门动态语言。通常，动态语言允许我们在程序运行时给对象绑定新的属性或方法，当然也可以对已经绑定的属性和方法进行解绑定。但是如果我们需要限定自定义类型的对象只能绑定某些属性，可以通过在类中定义 __slots__ 变量来进行限定。需要注意的是 __slots__ 的限定只对当前类的对象生效，对子类并不起任何作用。

  1. class Person():
  3.     # 限定Person对象只能绑定_name, _age和_gender属性
  4.     __slots__ = ('_name', '_age', '_gender')
  6.     def __init__(self, name, age):
  7.         self._name = name
  8.         self._age = age
  10.     # 访问器 - getter方法
  11.     @property
  12.     def name(self):
  13.         return self._name
  15.     # 访问器 - getter方法
  16.     @property
  17.     def age(self):
  18.         return self._age
  20.     # 修改器 - setter方法
  21.     @age.setter
  22.     def age(self, age):
  23.         self._age = age
  25.     def play(self):
  26.         if self._age <= 16:
  27.             print('%s正在玩飞行器' % self._name)
  28.         else:
  29.             print('%s正在玩斗地主' % self._name)
  32. def main():
  33.     person = Person('王大锤', 12)
  34.     person.play()
  35.     person._gender = '男'
  36.     # AttributeError: 'Person' object has no attribute '_is_gay'
  37.     # person._is_gay = True
  40. if __name__ == "__main__":
  41.     main()

静态方法和类方法

之前，我们在类中定义的方法都是对象方法，也就是说这些方法都是发送给对象的消息。实际上，我们写在类中的方法并不需要都是对象方法，例如我们定义一个“三角形”类，通过传入三条边长来构造三角形，并提供计算周长和面积的方法，但是传入的三条边长未必能构造出三角形对象，因此我们可以先写一个方法来验证三条边长是否可以构成三角形，这个方法很显然就不是对象方法，因为在调用这个方法时三角形对象尚未创建出来（因为都不知道三条边能不能构成三角形），所以这个方法是属于三角形类而并不属于三角形对象的。我们可以使用静态方法来解决这类问题，代码如下所示

  1. from math import sqrt
  4. class Triangle():
  6.     def __init__(self, a, b, c):
  7.         self._a = a
  8.         self._b = b
  9.         self._c = c
  11.     @staticmethod
  12.     def is_valid(a, b, c):
  13.         return a + b > c and b + c > a and a + c > b
  15.     def perimeter(self):
  16.         return self._a + self._b + self._c
  18.     def area(self):
  19.         half = self.perimeter() / 2
  20.         return sqrt(half * (half - self._a) * (half - self._b) * (half - self._c))
  23. def main():
  24.     a, b, c = 3, 4, 5
  25.     # 静态方法和类方法都是通过类发信息来调用的
  26.     if Triangle.is_valid(a, b, c):
  27.         t = Triangle(a, b, c)
  28.         print(t.perimeter())
  29.         # 也可以通过类发消息来调用对象方法，但是要传入接收消息的对象作为参数
  30.         # print(Triangle.perimeter(t))
  31.         print(t.area())
  32.         # print(Triangle.area(t))
  33.     else:
  34.         print('无法构成三角形')
  37. if __name__ == "__main__":
  38.     main()

和静态方法比较类似，Python还可以在类中定义类方法，类方法的第一个参数约定名为 cls ，它代表的是当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象，代码如下所示

  1. from time import time, localtime, sleep
  4. class Clock(object):
  5.     """数字时钟"""
  7.     def __init__(self, hour=0, minute=0, second=0):
  8.         self._hour = hour
  9.         self._minute = minute
  10.         self._second = second
  12.     @classmethod
  13.     def now(cls):
  14.         ctime = localtime(time())
  15.         return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)
  17.     def run(self):
  18.         """走字"""
  19.         self._second += 1
  20.         if self._second == 60:
  21.             self._second = 0
  22.             self._minute += 1
  23.             if self._minute == 60:
  24.                 self._minute = 0
  25.                 self._hour += 1
  26.                 if self._hour == 24:
  27.                     self._hour = 0
  29.     def show(self):
  30.         """显示时间"""
  31.         return '%02d:%02d:%02d' % \
  32.                (self._hour, self._minute, self._second)
  35. def main():
  36.     # 通过类方法创建对象并获取系统时间
  37.     clock = Clock.now()
  38.     while True:
  39.         print(clock.show())
  40.         sleep(1)
  41.         clock.run()
  44. if __name__ == '__main__':
  45.     main()

继承和多态

  1. class Person(object):
  2.     """人"""
  4.     def __init__(self, name, age):
  5.         self._name = name
  6.         self._age = age
  8.     @property
  9.     def name(self):
  10.         return self._name
  12.     @property
  13.     def age(self):
  14.         return self._age
  16.     @age.setter
  17.     def age(self, age):
  18.         self._age = age
  20.     def play(self):
  21.         print('%s正在愉快的玩耍.' % self._name)
  23.     def watch_av(self):
  24.         if self._age >= 18:
  25.             print('%s正在观看爱情动作片.' % self._name)
  26.         else:
  27.             print('%s只能观看《熊出没》.' % self._name)
  30. class Student(Person):
  32.     def __init__(self, name, age, grade):
  33.         super().__init__(name, age)
  34.         self._grade = grade
  36.     @property
  37.     def grade(self):
  38.         return self._grade
  40.     @grade.setter
  41.     def grade(self, grade):
  42.         self._grade = grade
  44.     def study(self, course):
  45.         print('%s的%s正在学习%s.' % (self._grade, self._name, course))
  48. class Teacher(Person):
  49.     """老师"""
  51.     def __init__(self, name, age, title):
  52.         super().__init__(name, age)
  53.         self._title = title
  55.     @property
  56.     def title(self):
  57.         return self._title
  59.     @title.setter
  60.     def title(self, title):
  61.         self._title = title
  63.     def teach(self, course):
  64.         print('%s%s正在讲%s.' % (self._name, self._title, course))
  67. def main():
  68.     stu = Student('王大锤', 15, '初三')
  69.     stu.study('数学')
  70.     stu.watch_av()
  71.     t = Teacher('骆昊', 38, '砖家')
  72.     t.teach('Python程序设计')
  73.     t.watch_av()
  76. if __name__ == "__main__":
  77.     main()

子类在继承了父类的方法后，可以对父类已有的方法给出新的实现版本，这个动作称之为方法重写（override）。通过方法重写我们可以让父类的同一个行为在子类中拥有不同的实现版本，当我们调用这个经过子类重写的方法时，不同的子类对象会表现出不同的行为，这个就是多态（poly-morphism）

  1. from abc import ABCMeta, abstractclassmethod
  4. class Pet(object, metaclass=ABCMeta):
  6.     def __init__(self, nickname):
  7.         self._nickname = nickname
  9.     @abstractclassmethod
  10.     def make_voice(self):
  11.         pass
  14. class Dog(Pet):
  16.     def make_voice(self):
  17.         print("%s：汪汪汪..." % self._nickname)
  20. class Cat(Pet):
  22.     def make_voice(self):
  23.         print("%s：喵...喵..." % self._nickname)
  26. def main():
  27.     pets = [Dog('旺财'), Cat('凯蒂'), Dog('大黄')]
  28.     for pet in pets:
  29.         pet.make_voice()
  32. if __name__ == '__main__':
  33.     main()

在上面的代码中，我们将Pet类处理成了一个抽象类，所谓抽象类就是不能够创建对象的类，这种类的存在就是专门为了让其他类去继承它。Python从语法层面并没有像Java或C#那样提供对抽象类的支持，但是我们可以通过abc模块的ABCMeta元类和abstractmethod包装器来达到抽象类的效果，如果一个类中存在抽象方法那么这个类就不能够实例化（创建对象）。上面的代码中，Dog和Cat两个子类分别对Pet类中的make_voice抽象方法进行了重写并给出了不同的实现版本，当我们在main函数中调用该方法时，这个方法就表现出了多态行为（同样的方法做了不同的事情）

实例：奥特曼打小怪兽

  1. from abc import ABCMeta, abstractclassmethod
  2. from random import randint, randrange
  5. class Fighter(metaclass=ABCMeta):
  7.     # 通过__slots__魔法限定对象可以绑定的成员变量
  8.     __slots__ = ('_name', '_hp')
  10.     def __init__(self, name, hp):
  11.         self._name = name
  12.         self._hp = hp
  14.     @property
  15.     def name(self):
  16.         return self._name
  18.     @property
  19.     def hp(self):
  20.         return self._hp
  22.     @hp.setter
  23.     def hp(self, hp):
  24.         self._hp = hp if hp >= 0 else 0
  26.     @property
  27.     def alive(self):
  28.         return self._hp > 0
  30.     @abstractclassmethod
  31.     def attack(self, other):
  32.         pass
  35. class Ultraman(Fighter):
  37.     __slots__ = ('_name', '_hp', '_mp')
  39.     def __init__(self, name, hp, mp):
  40.         super().__init__(name, hp)
  41.         self._mp = mp
  43.     def attack(self, other):
  44.         other.hp -= randint(15, 25)
  46.     def huge_attack(self, other):
  47.         # 究极必杀技(打掉对方至少50点或四分之三的血)
  49.         if self._mp >= 50:
  50.             self._mp -= 50
  51.             injury = other.hp * 3 // 4
  52.             injury = injury if injury >= 50 else 50
  53.             other.hp -= injury
  54.             return True
  55.         else:
  56.             self.attack(other)
  57.             return False
  59.     def magic_attack(self, others):
  60.         if self._mp >= 20:
  61.             self._mp -= 20
  62.             for temp in others:
  63.                 if temp.alive:
  64.                     temp.hp -= randint(10, 15)
  65.             return True
  66.         else:
  67.             return False
  69.     def resume(self):
  70.         # 恢复魔法
  72.         incr_point = randint(1, 10)
  73.         self._mp += incr_point
  74.         return incr_point
  76.     def __str__(self):
  77.         return '~~~%s奥特曼~~~\n' % self._name + \
  78.             '生命值: %d\n' % self._hp + \
  79.             '魔法值: %d\n' % self._mp
  82. class Monster(Fighter):
  84.     __slots__ = ('_name', '_hp')
  86.     def attack(self, other):
  87.         other.hp -= randint(10, 20)
  89.     def __str__(self):
  90.         return '~~~%s小怪兽~~~\n' % self._name + \
  91.             '生命值: %d\n' % self._hp
  94. def is_any_alive(monsters):
  95.     for monster in monsters:
  96.         if monster.alive > 0:
  97.             return True
  98.     return False
  101. def select_alive_one(monsters):
  102.     monsters_len = len(monsters)
  103.     while True:
  104.         index = randrange(monsters_len)
  105.         monster = monsters[index]
  106.         if monster.alive > 0:
  107.             return monster
  110. def display_info(ultraman, monsters):
  111.     print(ultraman)
  112.     for monster in monsters:
  113.         print(monster, end='')
  116. def main():
  117.     u = Ultraman('骆昊', 1000, 120)
  118.     m1 = Monster('狄仁杰', 250)
  119.     m2 = Monster('白元芳', 500)
  120.     m3 = Monster('王大锤', 750)
  121.     ms = [m1, m2, m3]
  122.     fight_round = 1
  124.     while u.alive and is_any_alive(ms):
  125.         print('========第%02d回合========' % fight_round)
  126.         m = select_alive_one(ms)  # 选中一只小怪兽
  127.         skill = randint(1, 10)   # 通过随机数选择使用哪种技能
  128.         if skill <= 6:  # 60%的概率使用普通攻击
  129.             print('%s使用普通攻击打了%s.' % (u.name, m.name))
  130.             u.attack(m)
  131.             print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
  132.         elif skill <= 9:  # 30%的概率使用魔法攻击(可能因魔法值不足而失败)
  133.             if u.magic_attack(ms):
  134.                 print('%s使用了魔法攻击.' % u.name)
  135.             else:
  136.                 print('%s使用魔法失败.' % u.name)
  137.         else:  # 10%的概率使用究极必杀技(如果魔法值不足则使用普通攻击)
  138.             if u.huge_attack(m):
  139.                 print('%s使用究极必杀技虐了%s.' % (u.name, m.name))
  140.             else:
  141.                 print('%s使用普通攻击打了%s.' % (u.name, m.name))
  142.                 print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
  143.         if m.alive > 0:  # 如果选中的小怪兽没有死就回击奥特曼
  144.             print('%s回击了%s.' % (m.name, u.name))
  145.             m.attack(u)
  146.         display_info(u, ms)  # 每个回合结束后显示奥特曼和小怪兽的信息
  147.         fight_round += 1
  148.     print('\n========战斗结束!========\n')
  149.     if u.alive > 0:
  150.         print('%s奥特曼胜利!' % u.name)
  151.     else:
  152.         print('小怪兽胜利!')
  155. if __name__ == '__main__':
  156.     main()