面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。
面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。
而面向对象的程序设计把计算机程序视为一组对象的集合，而每个对象都可以接收其他对象发过来的消息，并处理这些消息，计算机程序的执行就是一系列消息在各个对象之间传递。
在Python中，所有数据类型都可以视为对象，当然也可以自定义对象。自定义的对象数据类型就是面向对象中的类（Class）的概念。
面向对象编程和函数编程有什么区别？
函数编程与OOP的主要区别就是OOP可以使程序更加容易扩展和易更改，专业术语叫可读性好、易扩展。
一、封装
# 创建一个类：Person
class Person(object): # (object)是新式类的写法，经典类不用写这个。
def __init__(self, name, age): # 类的构造方法，实例化时自动执行
self.name = name
self.age = age
def show_info(self):
print("Name:%s,Age:%s" % (self.name,self,age))
# 实例化一个Person类的对象，自动执行类中的__init__方法
# 将Jack和18封装到person1的name和age属性中
person1 = Person("Jack", 18)
# 直接调用Jack的封装（person1对象），会输出Jack的name（person1对象的name属性）
print(person1.name)
# 通过self间接调用被封装的内容：Python默认会将person1传给self参数，即：person1.show_info(person1)，所以，此时方法内部的self = person1，即：self.name是Jack , self.age是18
person1.show_info()
# 所以，内容其实被封装到了对象 person1 中，每个对象中都有 name 和 age 属性。
# 注：self是一个形式参数，当执行person1 = Person("Jack", 18)时，self等于person1.
综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。
二、继承
继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。
对于面向对象来说，继承其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法,它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
- 通过继承创建的新类称为“子类”或“派生类”。
- 被继承的类称为“基类”、“父类”或“超类”。
- 继承的过程，就是从一般到特殊的过程。
要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。
class People(object): # 创建一个类：People
def __init__(self,name,age): # 父类的构造方法，实例化时自动执行。
self.name = name
self.age = age
def show_info(self): # 父类的方法
print("%s is %s years old." % (self.name,self.age))
class Teacher(People): # 创建一个类：Teacher，继承People类。
def __init__(self,name,age,course):
# People.__init__(self,name,age) # 不推荐这么写
super(Teacher,self).__init__(name,age) # 推荐写法，在子类的构造方法里只出现子类的类名
self.course = course
def show_course(self): # 定义一个方法
print("Teacher:%s is teaching %s" % (self.name,self.course)) # 继承了父类的name属性
Jack = Teacher("Jack",33,"Python") # 实例化一个老师：Jack
Jack.show_info() # 调用父类的方法 output>> Jack is 33 years old.
Jack.show_course() # 调用本类的方法 output>> Teacher:Jack is teaching Python
多继承
class D(object):
def bar(self):
print ('D.bar')
class C(D):
def bar(self):
print ('C.bar')
class B(D):
def bar(self):
print ('B.bar')
class A(B, C):
def bar(self):
print ('A.bar')
a = A()
a.bar()
# 执行a.bar方法时，首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
# 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
# 查找顺序：A --> B --> C --> D
# 这种查找顺序被称为：广度优先。
- 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。
- 新式类包含了很多新的功能，推荐使用新式类。
Python3.x中多继承时不管是经典类还是新式类都是广度优先。
Python2.x中多继承时经典类（深度优先），新式类（广度优先）：
深度优先：（A > B > D > C）首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中没有，则继续去C类中找，如果还是未找到，则报错。
广度优先：（A > B > C > D）首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中没有，则继续去D类中找，如果还是未找到，则报错。
注意：在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
三、多态
多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的：接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”。
通过Python模拟的多态：
class Animal:
def __init__(self, name): # Constructor of the class
self.name = name
def talk(self): # Abstract method, defined by convention only
raise NotImplementedError("Subclass must implement abstract method")
class Cat(Animal):
def talk(self):
return 'Meow!'
class Dog(Animal):
def talk(self):
return 'Woof! Woof!'
animals = [Cat('Missy'),
Dog('Lassie')]
for animal in animals:
print animal.name + ': ' + animal.talk()
总结
- 面向对象（Object Oriented Programming，OOP）是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用。
- 类 是一个模板，模板中包装了多个“函数”供使用（可以将多函数中公用的变量封装到对象中）。
- 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数。
- 面向对象三大特性：封装、继承和多态