coach的学习日记 7.21

coach的学习日记

Property装饰器

一般来说可以通过._的方式来说明某个对象是受保护的。使用Property包装器可以使得对象的访问安全和方便。
如下代码：

class Person(object):

    def __init__(self, name, age):
        self._name = name
        self._age = age

    # 访问器 - getter方法
    @property
    def name(self):
        return self._name

    # 访问器 - getter方法
    @property
    def age(self):
        return self._age

    # 修改器 - setter方法
    @age.setter
    def age(self, age):
        self._age = age

    def play(self):
        if self._age <= 16:
            print('%s正在玩飞行棋.' % self._name)
        else:
            print('%s正在玩斗地主.' % self._name)


def main():
    person = Person('王大锤', 12)
    person.play()
    person.age = 22
    person.play()
    # person.name = '白元芳'  # AttributeError: can't set attribute


if __name__ == '__main__':
    main()

在这段程序中age通过修改器进行了定义，因此在main中可以直接进行访问和修改。但是name没有，因此无法进行直接修改。
结果如下图：

_slot_绑定

有的时候，我们希望某个类只能绑定某些属性，那么我们可以通过_slot_来将它与一些属性进行绑定。如下所示：

class Person(object):

    # 限定Person对象只能绑定_name, _age和_gender属性
    __slots__ = ('_name', '_age', '_gender')

    def __init__(self, name, age):
        self._name = name
        self._age = age

在上面的语句中，通过_slot_将Person与name、age、gender绑定，name在之后的函数中，就不能为Person绑定新的属性

静态方法、类方法

除了在Class中通过def来声明方法之外，还存在两种方法，即静态方法和类方法，它们并不一定是对象方法，比如声明一种方法来判断输入的三条边能否生成一个三角形。这个方法在使用的时候，对象还没有被创建出来。静态方法的示例如下：

from math import sqrt
class Triangle(object):
       def _init_(self,a,b,c):
             self._a=a
             self._b=b
             self._c=c
             
       @staticmethod 
       #静态方法
       def is_valid(a,b,c):
             return a+b>c and a+c>b and b+c>a

在上述的语句中，is_valid是一个静态方法。在调用该函数时，可以在生成对象之前调用，判断三条边是否可以构成一个三角形。

def main
      a=3,b=4,c=5
          if Triangle.is_valid(a,b,c)
              t= Triangle(a,b,c)

在主函数中，首先用静态方法判断abc是否能构成三角形，之后再生成对象。
类方法则是在类中声明的方法。同样，它可以用于生成一个对象，而不是在生成对象后再使用该方法。

from time import time, localtime, sleep

class Clock(object)
   
   def _init_(self,...,....):
           ....
           ....
           ....
       
   @classmethod
   def now(cls):
         ctime = localtime(time())
         return cls(ctime.tm_hour,ctime.tm_min,ctime.tm_sec)

类方法的第一个参数约定为cls，它代表和该类相关信息的对象。这样一个类方法用于读取当前电脑的时间。

def main():
     clock = Clock.now()

在主函数中采用如下语句就完成了一个当前时钟的对象的创建。

继承

继承即用子类对象去继承父类对象的属性，并拥有更多独有的属性。

class Person(object)
     
     def _init_(self,name,age):
          self._name = name
          self._age = age

class Student(Person)
      
    def _init_(self,name,age,gender):
         super()._init_(name,age)
         self._gender = gender

Student子类继承了Person父类，并且新增了一个属性gender。

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

from abc import ABCMeta,abstractmethod

class Pet(object,metaclass=ABCMeta):

        def _init_(self,nickname):
              self._nickname = nickname
        
        @abstractmethod
        def make_voice(self):
              pass

上述代码将Pet处理成一个抽象的类，这种类并不能直接创建对象，而是让别的类去继承他。abc模块中的ABCMeta和abstractmethod起到包装器的效果。

class Dog(Pet):
    """狗"""

    def make_voice(self):
        print('%s: 汪汪汪...' % self._nickname)


class Cat(Pet):
    """猫"""

    def make_voice(self):
        print('%s: 喵...喵...' % self._nickname)


def main():
    pets = [Dog('旺财'), Cat('凯蒂'), Dog('大黄')]
    for pet in pets:
        pet.make_voice()


if __name__ == '__main__':
    main()

在main函数中，使用的方法名make_voice是相同的，但是不同对象的方法不同，这就是多态。