Python 基础 面向对象之二 三大特性

Python 基础 面向对象之二 三大特性

上一篇主要介绍了Python中，面向对象的类和对象的定义及实例的简单应用，本篇继续接着上篇来谈，在这一篇中我们重点要谈及的内容有：Python 类的成员、成员修饰符 面向对象的三大特性：继承、多态和封装，貌似今天内容挺多的，没有关系，慢慢来！

一、类中的基本知识：

一、类的成员、成员修饰符

        一、字段

字段包括：普通字段和静态字段，他们在定义和使用中有所区别，而最本质的区别是内存中保存的位置不同，

• 普通字段属于对象
• 静态字段属于类

 class Room:
     tag=1
     def __init__(self,name,owner,width,length,heigh):
         self.name=name
         self.owner=owner
         self.width=width
         self.length=length
         self.heigh=heigh
 
 r1=Room('厕所','sb',100,100,100000)
 print(r1.name)  # 访问的是普通字段
 print(Room.tag) # #直接访问静态字段

so,通过上述例子可以看出：

• 静态字段在内存中只保存一份
• 普通字段在每个对象中都要保存一份（相当于绑定在每个实例化对象的身上，然后本身有一个类“指针”的东西指向类）

应用场景： 通过类创建对象时，如果每个对象都具有相同的字段，那么就使用静态字段

    二、方法

方法包括：普通方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。

• 普通方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
• 类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
• 静态方法：由类调用；无默认参数；

class Foo:
 
    def __init__(self, name):
        self.name = name
 
    def ord_func(self):
        """ 定义普通方法，至少有一个self参数 """
 
        # print self.name
        print ('普通方法')
 
    @classmethod
    def class_func(cls):
        """ 定义类方法，至少有一个cls参数 """
 
        print ('类方法')
 
    @staticmethod
    def static_func():
        """ 定义静态方法 ，无默认参数"""
 
        print ('静态方法')
 
# 调用普通方法
f = Foo('sb')
f.ord_func()
 
# # 调用类方法
Foo.class_func()
f.class_func()
#
# # 调用静态方法
Foo.static_func()
f.static_func()

类方法调用和静态方法调用的时候既可以使用使用类名调用，也可以使用对象来调用，区别在哪里呢？注意：最大的区别是用类名调用的时候是不需要实例化的，而使用对象来访问时是先要进行实例化，之后再进行调用。

三、属性　　

如果你已经了解Python类中的方法，那么属性就非常简单了，因为Python中的属性其实是普通方法的变种。

对于属性，有以下三个知识点：

• 属性的基本使用
• 属性的两种定义方式

 class Goods:
     @property
     def pricr(self):
         #print('nijiushidahbi')
         return "haishininiubi"
 
 obj = Goods()
 result = obj.pricr
 print(result)
 
 显示结果：haishininiubi

由属性的定义和调用要注意一下几点：

• 定义时，在普通方法的基础上添加 @property 装饰器；
• 定义时，属性仅有一个self参数
• 调用时，无需括号
             方法：foo_obj.func()
             属性：foo_obj.prop

注意：属性存在意义是：访问属性时可以制造出和访问字段完全相同的假象

属性由方法变种而来，如果Python中没有属性，方法完全可以代替其功能。

Python的属性的功能是：属性内部进行一系列的逻辑计算，最终将计算结果返回

二、面向对象编程的三大特性介绍

1.继承与派生

继承是一种创建新的类的方式，在python中，新建的类可以继承自一个或者多个父类，原始类称为基类或超类，新建的类称为派生类或子类。

python中类的继承分为：单继承和多继承

 class Grandfather:
     pass
 
 class Father(Grandfather): #单继承 Father是派生类，grandfather 是基类
     pass
 
 class son(Father,Grandfather): #多继承
     pass

继承使用产生的场景：如果我们定义了一个类A，然后又想新建立另外一个类B，但是类B的大部分内容与类A的相同时我们不可能从头开始写一个类B，这就用到了类的继承的概念。通过继承的方式新建类B，让B继承A，B会‘遗传’A的所有属性(数据属性和函数属性)，实现代码重用。

除了继承与派生的概念还有一个概念是需要提出的那就是：组合。组合就是指在一个类中以另外一个类的对象作为数据属性，成为类的组合。

组合与继承两者到底什么的关系？1.继承的方式：通过继承建立了派生类与基类的关系，两者之间是“是”的关系。当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如教授是老师    2.组合的方式：用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python课程（当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好）

class School:
    def __init__(self,name,addr):
        self.name=name
        self.addr=addr
 
    def zhao_sheng(self):
        print('%s 正在招生' %self.name)
 
class Course:
    def __init__(self,name,price,period,school):
        self.name=name
        self.price=price
        self.period=period
        self.school=school
 
s1=School('北大','北京') 
 
c1=Course('linux',10,'1h',s1)
print(c1.name) #linux
print(c1.school) # <__main__.School object at 0x02182330>
print(c1.school.name) # 北大
print(c1.school.addr) # 北京

在这个例子中呢，创建了两个类，一个是学校类一个是课程类。需要将课程类与学校类进行相关联的时候，继承在这里是不合适的，那我们采用组合的方式来对这两个类进行关联，这样就在实例化一门课程的时候把学校的信息进行关联。

接口的概念：

继承有两种用途：

一：继承基类的方法，并且做出自己的改变或者扩展（解决代码重用，但是子类与基类出现强耦合）

二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能。(推举使用)

归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。

接口继承：就是定义一个父类，其主要目的就是所有的子类，必须去实现父类的方法（与是否省代码，么有半毛钱关系），父类可以不去具体实现，具体的实现由子类自己去实现。

举个例子：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样。

抽象类： 从实现角度来看，抽象类与普通类的不同之处在于：抽象类中只能有抽象方法（没有实现功能），该类不能被实例化，只能被继承，且子类必须实现抽象方法（这种解释有点像接口了）

#一切皆文件
import abc #利用abc模块实现抽象类
 
class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        pass
 
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass
 
# class Txt(All_file):
#     pass
#
# t1=Txt() #报错,子类没有定义抽象方法
 
class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')
 
    def write(self):
        print('文本数据的读取方法')
 
class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')
 
    def write(self):
        print('硬盘数据的读取方法')
 
class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')
 
    def write(self):
        print('进程数据的读取方法')
 
wenbenwenjian=Txt()
 
yingpanwenjian=Sata()
 
jinchengwenjian=Process()
 
#这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read()
 
print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)

继承实现的原理：（多继承，很多语言只支持单继承）

Python继承中有两种方式：一种是深度优先；另一种是广度优先；

当类是经典类时，多继承会按照深度优先方式查找；当类是新式类时，多继承会按照广度优先方式查找。注：当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

现在举个例子进行说明：

class A(object):
    def test(self):
        print('from A')
 
class B(A):
    def test(self):
        print('from B')
 
class C(A):
    def test(self):
        print('from C')
 
class D(B):
    def test(self):
        print('from D')
 
class E(C):
    def test(self):
        print('from E')
 
class F(D,E):
    # def test(self):
    #     print('from F')
    pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性
 
#新式类继承顺序:F->D->B->E->C->A
#经典类继承顺序:F->D->B->A->E->C
#python3中统一都是新式类
#pyhon2中才分新式类与经典类

在查找的过长中一旦找到查找过程就会立即中断，不会继续查找。

多继承的原理：（Python实现多继承的原理）

python到底是如何实现继承的，对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表，例如：

F.mro() #等同于F.__mro__
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'objec
t'>]

子类调用父类方法的实现过程：子类继承了父类的方法，然后想进行修改，注意了是基于原有的基础上修改，那么就需要在子类中调用父类的方法。

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

class Vehicle: #定义交通工具类
     Country='China'
     def __init__(self,name,speed,load,power):
         self.name=name
         self.speed=speed
         self.load=load
         self.power=power
 
     def run(self):
         print('开动啦...')
 
class Subway(Vehicle): #地铁
    def __init__(self,name,speed,load,power,line):
        Vehicle.__init__(self,name,speed,load,power) #子类继承父类
        self.line=line
 
    def run(self):
        print('地铁%s号线欢迎您' %self.line)
        Vehicle.run(self)
 
line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
line13.run()
 
# 地铁13号线欢迎您
开动啦...

方法二：super()（推举使用此种方式）

class Vehicle: #定义交通工具类
     Country='China'
     def __init__(self,name,speed,load,power):
         self.name=name
         self.speed=speed
         self.load=load
         self.power=power
 
     def run(self):
         print('开动啦...')
 
class Subway(Vehicle): #地铁
    def __init__(self,name,speed,load,power,line):
        #super(Subway,self) 就相当于实例本身 在python3中super()等同于super(Subway,self)
        super().__init__(name,speed,load,power)
        self.line=line
 
    def run(self):
        print('地铁%s号线欢迎您' %self.line)
        super(Subway,self).run()
 
class Mobike(Vehicle):#摩拜单车
    pass
 
line13=Subway('中国地铁','180m/s','1000人/箱','电',13)
line13.run()

注意：使用super调用的所有属性，都是从MRO列表当前的位置往后找，千万不要通过看代码去找继承关系，一定要看MRO列表。

    2.多态（性）

多态是指一个事物有多中形态（一个抽象类有多个子类，so 多态的概念依赖于继承），而多态性是指：指具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容的函数。

在面向对象方法中一般是这样表述多态性：向不同的对象发送同一条消息，不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

多态是反映在执行时的状态，在面向对象中，多态是怎么来得呢？首先，先定义一个基类，再定义一堆子类。其次，才能展现不同的类实例化出的实例去调用同一个方法。

 class H2O:
     def __init__(self,name,temperature):
         self.name=name
         self.temperature=temperature
     def turn_ice(self):
         if self.temperature < 0:
             print('[%s]温度太低结冰了' %self.name)
         elif self.temperature > 0 and self.temperature < 100:
             print('[%s]液化成水' %self.name)
         elif self.temperature > 100:
             print('[%s]温度太高变成了水蒸气' %self.name)
     def aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(self):
         pass
 
 class Water(H2O):
     pass
 class Ice(H2O):
     pass
 class Steam(H2O):
     pass
 
 w1=Water('水',25)
 i1=Ice('冰',-20)
 s1=Steam('蒸汽',3000)
 
 w1.turn_ice()
 i1.turn_ice()
 s1.turn_ice()

3.封装

装就是把东西包起来，而封的意思就是把口子封起来。为何要在编程的过程中使用这一特性呢？封装数据的作用就是为了保护隐私，而封装方法的作用就是为了隔离复杂程度。
    封装其实是有两个层面的意思：

其一：第一个层面的封装（什么都不用做）：创建类和对象会分别创建二者的名称空间，我们只能用类名.或者obj.的方式去访问里面的名字，这本身就是一种封装。（注意：对于这一层面的封装（隐藏），类名.和实例名.就是访问隐藏属性的接口）

其二：第二个层面的封装：类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问，或者留下少量接口（函数）供外部访问。

在Python中，用双下划线来实现隐藏属性（设置成私有的），（类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式）

class A:
    __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
    def __init__(self):
        self.__X=10 #变形为self._A__X
    def __foo(self): #变形为_A__foo
        print('from A')
    def bar(self):
        self.__foo() #只有在类内部才可以通过__foo的形式访问到.
 
f1 = A()
# f1.__foo() # 'A' object has no attribute '__foo'
f1.bar() # 通过在对象A中创建一个接口，在内部调用私有方法

好了，今天就搞到这里，明天继续！！！