⼀. ⾯向对象和⾯向过程
1. ⾯向过程: ⼀切以事物的流程为核⼼. 核⼼是"过程"⼆字, 过程是指解决问题的步骤,即, 先⼲什么, 后⼲什么. 基于该思想编写程序就好比在编写⼀套流⽔线. 是⼀种机械式的编程思维
优点: 负责的问题流程化, 编写相对简单
缺点: 可扩展性差
2. ⾯向对象: ⼀切以对象为中⼼.
什么是对象? 不好解释. 先解释什么是⻋? 有轱辘, 有⽅向盘, 有发动机, 会跑的是⻋。 在看⼀个例子。什么是⼈？有名字, 年龄, 爱好, 会唱歌跳舞思考的是⼈。我们给这两个
例子下了⼀个简单的定义。总结: 具有相同属性和动作的结合体叫对象。⾯向对象思维, 要⾃⼰建立对象，⾃⼰建立场景。你就是⾯向对象世界中的上帝，你想让⻋⼲嘛就⼲嘛，你想让⼈⼲嘛⼈就能⼲嘛。
优点: 可扩展性强
缺点: 编程的复杂度⾼于⾯向过程
对比:
要把⼤象装冰箱, 总共分⼏步? 三步：第⼀步，打开冰箱⻔；第⼆步，装⼤象； 第三步关，冰箱⻔。 这是⼀个典型的⾯向过程的思维⽅式。来我们如果换成⾯向对象呢? 很简单，想办法造⼀个会钻冰箱的⼤象就可以了，然后命令⼤象，进冰箱， ⼤象就乖乖的进冰箱了， 这就是⾯向对象思维。 我们⾯向的不再是事物发展的流程, ⽽是操纵某⼀种事物的个体， 具体的某⼀个个体。
⼆. ⾯向对象如何编写
- 格式：
格式：class 类名：
pass
例子：假设，我们创建一个车类
class Car:
pass
#⻋有了，我们的⻋⾄少得有个颜⾊, ⻋牌, 排量等等信息。 不同的⻋, 有不同的颜⾊, ⻋牌, 排量等。
c = Car( )
c.color = "red"
c.pai = "京A66666"
c.pailiang = "1.6T"
print(c.color)
print(c.pai)
print(c.pailiang)
车有了，也创建了，但是如果还想再多创建几辆怎么办呢？简单，把上面代码再复制几份就是了。但是，如果这样操作了，就会产生很多冗余的代码，看着也不简洁。看下面的写法：
class Car:
def __init__(self, color, pai, pailiang): # self表示当前类的对象. 当前你创建的是谁, 谁来访问的这个⽅法.那这个self就是谁.
self.color = color
self.pai = pai
self.pailiang = pailiang
c1 = Car("red", "京A66666", "1.6T")#创建第一辆
c2 = Car("white", "京B22222", "2,0T")#创建第二辆
属性值，设置完了，一辆车有了。但是车的作用是什么？就是在路上跑啊。所以，再把跑这个功能添加进去。
class Car:
def __init__(self, color, pai, pailiang): # self表示当前类的对象. 当前你创建的是谁, 谁来访问#的这个⽅法.那这个self就是谁.
self.color = color
self.pai = pai
self.pailiang = pailiang
def run(self, speed):
print("⻋可以跑%s迈" % speed)
c = Car("red", "京A66666", "2.0T")#创建一个对象，就是新建一辆车
c.run(100) # 这时. python会⾃动把对象c传递给run⽅法的第⼀个参数位置.
总结: 类与对象的关系: 类是对事物的总结。抽象的概念，类⽤来描述对象，对象是类的实例化的结果。对象能执⾏哪些⽅法，都由类来决定，类中定义了什么，对象就拥有什么。
三. ⾯向对象的三⼤特征
⾯向对象三⼤特征: 封装, 继承, 多态。只要是⾯向对象编程语⾔，都有这三个特征。
1. 封装: 把很多数据封装到⼀个对象中，把固定功能的代码封装到⼀个代码块，函数, 对象, 打包成模块， 这都属于封装的思想。具体的情况具体分析，比如，你写了⼀个很⽜B
的函数，那这个也可以被称为封装。在⾯向对象思想中，是把⼀些看似⽆关紧要的内容组合到⼀起统⼀进⾏存储和使⽤，这就是封装。
2. 继承: ⼦类可以⾃动拥有⽗类中除了私有属性外的其他所有内容，说⽩了, ⼉⼦可以随便⽤爹的东⻄，但是朋友们, ⼀定要认清楚⼀个事情. 必须先有爹, 后有⼉⼦，顺序不能乱。在python中实现继承非常简单，在声明类的时候, 在类名后⾯添加⼀个⼩括号,就可以完成继承关系。那么什么情况可以使⽤继承呢? 单纯的从代码层⾯上来看，两个类具有相同的功能或者特征的时候，可以采⽤继承的形式，提取⼀个⽗类, 这个⽗类中编写着两个类相同的部分，然后两个类分别去继承这个类就可以了。 这样写的好处是我们可以避免写很多重复的功能和代码，如果从语义中去分析的话，会简单很多。如果语境中出现了x是⼀种y，这时, y是⼀种泛化的概念，x比y更加具体。那这时x就是y的⼦类。比如，猫是⼀种动物，猫继承动物，动物能动，猫也能动，这时猫在创建的时候就有了动物的"动"这个属性。再比如, ⽩骨精是⼀个妖怪. 妖怪天⽣就有⼀个比较不好的功能"吃⼈", ⽩骨精⼀出⽣就知道如何"吃⼈"，此时⽩骨精继承妖精。话不多说上代码：
class Yao:
def chi(self):
print("我是妖怪, 我天⽣就会吃⼈")
class BaiGuJing(Yao): # ⽩⻣精继承妖怪
pass
bgj = BaiGuJing()
bgj.chi() # 我是妖怪, 我天⽣就会吃⼈ # 虽然⽩⻣精类中没有编写chi. 但是他爹有啊. 直接拿来⽤
在python中, ⼀个类可以同时继承多个⽗类。说⽩了, 现在⼀个⼉⼦可能会有多个爹了。既然是有这么多个爹, 总得有远有近。
class Cla01:
def fun01(self):
print("Cla01.fun01")
def fun02(self):
print("Cla01.fun02")
class Cla02:
def fun03(self):
print("Cla02.fun03")
def fun02(self):
print("Cla02.fun02")
class Cla(Cla01, Cla02):
pass
obj = Cla()
obj.fun01() # 亲爹
obj.fun03() # 亲爹没有, 找⼲爹
obj.fun02() # 亲爹有了, 就不找⼲爹了
3. 多态: 同⼀个对象, 多种形态。这个在python中其实是很不容易说明⽩的， 因为我们⼀直在⽤，只是没有具体的说。比如，我们创建⼀个变量a = 10 , 我们知道此时a是整数类型， 但是我们可以通过程序让a = "alex", 这时, a⼜变成了字符串类型。这是我们都知道的，但是, 我要告诉你的是，这个就是多态性。同⼀个变量a可以是多种形态，可能这样的程序和说法你还geet不到具体什么是多态。接下来，我们来看⼀个程序，北京动物园饲养员Tom⼀天的⼯作， 从早上开始喂养猪, 中午喂哈⼠奇, 晚上还得喂阿拉斯加。来我们⽤代码实现这样的代码:
class Animal:
def chi(self):
print("动物就知道吃")
class Pig(Animal):
def chi(self):
print("猪在吃")
class Haski(Animal):
def chi(self):
print("哈⼠奇在吃")
class Alasika(Animal):
def chi(self):
print(("阿拉斯加在吃")
class SiYangYuan:
def yanng_animal(self, ani):
ani.chi()
zhu = Pig()
erha = Haski()
ala = Alasika()
Tom= SiYangYuan()
Tom.yanng_animal(zhu)
Tom.yanng_animal(erha)
Tom.yanngg_animal(ala)
多态的好处: 程序具有超⾼的可扩展性. ⾯向对象思想的核⼼与灵魂. python⾃带多态。