Python 面向对象拾遗

1.装饰器 （property +方法）

经典类：只有一种@property 装饰器

class A:
    @property
    def fuc(self):
        return 'ccc'
a = A()
print(a.fuc)

新式类：具有多种property 装饰器

class A(object):
    @property
    def func(self):
        return "2.7"
    @func.setter
    def func(self,value):
        print('"2.7"+value')
    @func.deleter
    def func(self):
        print('del')
a = A()
print(a.func)
a.func = 111
del a.func

 2.静态字段，property内置函数+方法 ->类中的静态字段，通过对象访问

 经典类

class A:
    def get_info(self):
        return 'aaa'
    PRO = property(get_info)

a = A()
print(a.PRO)

 新式类

class A(object):
    def get_info(self):
        return 'aaa'
    def set_info(self,value):
        print(value)
    def del_info(self):
        print('del')
    PRO = property(get_info,set_info,del_info,'this is a doc')

a = A()
print(a.PRO)
a.PRO = 111
del a.PRO
print(A.PRO.__doc__)

3.经典类与新式类

  在2.7中，没有继承object 则是经典类，继承了object 则是新式类

  在3.5中，统统都是新式类

  经典类继承流程：深度优先算法

 实现代码：

#经典类，多继承
class F:
    def __init__(self):
        pass
    def func(self):
        print('F')
class E(F):
    def __init__(self):
        pass
    def func(self):
        print('E')
class D(F):
    def __init__(self):
        pass
    def func(self):
        print('D')
class C(E):
    def __init__(self):
        pass
    def func(self):
        print('C')
class B(D):
    def __init__(self):
        pass
    def func(self):
        print('B')
class A(B,C):
    def __init__(self):
        pass
    def func(self):
        print('A')

a = A()
a.func()
# A - B - D -F -C - E  深度优先算法

新式类继承流程图：

实现代码：

#新式类
class F(object):
    def __init__(self):
        pass
    def func(self):
        print('F')
class E(F):
    def __init__(self):
        pass
    # def func(self):
    #     print('E')
class D(F):
    def __init__(self):
        pass
    # def func(self):
    #     print('D')
class C(E):
    def __init__(self):
        pass
    # def func(self):
    #     print('C')
class B(D):
    def __init__(self):
        pass
    # def func(self):
    #     print('B')
class A(B,C):
    def __init__(self):
        pass
    # def func(self):
    #     print('A')


a = A()
a.func()
# A - B -D - C -E - F 类似广度优先算法

 4.抽象类与抽象方法 （主要起到约束的作用）

第一种实现方法，但是有缺点

#抽象类与抽象方法,
class A:
    def func(self,value):
        raise NotImplementedError

class B(A):
    def __init__(self):
        pass
    def func(self,value):
        print(value)
        return value

b = B()
b.func(555) # 555，如果没有实现该方法，调用的时候就会抛出异常，并不是实例化的时候抛出异常

推荐第二种

import abc
class A:
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def func(self,value):
        return

class B(A):
    def __init__(self):
        pass

    def func(self,value):
        print('i am a instance of abstractmethod '+value)

b = B()  #如果方法没有实现，在实例化的时候就会抛出异常
b.func('func')

 等价

import abc
class A(metaclass=abc.ABCMeta):

    @abc.abstractmethod
    def func(self,value):
        return

class B(A):
    def __init__(self):
        pass

    def func(self,value):
        print('i am a instance of abstractmethod '+value)

 

5.Python中接口两种实现方法，一种是抽象类和抽象方法。另一种子类继承父类，父类的方法都pass。

6.接口是做约束的，抽象方法与抽象类：既可以继承，又可以约束