1.面向对象的思想
Python是一种面向对象语言。面向对象没有那么玄乎，可以理解成“对象就是一个角色”。面向对象就是对象是个服务生，我们面对着他，不需要了解太多，只需要知道他能给为我们做些什么，当需要相关服务时，直接找他就行。
比如，字符串就是一个对象，当我们需要用到字符串替换时，直接找str就行，它有自己独特的功能replace，直接调用就行：
str1 = "庆余年"
str1.replace("庆余年", "将夜")
'将夜'
其实Python中的数据类型都是一个个对象，我们直接用就可以，简单粗暴。这就是面向对象的好，它把实现细节都封装起来，不需要自己多花力气去实现，用就完了。
当Python中没有我们需要的服务，找不到服务生（对象）时，就需要自己根据需求创建对象。
2.对象的创建和操作
在了解如何创建和操作对象前，先来了解下类的知识。类是一个结构，它会提供必要的框架，通过这个结构，去实例化出一个又一个对象。
比如我们定义一个类是房子，它是一个结构，告诉我们房子的属性，比如层数，占地面积等等，接着我们就可以通过这个类，进行实例化，得到一个个对象实例，比如高楼，别墅等等，这些得到的对象，都是有“数据”的。
为了方便理解，下面以定义“人”为例：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
使用关键字class就可以定义类，截止用__init__方法进行初始化。后面的self代表的是实例本身，name和age属于这个类的属性。
self.name = name
self.age = age
以上两行，声明每一个实例化得到的对象的属性值。
如何实例化呢？很简单，通过Person("zhangsan", 18)就可以实例化类，得到一个对象。zhangsan现在就是一个通过Person实例化得到的对象，名字是zhangsan，年龄是18。
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
zhang_san = Person("zhangsan", 18)
print(zhang_san.name)
print(zhang_san.age)
zhangsan
18
我们可以用这个类来实例化其他对象，比如wangwu：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
wang_wu = Person("wangwu", 23)
print(wang_wu.name)
print(wang_wu.age)
wangwu
23
我们也可以定义共同的变量，比如：
class Person:
hobby = "reading"
def __init__(self, name, age):
self.name = name
self.age = age
zhang_san = Person("zhangsan", 18)
wang_wu = Person("wangwu", 23)
print(zhang_san.hobby)
print(wang_wu.hobby)
reading
reading
可以看出，不同的实例可以访问当类里的同一个变量。
除了定义属性外，还可以定义功能，就是我们通常说的方法，比如说和吃。
class Person:
hobby = "reading"
def __init__(self, name, age):
self.name = name
self.age = age
def say(self, something):
return "{} 说 {}".format(self.name, something)
def eat(self, food):
return "{} 吃 {}".format(self.name, food)
zhang_san = Person("zhangsan", 18)
print(zhang_san.say("今天天不错"))
print(zhang_san.eat("担担面"))
zhangsan 说 今天天不错
zhangsan 吃 担担面
类和对象的知识是不是就结束了？其实并没有，还有更细的内容。
3.父类、子类、继承
如果我们把人类看做一个类，往下还可按照肤色进行细分，比如黄种人、白种人、黑种人等。这里人类就是“父类”，黄种人、白种人等就是“子类”。
人类有的属性和功能，继承得到的子类们也会具有，这些子类们不需要额外的操作。这种关系，在面向对象中，被叫做继承。
#父类
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def play(self, game):
return "{} 玩 {}".format(self.name, game)
#子类继承父类
class Asian(Person):
pass
Lisi = Asian("Lisi", 15)
print(Lisi.play("王者荣耀"))
Lisi 玩 王者荣耀
可以看到黄种人这个对象，可以直接调用它的父类Person的play方法。当然，子类也可以定义自己特有的属性和方法，比如：
#父类
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def play(self, game):
return "{} 玩 {}".format(self.name, game)
#子类
class Asian(Person):
def sing(self, song):
return "{} 唱 {}".format(self.name, song)
Lisi = Asian("Lisi", 15)
print(Lisi.sing("你的答案"))
Lisi 唱 你的答案
如果希望子类和父类的功能不一样，比如父类是“唱”，子类是“动情地唱”：
#方法重写
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def sing(self, song):
return "{} 唱 {}".format(self.name, song)
#子类
class Asian(Person):
def sing(self, song):
return "{} 动情地唱 {}".format(self.name, song)
Liyi = Person("Liyi", 40)
print(Liyi.sing("海阔天空"))
Liliu = Asian("Liliu", 16)
print(Liliu.sing("下山"))
Liyi 唱 海阔天空
Liliu 动情地唱 下山
上面的例子就是“方法的重写”
继续深入地讨论下父类和子类，父类也叫作基类、超类（super class）。类只是一个结构，在定义结构的时候，它并不是实例化出来的对象，只是个定义。那么在定义方法时，如果想要用到 super 类的方法，你就只能用 super 来调用它。
以下来源于 Python:类的继承，调用父类的属性和方法基础详解
以上我们了解过子类继承父类：
class Father():
def __init__(self):
self.a='aaa'
def action(self):
print('调用父类的方法')
class Son(Father):
pass
son=Son() # 子类Son 继承父类Father的所有属性和方法
son.action() # 调用父类方法
son.a # 调用父类属性
调用父类的方法
'aaa'
子类重写方法：
class Father():
def __init__(self):
self.a='aaa'
def action(self):
print('调用父类的方法')
class Son(Father):
def __init__(self):
self.a='bbb'
def action(self):
print('子类重写父类的方法')
son=Son() # 子类Son继承父类Father的所有属性和方法
son.action() # 子类Son调用自身的action方法而不是父类的action方法
son.a
子类重写父类的方法
'bbb'
如果子类没有重写父类的方法，那么调用该方法的时候，会调用父类的方法，当子类重写了父类的方法，默认是调用自身的方法。
如果如果子类Son重写了父类Father的方法，如果想调用父类的action方法，可以利用super()
#如果在重新父类方法后，调用父类的方法
class Father():
def action(self):
print('调用父类的方法')
class Son(Father):
def action(self):
super().action()
son=Son()
son.action()
调用父类的方法
如果自己也定义了 init 方法,那么父类的属性是不能直接调用的,可以在 子类的 init中调用一下父类的 init 方法。
class Father():
def __init__(self):
self.a='aaa'
class Son(Father):
def __init__(self):
super().__init__()
#也可以用 Father.__init__(self) 这里面的self一定要加上
son=Son()
print(son.a)
aaa
再来一个复杂点的例子
class Father():
def __init__(self):
self.a=1
self.b=2
class Son(Father):
def __init__(self):
super().__init__()
#也可以用 Father.__init__(self) 这里面的self一定要加上
def add(self):
return self.a+self.b
son=Son()
print(son.add())
3
父类在初始化过程中，直接对a，b分别赋值1,2。子类利用super(). __init__ ()继承了父类的初始化参数a和b，所以子类调用自身的add函数（add函数返回a和b的和）会返回结果值。
如果不对父类初始化直接赋值，并且子类在调用父类初始化过程中，增加额外自身需要的初始化参数值。
class Father():
def __init__(self,a,b):
self.a = a
self.b = b
def dev(self):
return self.a - self.b
#调用父类初始化参数a,b并增加额外参数c
class Son(Father):
def __init__(self,a,b,c=10): # 固定值： 例如默认c=10，也可以显示地将c赋值
Father.__init__(self,a,b)
self.c = c
def add(self):
return self.a+self.b
def compare(self):
if self.c > (self.a+self.b):
return True
else:
return False
son=Son(1,2) # 由于c在初始化过程中默认为10，所以c可以不用显示表达出来
print(son.dev()) # 调用父类dev函数
print(son.add()) # 子类自身add函数
print(son.compare()) # 子类自身compare函数
-1
3
True
以上都是单继承的情况，下面介绍多继承。比如说儿子的爸爸是黄种人，妈妈是白种人。
#多继承
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self, food):
print(self.name, "调用的是Person方法，正在吃{}".format(food))
class AsianFather(Person):
def eat(self, food):
print(self.name, "调用的是AsianFather方法，正在吃{}".format(food))
class CaucasianMonther(Person):
def eat(self, food):
print(self.name, "调用的是CaucasianMonther方法，正在吃{}".format(food))
class Son(AsianFather, CaucasianMonther):
pass
son = Son("Wangwu", 18)
son.eat("饺子")
Wangwu 调用的是AsianFather方法，正在吃饺子
4.多态
为什么调用的是 YellowPeopleFather 里的方法，而不是其他的方法。多重继承的子类，调用方法的顺序。在 Python 中，使用到的是 MRO，我们可以通过调用子类的 mro 方法来具体查看：
print(Son.__mro__)
(<class '__main__.Son'>, <class '__main__.AsianFather'>, <class '__main__.CaucasianMonther'>, <class '__main__.Person'>, <class 'object'>)
可以看到，这里是调用的顺序是
Son->AsianFather->CaucasianMother–>Person–>object
因为我们的 Son 类没有定义 eat 方法，所以我们才会看到 Son 是调用了 AsianFather里的 eat 方法。
我们可以举个例子再来验证下：
#多继承
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self, food):
print(self.name, "调用的是Person方法，正在吃{}".format(food))
class AsianFather(Person):
def eat(self, food):
print(self.name, "调用的是AsianFather方法，正在吃{}".format(food))
class CaucasianMonther(Person):
def eat(self, food):
print(self.name, "调用的是CaucasianMonther方法，正在吃{}".format(food))
class Son(AsianFather, CaucasianMonther):
def eat(self, food):
print(self.name, "调用的是Son方法，正在吃{}".format(food))
son = Son("Wangwu", 18)
son.eat("饺子")
Wangwu 调用的是Son方法，正在吃饺子
如果我们想在 Son 里面使用AsianFather的 eat 方法，可以根据MRO顺序，使用super。其实调用 super 的时候，就是调用 MRO 顺序的下一个类。
#多态
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def eat(self, food):
print(self.name, "调用的是Person方法，正在吃{}".format(food))
class AsianFather(Person):
def eat(self, food):
print(self.name, "调用的是AsianFather方法，正在吃{}".format(food))
class CaucasianMonther(Person):
def eat(self, food):
print(self.name, "调用的是CaucasianMonther方法，正在吃{}".format(food))
class Son(AsianFather, CaucasianMonther):
def eat(self, food):
super().eat(food)
#super(Son, self).eat(food)
son = Son("Wangwu", 18)
son.eat("饺子")
Wangwu 调用的是AsianFather方法，正在吃饺子
参考资料：
什么是面向对象编程思想
如何创建和操作 Python 对象？类、实例化、对象之间的关系？
Python:类的继承，调用父类的属性和方法基础详解
Python编程：封装、继承、多态
