*写在前面：为了更好的学习python，博主记录下自己的学习路程。本学习笔记基于廖雪峰的Python教程，如有侵权，请告知删除。欢迎与博主一起学习Pythonヽ(￣▽￣)ﾉ *
目录
面向对象编程
封装
• 封装数据
• 调用封装数据
继承
• 多继承
• Mixin
多态
鸭子类型
面向对象编程
面向对象编程有三大特征，分别是封装、继承和多态。
封装
封装，顾名思义是将数据封装到某处，在要用的时候再从某处调用。
封装数据
首先定义一个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 = 2
可见在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（鸭子），那么把它就可以被当成动物（鸭子）。
以上就是本节的全部内容，感谢你的阅读。
有任何问题与想法，欢迎评论与吐槽。
和博主一起学习Python吧(￣▽￣)~*
网友评论