学习总结2019.4.22

佚名 6年前 (2019-04-23) 随笔 410人围观抢沙发百度已收录

抽象父类

# 抽象父类：拥有抽象方法(子类共有的方法，但是父类不能有具体的实现体)的父类
#       抽象方法：方法名是具体的，但是实现体是抽象的(在子类中重写来具象化)

# 注意点：有抽象方法的父类不能被实例化（假设能被实例化，就可以调用自己的抽象方法，没有任何意义）

# 实现抽象父类的语法
import abs# abstract base class
class Sup(metaclass=abc.ABCMeta):

    # 抽象父类中的抽象方法，在继承它的子类中必须有自己的实现体
    #       -- 抽象父类中的抽象方法实现体就没有意义，实现与不实现都是pass填充
    @abc.abstractmethod
    def func(self): pass

class Sub(Sup):
    def func(self):
        # 必须重写父类的抽象方法

案例

import abc
class Quan(metaclass=abc.ABCMeta):
    def __init__(self, name):
        self.name = name
    # 共有方法，子类继承就可以了
    def run(self):
        print(self.name + 'running')
    # 抽象方法：子类必须重写
    @abc.abstractmethod
    def chi(self): pass

    @abc.abstractmethod
    def jiao(self): pass

class Dog(Quan):
    def kanmen(self):
        print(self.name + '看门')
    def chi(self):
        super().chi()
        print(self.name + '狗粮')
    def jiao(self):
        print('汪汪汪')

class Wolf(Quan):
    def bulie(self):
        print(self.name + '捕猎')
    def chi(self):
        print(self.name + '肉')
    def jiao(self):
        print('嗷嗷嗷')

dog = Dog('来福')
wolf = Wolf('呵呵')

dog.jiao()
wolf.jiao()
dog.run()
wolf.run()

View Code

多态

# 多态：对象的多种状态 - 父类对象的多种(子类对象)状态

import abc
class People(metaclass=abc.ABCMeta):
    def __init__(self, name):
        self.name = name
    @abc.abstractmethod
    def speak(self): pass

class Chinese(People):
    def speak(self):
        print('说中国话')
class England(People):
    def speak(self):
        print('说英国话')

if __name__ == '__main__':
    # 多态的体现：功能或是需求，需要父类的对象，可以传入父类对象或任意子类对象
    #       注：一般都是规定需要父类对象，传入子类对象
    def ask_someone(obj):
        print('让%s上台演讲' % obj.name)  # 父类提供，自己直接继承
        obj.speak()  # 父类提供，只不过子类重写了

    ch = Chinese('王大锤')
    en = England('Tom')

    # 传入Chinese | England均可以，因为都是People的一种状态(体现方式)
    ask_someone(ch)
    ask_someone(en)

    # 传入str不可以，因为str的对象没有name和speak
    # s = str('白骨精')
    # ask_someone(s)
    # p = People('kkk')

鸭子类型

# 需求：需要一个对象，该对象有name属性及speak方法，就可以作为一种状态的体现被传入
def ask_someone(obj):
    print('让%s上台演讲' % obj.name)
    obj.speak()

# 鸭子类型：
# 1.先规定：有什么属性及什么方法的类的类型叫鸭子类型
# 2.这些类实例化出的对象，都称之为鸭子，都可以作为需求对象的一种具体体现
class A:
    # 能有自己特有的属性和方法，可以和B完全不一样，但是必须有鸭子类型规定的属性和方法，不然就不是鸭子类型
    def __init__(self, name):
        self.name = name
    def speak(self):
        print('说AAAA')


class B:
    # 能有自己特有的属性和方法，可以和A完全不一样，但是必须有鸭子类型规定的属性和方法，不然就不是鸭子类型
    def __init__(self, name):
        self.name = name
    def speak(self):
        print('说BBBB')

ask_someone(B('B'))

反射

# 反射：通过字符串与类及类的对象的属性(方法)建立关联
class A:
    num = 10
print(hasattr(A, 'num'))
res = getattr(A, 'num', '默认值')
print(res)
delattr(A, 'num')
print(setattr(A, 'tag', 10))
# 类的属性类来操作


class B:
    def __init__(self, name):
        self.name = name
print(hasattr(b, 'name'))
print(getattr(b, 'name', '对象的属性类不能获取'))
delattr(b, 'name')
print(setattr(b, 'age', 18))
# 对象的属性对象来操作


class C:
    def fn(self):
        print('fn')

    @classmethod
    def func(cls):
        print('func')

fn = getattr(C, 'fn')
c = C()
fn(c)  # 类获取对象方法调用时传入具体的对象

obj_fn = getattr(c, 'fn')
obj_fn()  # 对象获取对象方法调用时不用传参

func = getattr(C, 'func')
func()  # 类获取类方法调用时不需要传入参数