初识面向对象
1. 面向对象和面向过程
1. 面向过程：一切以事物的流程为核心，核心是“过程”二字，过程指的是解决问题的步骤，即，先干什么，后干什么，
基于该思想编写程序就好比在编写一套流水线，是一种机械式的编程思维。
优点：负责的问题流程化，编写相对简单
缺点：可扩展性差
2.面向对象：一切以对象为中心，具有相同属性和动作的结合体叫对象。面向对象思维，要自己建立对象，自己建立场景，自己可
以随意指挥你所建立场景中的一切对象去干你想要实现的操作。
优点：可扩展性强
缺点：编程的复杂度高于面向过程
对比：面向过程在执行一个操作的时候，只需要按照执行步骤，一步一步去直接执行；
面向对象则需要建立一个执行所需的场景，然后再建立一个对象或者多个对象，
然后再定义对象的属性以及所要实现的操作。
2. 面向对象如何编写
想象生产一辆车，首先要创建车这一类事物，然后定义这一类事物都有哪些属性
class Car： (类名首字母大写) # 创建类名
c = Car() # 创建一辆车
c.color = '红色' }
c.pai'京A12345' } # 定义车的属性
c.pailiang'1.6T' }
print(c.color)
print(c.pai)
print(pailiang)
# 使用“车”的特征可以给定义的对象设置属性
# 我们可以在创建一辆车，并设置新的相关属性
c2 = Car()
c2.color = '黑'
c2.pai = '冀GW7835'
c2.pailiang = '1.5T'
print(c)
print(c2)
# 这两辆车是完全不相同的两量车，但是它们拥有相同的属性。
# 有了属性，我们就可以进一步对对象去实行操作。在python中我们使用__init__(self)函数
给所创建的对象进行初始化操作，这个函数（方法）被称为函数构造（方法）。
class Car:
def __init__(self,name,pai,pailing): # self表示当前类你所创建的对象，谁访问这个方法，这个self就是谁。
self.color = color
self.pai = pai
self.pailiang = pailiang
c1 = Car('红','京A7896','1.6T')
c2 = Car('黑','冀GW1643','2.0T')
print(c1.color)
print(c2.color)
# 通过打印可以看出，这两个对象一样可以设置属性。
# 创建的车这一类不仅只有属性，它还可以实现一列的动作，我们要把车所实现的动作写成一个构造函数（方法）
class Car:
def __init__(self,color,pai,pailiang):
self.color = color
self.pai = pai
self.pailiang = pailiang
def run(self,speed):
print('车可以跑%s迈' % speed)
c = Car('红色','京A7896','2.0T')
c.run(120) # 这是python会自动把对象c传递给run方法的第一个参数位置。
总结: 类与对象的关系: 类是对事物的总结. 抽象的概念. 类用来描述对象. 对象是类的实例
化的结果. 对象能执行哪些方法. 都由类来决定. 类中定义了什么. 对象就拥有什么并且可以做什么。
3. 面向对象和面向过程的整体对比
根据具体案例来对比：把大象装进冰箱
1.面向过程
非函数版:
print('打开冰箱门')
print('把大象装进去')
print('关闭冰箱门')
函数版：
def open():
print('打开冰箱门')
def zhuang():
print('把大象装进去')
def colse():
print('关闭冰箱门')
open()
zhuang()
colse()
2.面向对象
class Elephant():
def open(self):
print('打开冰箱门')
def zhuang(self):
print('把大象装进冰箱')
def close(self):
print('关闭冰箱门')
dx = Elephant()
dx.open()
dx.zhuang()
dx.close()
# 面向对象相对面向过程比较麻烦
# 看下一个案例：小猪佩奇大战奥特曼. 说. 有一个小猪名叫佩奇,
今年40岁了. 会使用嘴巴嘟嘟必杀技. 他不光大战奥特曼, 还会大战蝙蝠侠, 蜘蛛侠
1.面向过程
def da_atm(name,age,jn):
print('%s,今年%s岁了，使用%s技能打奥特曼' % (name,age,jn))
def da_zzx(name,age,jn):
print('%s,今年%s岁了，使用%s技能打蜘蛛侠' % (name,age,jn))
def da_bfx(name,age,jn):
print('%s,今年%s岁了，使用%s技能打战蝙蝠侠' % (name,age,jn))
da_atm('小猪佩奇','40','嘴巴嘟嘟')
da_zzx('小猪佩奇','40','嘴巴嘟嘟')
da_bfx('小猪佩奇','40','嘴巴嘟嘟')
2.面向对象
class Pig:
def __init__(self,name,age,jn):
self.name = name
self.age = age
self.jn = jn
def da_atm(self):
print('%s,今年%s岁了，使用%s技能打奥特曼' % (self.name, self.age, self.jn))
def da_zzx(self):
print('%s,今年%s岁了，使用%s技能打奥特曼' % (self.name, self.age, self.jn))
def da_bfx(self):
print('%s,今年%s岁了，使用%s技能打奥特曼' % (self.name, self.age, self.jn))
peiqi = Pig('小猪佩奇','40','嘴巴嘟嘟')
peiqi.da_atm()
peiqi.da_zzx()
peiqi.da_bfx()
# 在这个案例中，很明显面向对象的思想、思维方式更加清新一些，代码也更容易编写。
但是具体的使用情况需要根据具体的需求来判断使用。
4.面向对象的三大特征
1.封装：
把很多数据封装到一个对象中，把固定功能的代码封装到一个代码块、函数、对象，打包成模块，
这都属于封装的思想，具体的情况具体分析使用。仔面相对象的思想中，把一些看似无关紧要的
内容组合到一起统一进行存储和使用，这就是封装。
2.继承：
子类可以自动拥有父类中除了私有属性的其他内容，⼦类可以随便父类的东西. 但是一定要认清楚个事情.
必须先有父类, 后有子类，顺序不能乱。在python中实现继承非常简单. 在声明类的时候, 在类名后面添加个小括号,
就可以完成继承关系.单纯的从代码层面上来看. 两个类具有相同的功能或者特征的时候. 可以采用继承的形式.
提取一个父类, 这个父类写着两个类相同的部分. 然后两个类分别取继承这个类就可以了. 这样写的好处
是我们可以避免写很多重复的功能和代码. 如果从语义中去分析的话. 会简单很多. 如果语境中出现了x是一种y.
这时, y是一种泛化的概念. x比y更加具体. 那这时x就是y的子类.
# 写案例：白骨精是一个妖怪. 妖怪天生就会吃人, 白骨精一出生就知道如何"吃人". 此时 白骨精继承妖精的天性。
class Yoo:
def chiren(self):
print('我是妖精，我生来就会吃人')
class Bgj(Yoo):
pass
bgj = Bgj()
bgj.chiren()
# 妖精天生就会吃人，白骨精属于妖精类，所以白骨精继承妖精吃人的技能。
在python中，一个类可以继承多个父类，父类多的时候，父类相同的属性，就要靠父类的远近来区别了。
# 写案例
class fulei1:
def chi(self):
print('告诉你 1+1=2')
def play(self):
print('带你去 天安门、故宫')
class fulei2:
def le(self):
print('给你讲笑话')
def play(self):
print('带你去 天安门')
class zilei(fulei1,fulei2):
pass
erzi = zilei()
erzi.chi() # fulei1 的功能
erzi.le() # fulei2 的功能
erzi.play() # fulei1有，就不找fulei2
3. 多态：
同一个对象, 多种形态。这个在python中其实是很不容易说明⽩的。因为我们一直在用，只是没有具体的说。
比如，我们创建一个变量a = 10 , 我们知道此时a是整数类型，但是我们可以通过程序让a = "alex", 这时,
a又变成了字符串类型。这是我们都知道的，但是这个就是多态性，同一个变量a可以是多种形态，可能这样
的程序和说法你还get不到具体什么是多态.
# 案例：
饲养员⼀天的⼯作. 喂养猪, 喂狗, 还得喂大象.
class Animal:
def chi(self):
print('动物都会吃')
class Pig:
def chi(self):
print('猪在吃')
class Dog:
def chi(self):
print('狗在吃')
class Elephant:
def chi(self):
print('大象在吃')
class Siyangyuan:
def wei_animal(self,ani):
ani.chi()
zhu = Pig()
gou = Dog()
daxiang = Elephant()
syy = Siyangyuan()
syy.wei_animal(zhu)
syy.wei_animal(gou)
syy.wei_animal(daxiang)
多态的好处： 程序具有超强的可扩展性. 面向对象思想的核心与灵魂. python自带多态
