Python 8th Day

Posted 2020-08-02

多态

我们编写一个名为 Animal 的 class, 有一个 run() 方法可以直接打印：

class Animal(object):
    def run(self):
        print(‘Animal is running...‘)

要理解多态的好处，我们还需要再编写一个函数，这个函数接受一个 Animal 类型的变量：

def run_twice(animal):
    animal.run()
    animal.run()

当我们传入Animal的实例时，run_twice()就打印出：

>>> run_twice(Animal())
Animal is running...
Animal is running...

如果我们再定义一个Tortoise类型，从 Animal 派生：

class Tortoise(Animal):
    def run(self):
        print(‘Tortoise is running slowly...‘)

当我们调用run_twice()时，传入Tortoise的实例：

>>> run_twice(Tortoise())
Tortoise is running slowly...
Tortoise is running slowly...

多态的好处就是，当我们需要传入 Tortoise 时，我们只需要接收 Animal 类型就可以了，因为 Tortoise 是 Animal 类型，然后，按照 Animal 类型进行操作即可。由于 Animal 类型有 run() 方法，因此，传入的任意类型，只要是 Animal 类或者子类，就会自动调用实际类型的 run() 方法，这就是多态的意思。

类成员

普通字段（data attributes）: Data attributes are pieces of data held by a specific instance of a class. 

静态字段（class attributes）: Python also supports class attributes, which are variables owned by the class itself.

普通对象只能由对象访问，静态字段应该由类访问，静态字段在代码加载时已经创建。

普通方法 (instance method)

静态方法（static method）

与普通方法的不同：

1）去掉 self

2）使用 @staticmethod 装饰器

3）静态方法由类调用，其实就是函数，只是与这个类相关

类方法（class method）

类方法是一种特殊的静态方法，也由类调用，与静态方法不同：

1）自动传入一个 cls 参数，cls 为函数名

class Province:
    @classmethod
    def f2(cls):
        print(cls)

hn = Province(‘henan‘)
hn.f2()

输出为：<class ‘__main__.Province‘>

Class methods are methods that are not bound to an object, but to a class!

>>> class Pizza(object):
...     radius = 42
...     @classmethod
...     def get_radius(cls):
...         return cls.radius
... 
>>> 
>>> Pizza.get_radius
<bound method type.get_radius of <class ‘__main__.Pizza‘>>
>>> Pizza().get_radius
<bound method type.get_radius of <class ‘__main__.Pizza‘>>
>>> Pizza.get_radius is Pizza().get_radius
True
>>> Pizza.get_radius()
42

对象名加 () 执行 __call__

类名加 () 执行 __init__ 

静态方法与类方法的对比：

#!/usr/bin/env python

class Smoothie(object):

    YOGURT = 1
    STRAWBERRY = 2
    BANANA = 4
    MANGO = 8

    @staticmethod
    def blend(*mixes):
        return sum(mixes) / len(mixes)

    @staticmethod
    def eternal_sunshine():
        return Smoothie.blend(Smoothie.YOGURT, Smoothie.STRAWBERRY, Smoothie.BANANA)

    @staticmethod
    def mango_lassi():
        return Smoothie.blend(Smoothie.YOGURT, Smoothie.MANGO)

使用静态方法，需要 hardcode class 的名字，而使用类方法：

#!/usr/bin/env python

class Smoothie(object):

    YOGURT = 1
    STRAWBERRY = 2
    BANANA = 4
    MANGO = 8

    @staticmethod
    def blend(*mixes):
        return sum(mixes) / len(mixes)

    @classmethod
    def eternal_sunshine(cls):
        return cls.blend(cls.YOGURT, cls.STRAWBERRY, cls.BANANA)

    @classmethod
    def mango_lassi(cls):
        return cls.blend(cls.YOGURT, cls.MANGO)

合理使用类方法的第一个好处：当需要改类的名字时，类的方法不需要改动。

另一个好处就是，当我们再创建一个 subclass 时，

class BetterSmoothie(Smoothie):

    YOGURT = ‘yogurt‘
    STRAWBERRY = ‘strawberry‘
    BANANA = ‘banana‘
    MANGO = ‘mango‘

    @staticmethod
    def blend(*mixes):
        return ‘, ‘.join(mixes)

我们更新了静态方法 blend, 从 Smoothie 继承的类方法 eternal_sunshine() 和 mango_lassi() 会自动使用新的 blend 方法。

属性：

class Pager:
    def __init__(self, all_count):
        self.all_count = all_count

    @property
    def all_pager(self):
        a1, a2 = divmod(self.all_count, 10)
        if a2 == 0:
            return a1
        else:
            return a1 + 1

    @all_pager.setter
    def all_pager(self, value):
        print(value)

    @all_pager.deleter
    def all_pager(self):
        print(‘del all_pager‘)

对一个普通方法使用装饰器 @property 就相当于构造了一个动态字段，构造的属性只能取值，不能赋值，除非使用 @func_name.setter 装饰器再构造一个函数，使用 @func_name.deleter 装饰器使属性可删除，这样属性就具有完整的字段属性。

一个例子：

class Celsius:
    def __init__(self, temperature = 0):
        self.set_temperature(temperature)

    def to_fahrenheit(self):
        return (self.get_temperature() * 1.8) + 32

    # new update
    def get_temperature(self):
        return self._temperature

    def set_temperature(self, value):
        if value < -273:
            raise ValueError("Temperature below -273 is not possible")
        self._temperature = value

在 instance variable 前加一个 ‘_’ 意思是指明该字段应为私有字段，但是从外部依然可以访问。

class Celsius:
    def __init__(self, temperature = 0):
        self.temperature = temperature

    def to_fahrenheit(self):
        return (self.temperature * 1.8) + 32

    def get_temperature(self):
        print("Getting value")
        return self._temperature

    def set_temperature(self, value):
        if value < -273:
            raise ValueError("Temperature below -273 is not possible")
        print("Setting value")
        self._temperature = value

    temperature = property(fget=get_temperature, fset=set_temperature)

最后一行的意思是，property attaches some code (get_temperature and set_temperature) to the member attribute accesses (temperature). 当试图获取对象的 temperature 字段时会自动执行 get_temperature 方法 instead of a dictionary (__dict__) look-up.

Super 方法

class C1:

    def f1(self):
        # print(‘c1.f1‘)
        return 123


class C2(C1):

    def f1(self):
        # 主动执行 C2 的父类的 f1 方法
        # super(C2,self) 相当于实例化了 C1 class
        ret = super(C2,self).f1()
        print(‘c2.f1‘)
        return ret

super 方法可以主动执行父类的同名方法。