笔记更新于2019年11月25日,
摘要:面向对象的三大特征;封装;继承;多态;动态语言的鸭子类型
写在前面:为了更好的学习python,博主记录下自己的学习路程。本学习笔记基于廖雪峰的Python教程,如有侵权,请告知删除。欢迎与博主一起学习Pythonヽ( ̄▽ ̄)ノ
面向对象编程
面向对象编程有三大特征,分别是封装、继承和多态。
封装
封装,顾名思义是将数据封装到某处,在要用的时候再从某处调用。
• 封装数据
首先定义一个class(类)
class Animal(object):
def __init__(self,name,age):
self.name = name
self.age = age
然后定义创建一个对应的Instance(实例)
dog = Animal('dog',3)
事实上,在创建该实例的同时,就把数据’dog’和3分别封装到dog的name和age属性中,这个过程就是数据封装。
• 调用封装数据
调用封装数据有两种方法,一种是通过对象直接调用:
>>>dog.name
dog
>>>dog.age
3
另一种是通过在类的内部定义方法来间接调用::
class Animal(object):
def __init__(self, name, age):
self.name = name
self.age = age
def detail(self): #再创建一个方法来调用数据
print('name = %s' % self.name)
print('age = %d' % self.age)
>>>dog.detail()
name = dog
age = 3
这样的话,从外部看Animal类,只需要知道创建实例时给出name和age,至于如何打印,都在Animal内部定义,这样就把这些数据和逻辑封装起来,可以简单调用却不用知道内部的细节。
继承
在OOP程序设计中,在定义一个class时,可以从另一个class继承下来,新的class称为子类或派生类,被继承的class称为父类或超类、基类。举些简单的例子:
父类 | 子类 |
---|---|
动物 | 狗,猫,熊 |
文具 | 笔,尺子,橡皮 |
这跟类与实例的关系有点像,只不过在这里两者都是类。
继承最大的好处就是子类可以沿用父类里面的全部功能,比如我们定义一个继承Animal类型的Dog类。
class Dog(Animal):
def __init__(self,name,age):
self.name = name
self.age = age
这时候我们再创建一个Dog对应的实例dog,此时dog就可以用Animal的方法了。
>>>dog = Dog('pupy',1)
>>>dog.detail()
name = pupy
age = 1
可见在Dog中并没有定义detail这一方法,而实例dog是继承了Animal里面的detail方法。
• 多继承
在java和C#中只能继承一类,而在Python中允许继承多类,举个简单的例子。
class D(object): #定义一个父类D
def say(self):
print('D.say')
class B(D): #B类继承D类
def say(self):
print('B.say')
class C(D): #C类继承D类
def say(self):
print('C.say')
class A(B,C): #A类继承B类和C类
这个时候A就继承了两个类,B与C。现在有个问题是当A的实例在.say()的时候,是执行哪个类的say方法呢?看一下输出结果:
>>>a = A()
>>>a.say()
B.say
在多继承中,在调用方法时,会按照广度优先的方式去查找对应的方法。
在本例中,先查找A类有没有say(),然后查找B类,再查找C类,最后查找D类,如果都没找到则报错,如果找到了则不会再查找后面的类。
(这里插一个小知识点,在Python2及以前的版本中,存在经典类和新式类两种类,经典类在定义时没有继承object,而新式类则有继承。现在使用的便是新式类,采用广度优先的方式查找,而经典类采用深度优先的方式查找,放在上例中就是A-B-D-C的顺序。而在Python3即之后的版本中,已经没有经典类和新式类的说法了,都默认采用新式类,即使在定义时没有继承object)
• Mixin
多继承的好处是能简化多层次的继承关系。这里举廖雪峰官方网站里面的一个例子来说明。
假设我们要实现以下4种动物:
Dog - 狗狗;
Bat - 蝙蝠;
Parrot - 鹦鹉;
Ostrich - 鸵鸟。
按照哺乳动物Mammal和鸟类Bird归类,我们可以设计出这样的类的层次:
┌───────────────┐
│ Animal │
└───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ Mammal │ │ Bird │
└─────────────┘ └─────────────┘
│ │
┌─────┴──────┐ ┌─────┴──────┐
│ │ │ │
▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Dog │ │ Bat │ │ Parrot │ │ Ostrich │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
这时如果我们要添加“能跑”“能飞”的分类,层次就会变成这样:
┌───────────────┐
│ Animal │
└───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ Mammal │ │ Bird │
└─────────────┘ └─────────────┘
│ │
┌─────┴──────┐ ┌─────┴──────┐
│ │ │ │
▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ MRun │ │ MFly │ │ BRun │ │ BFly │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
│ │ │ │
│ │ │ │
▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Dog │ │ Bat │ │ Ostrich │ │ Parrot │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
如果还要再分“宠物类”和“非宠物类”,那么类的数量会呈指数增长,这样明显不行。这时候就需要用到多重继承了。
先定义一个主要类层,还是按哺乳类和鸟类设计:
class Animal(object):
pass
#大类:
class Mammal(Animal):
pass
class Bird(Animal):
pass
再额外定义Runnable类和Flyable类:
class Runnable(object):
def run(self):
print('Running...')
class Flyable(object):
def fly(self):
print('Flying...')
这时候再定义动物小类,如果是能跑的哺乳类动物,则同时继承上面两个类即可:
class Dog(Mammal, Runnable):
pass
class Bat(Mammal, Flyable):
pass
这种“混入”额外功能的多重继承设计通常称之为Mixin。MixIn的目的就是给一个类增加多个功能。为了更好体现出继承关系,通常在把额外功能的类名改为XxxMixin,像这样:
class RunnableMixin(object):
def run(self):
print('Running...')
class FlyableMixin(object):
def fly(self):
print('Flying...')
class Dog(Mammal, RunnableMixin):
pass
class Bat(Mammal, FlyableMixin):
pass
多态
多态,是指一个对象具有多种形态,或者说一个类型具有多种类型的能力。
在理解多态之前,我们要对数据类型再做一点说明。实际上,在我们定义一个类的时候,也就是定义了一种数据类型。
x = int(5) #x是int类型
y = list(1) #y是list类型
a = Animal() #a是Animal类型
dog = Dog() #dog是Dog类型
接下来我们定义一个父类及其一些子类:
class Animal(object):
pass
class Dog(Animal):
pass
class Cat(Animal):
pass
class Pig(Animal):
pass
由于继承的关系,Dog的实例dog不仅是Dog类型,还是Animal类型,可以通过isinstance()来判断:
>>>dog = Dog()
>>>isinstance(dog, Dog)
True
>>>isinstance(dog, Animal)
True
所以,在继承关系中,如果一个实例的数据类型是某个子类,那它的数据类型也可以被看做是父类。
接下来我们在类中增加一些方法,再定义一个函数。
class Animal(object):
def __init__(self,name): #在创建实例时,绑定一个name属性
self.name = name
def run(self,name): #定义一个方法,打印想要的内容
print(self.name + ' is running!')
class Dog(Animal):
pass
class Cat(Animal):
pass
class Pig(Animal):
pass
def run1(animal): #定义一个接受animal类型的函数
print('wow!')
animal.run(animal.name) #执行animal中的run方法
horse = Animal('lin') #创建一个Animal类的实例
dog = Dog('pupy') #创建一个Dog类的实例
cat = Cat('miumiu') #创建一个Cat类的实例
执行run1函数,传入实例对象horse:
>>>run1(horse)
wow!
lin is running!
当我们传入实例对象dog和cat时同样可以执行。
>>>run1(dog)
wow!
pupy is running!
>>>run1(cat)
wow!
miumiu is running!
这就是所讲的多态。对于函数run1而言,传入的animal可以是Animal类型,也可以是Dog类型或是Cat类型的实例对象。
看到这里,你或许会有疑问:animal只不过是一个函数的参数,难道不可以接受任何类型的数据?
是的,你没有错,这就是动态语言的特点。所以实质上,对于Python这种动态语言来说,并没有多态这一说法,而是崇尚鸭子类型。
鸭子类型
Duck typing,鸭子类型,是动态类型的一种风格。
这个概念的名字来源于由James Whitcomb Riley提出的鸭子测试,“鸭子测试”可以这样表述:
“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子,那么这只鸟就可以被称为鸭子。”
接上面的例子,我们再定义一个类,这个类不继承Animal。
class Xxxx(object):
def __init__(self, name):
self.name = name
def run(self, name):
print(self.name + ' is running!')
aaaa = Xxxx('aaaa')
把实例对象aaaa传入run1函数,依旧可以执行。
>>>run1(aaaa)
wow!
aaaa is running!
run1函数并没有判断传入的参数是否为animal类型,只是判断传入的参数是否有run的方法,如果有,则可以执行。
这就是动态语言的鸭子类型,run1函数并不在乎传入的aaaa是不是动物(鸭子),它只是run(走)起来像animal(鸭子),那么把它就可以被当成动物(鸭子)。
以上就是本节的全部内容,感谢你的阅读。
下一节内容:13.获取对象信息type( )、isinstance( )、dir( ) 的用法
有任何问题与想法,欢迎评论与吐槽。
和博主一起学习Python吧( ̄▽ ̄)~*