20180315-Python面向对象编程设计和开发

1.在子类中调用父类的方法

在子类派生出的新方法中，往往需要重用父类的方法，我们有两种实现方式：

方式一：父类名.父类方法()

Animal.__init__(self,name)

方式二：super().父类方法()

super().__init__(name)  #super(Dog,self) 就相当于实例本身了，因为在python3中super()等于super(Dog,self)

两种方式的区别:方式一是跟继承没有关系的，方式二是依赖于继承的，并且即使没有直接继承关系，super()仍然会按照__mro__继续往后查找

class A:
    def test(self):
        super().test()

class B:
    def test(self):
        print('from B')

class C(A,B):
    pass

c = C()
c.test()
# 打印结果
# from B

print(C.__mro__)
# 打印结果
# (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

2.isinstance和issubclass区别？

答：isinstance(obj,cls) 用于检测obj是否为类cls的对象

　　issubclass(sub,cls) 用于检测sub类是否为cls类的派生类

3.通过__import__('module_name',fromlist=True)的方式，可以以字符串的形式导入模块

4.classmethod和staticmethod装饰器装饰方法的区别？

答：classmethod装饰器装饰的方法，是指绑定到类的方法，代码形式如下：func(cls)： pass,自动将类作为第一个参数传入函数，其实对象也可以调用，但仍将类作为第一个参数传入函数

　　staticmethod装饰器装饰的方法，非绑定方法，不与类和对象绑定，类和对象都可以调用，但是没有自动传入参数那么一说

　　具体区别请看代码：

class MySQL:
    def __init__(self,host,port):
        self.host = host
        self.port = port
        
    @staticmethod
    def from_conf():
        return MySQL(HOST,PORT)

    @classmethod
    def from_conf(cls):
        print(cls)
        return cls(HOST,PORT)

5.__dict__用于查看类或对象的命名空间

6.类有两种属性：数据属性和函数属性

1. 类的数据属性是共享的,数据属性具体指类的变量属性

   class OldboyStudent:
       school = 'lufficity'
   
       def __init__(self):
           pass
   
   
   s1 = OldboyStudent()
   s2 = OldboyStudent()
   s3 = OldboyStudent()
   
   print(id(OldboyStudent.school)) #4355952816
   print(id(s1.school)) #4355952816
   print(id(s2.school)) #4355952816
   print(id(s3.school)) #4355952816

2. 类的函数属性是绑定给对象用的，称为绑定到对象的方法

   class OldboyStudent:
       school = 'lufficity'
   
       def __init__(self):
           pass
   
       def learn(self):
           print('learn')
   
   
   
   s1 = OldboyStudent()
   s2 = OldboyStudent()
   s3 = OldboyStudent()
   
   
   print(OldboyStudent.learn) #<function OldboyStudent.learn at 0x105209598>
   print(s1.learn) #<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x105205320>>
   print(s2.learn) #<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x105205470>>
   print(s3.learn) #<bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x105205438>>

　　注意：在obj.name中，会先在obj所在的命名空间寻找name，找不到则去obj所在的类中寻找，类找不到就从父类中寻找，如果还是找不到则抛出异常

7.SubClass.__bases__ 查看继承，__bases__查看所有继承的父类

8.抽象类

抽象类是一个特殊的类，他的特殊之处就在于只能被继承，不能被实例化。

如果说类是从一堆对象中抽取相同内容而来的，那抽象类就是从一堆类中抽取相同内容而来的，内容包括数据属性和函数属性。

从设计的角度来看，如果说类是从现实对象抽象而来的，那么抽象类就是基于类中抽象而来的。

从实现的角度来看，抽象类和普通类的不用之处在于：抽象类只能有抽象方法(没有实现功能)，该类不能被实例化，只能被继承，且子类必须实现抽象方法，这一点与接口有点类似。

Python中实现抽象类

from abc import abstractmethod, ABCMeta


class AllFile(metaclass=ABCMeta):
    all_type = 'file'

    @abstractmethod  # 定义抽象方法，无需实现功能
    def read(self):
        '子类必须实现功能'
        pass

    @abstractmethod  # 定义抽象方法，无需实现功能
    def write(self):
        '子类必须实现功能'
        pass


class Txt(AllFile):
    def read(self):
        print('文本数据的读取方法')

    def write(self):
        print('文本数据的写方法')


class Sata(AllFile):
    def read(self):
        print('硬盘数据读取方法')

    def write(self):
        print('硬盘数据的写方法')


txt = Txt()
st = Sata()

# 这样大家都被归一化了，也就是一切皆文件都思想
txt.read()
st.write()

print(txt.all_type)
print(st.all_type)

抽象类和接口的区别：

抽象类的本质还是类，指的是一组类的相似性，包括数据属性和函数属性，而接口强调函数属性的相似性

抽象类是介于类和接口的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计

9.在继承中如果父类不想让子类覆盖自己的方法，可以将方法定义的私有化 __func

10.封装方法：目的是隔离复杂度

# 封装方法：隔离复杂度
# 取款功能：这个功能是由多个功能组成的，包括插卡、用户验证、输入金额、打印账单、取钱
# 对于使用者来说，只关心取钱功能，其他的功能是可以隐藏起来的
# 隔离了复杂度，而且提高的安全性
class ATM:
    def __card(self):
        print('插卡')

    def __auth(self):
        print('用户验证')

    def __input(self):
        print('输入金额')

    def __print_bill(self):
        print('打印账单')

    def __take_money(self):
        print('取钱')

    def withdraw(self):
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()

atm = ATM()
atm.withdraw()

 11.特性

property是一种特殊属性，访问时他会执行一段功能(函数)，然后返回值

import  math


class Circle:
    def __init__(self,radius):
        self.radius = radius

    @property
    def area(self): # 计算圆的面积
        return math.pi * self.radius ** 2

    @property
    def perimeter(self): # 计算圆的周长
        return 2 * math.pi * self.radius

c = Circle(10)

print('圆的面积:',c.area)
print('圆的周长:',c.perimeter)

注意：此时的area、perimeter不能被赋值

为什么要用property？

将一个函数定义成一个特性后，对象再去使用的时候obj.name，根本无法察觉name是通过函数计算出来的，这种特性的使用遵循了归一化的设计

除此之外：

面向对象的的封装有三种方式：
public
这种其实就是不封装，对外公开
protected
这种封装对外不公开，但是对其朋友、子类公开
priviate
这种封装其实对谁都不公开

Python其实并没有把这三种封装到class机制中，在C++里面一般都会将所有的数据设置为所有的，然后提供get和set方法获取和设置，在Python中通过property方法去实现

class Foo:
    def __init__(self,val):
        self.__NAME = val # 将数据属性都隐藏起来

    @property
    def name(self):
        return self.__NAME  # obj.name访问的是self.__NAME

    @name.setter
    def name(self,value):
        if not isinstance(value,str): # 在设定值之前进行检查
            raise TypeError('%s must be str' % value)
        self.__NAME = value

f = Foo('egon')
print(f.name)
f.name = 'alex'
print(f.name)