Python之路（十四）：面向对象（初级篇）
概述
- 面向过程：根据业务逻辑从上到下写垒代码
- 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
- 面向对象：对函数进行分类和封装，让开发“更快更好更强...”
面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。
while True： if cpu利用率 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 硬盘使用空间 > 90%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 if 内存占用 > 80%: #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接
随着时间的推移，开始使用了函数式编程，增强代码的重用性和可读性，就变成了这样：
def 发送邮件(内容) #发送邮件提醒 连接邮箱服务器 发送邮件 关闭连接 while True： if cpu利用率 > 90%: 发送邮件('CPU报警') if 硬盘使用空间 > 90%: 发送邮件('硬盘报警') if 内存占用 > 80%: 发送邮件('内存报警')
今天我们来学习一种新的编程方式：面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）
注：Java和C#来说只支持面向对象编程，而python比较灵活即支持面向对象编程也支持函数式编程
创建类和对象
面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。
1、类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
2、对象则是根据模板创建的实例，通过实例对象可以执行类中的函数
- class是关键字，表示类
- 创建对象，类名称后加括号即可
ps：类中的函数第一个参数必须是self（详细见：类的三大特性之封装）
类中定义的函数叫做 “方法”
# 创建类 class Foo: def Bar(self): print 'Bar' def Hello(self, name): print 'i am %s' %name # 根据类Foo创建对象obj obj = Foo() obj.Bar() #执行Bar方法 obj.Hello('wupeiqi') #执行Hello方法
诶，你在这里是不是有疑问了？使用函数式编程和面向对象编程方式来执行一个“方法”时函数要比面向对象简便。
执行方式：
- 面向对象：【创建对象】【通过对象执行方法】
- 函数编程：【执行函数】
观察上述对比答案则是肯定的，然后并非绝对，场景的不同适合其的编程方式也不同。
总结：函数式的应用场景 --> 各个函数之间是独立且无共用的数据
#在面向对象编程中，根据类创建对象（也叫创建一个类的实例）
#####################################################
self:形式参数。Python内部传递 。self就是执行该方法的对象
class Foo: def func1(self,backend): print(backend,self) obj1 = Foo() print(obj1) obj1.func1("aaaa") # <__main__.Foo object at 0x0000000002248BE0> # aaaa <__main__.Foo object at 0x0000000002248BE0> #执行方法时，先去类中找到方法，self 就是将执行该方法的对象obj1，其他就是正常参数
面向对象三大特性
面向对象的三大特性是指：封装、继承和多态。
一、封装
class Foo: def func1(self): print(self.backend) obj1 = Foo() obj1.backend = "hahhhahahah" obj1.func1() #输出：hahhhahahah obj2 = Foo() obj2.backend = "llallalala" obj2.func1() #输出：llallalala
#数据库操作 class sql_play: def link(self): port = self.port user = self.user pwd = self.pwd ip = self.ip def add_sql(self): print(self.user,self.pwd) def del_sql(self): print(self.pwd,self.user) obj1 = sql_play() obj1.port = "3306" obj1.user = "zxg" obj1.pwd = "123456" obj1.ip = "481535" obj1.link() obj1.add_sql() obj1.del_sql() #这样就可以将参数封装起来，然后调用，就不需要想函数式编程那样一遍一遍的传参数 #多用于多个函数方法使用中有多个参数需要传递的时候
#但是上面的封装方式不常用
封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
所以，在使用面向对象的封装特性时，需要：
- 将内容封装到某处
- 从某处调用被封装的内容
第一步：将内容封装到某处
注：1、如果想要每个对象都有公共封装的东西，就写 self.xxx = "xxxx" ,如果不同，就在创建对象时，传参数
2、 类+括号 -> 自动执行类中__init__方法：创建了一个对象
在__init__方法中执行具体封装操作
__init__有一个特殊名字：构造方法。
这个过程也叫作：初始化
3、在Python解释器销毁对象时，自动调用__del__方法：析构方法
4、使用场景：当同一类型的方法具有相同参数时，直接封装到对象即可
self 是一个形式参数，当执行 obj1 = Foo('wupeiqi', 18 ) 时，self 等于 obj1
当执行 obj2 = Foo('alex', 78 ) 时，self 等于 obj2
所以，内容其实被封装到了对象 obj1 和 obj2 中，每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。
第二步：从某处调用被封装的内容
调用被封装的内容时，有两种情况：
- 通过对象直接调用
- 通过self间接调用
1、通过对象直接调用被封装的内容
上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名
class Foo: def __init__(self, name, age): #构造方法 self.name = name self.age = age obj1 = Foo('wupeiqi', 18) print(obj1.name) # 直接调用obj1对象的name属性 #输出：wupeiqi print(obj1.age) # 直接调用obj1对象的age属性 #输出：18 obj2 = Foo('alex', 73) print(obj2.name) # 直接调用obj2对象的name属性 #输出：alex print(obj2.age) # 直接调用obj2对象的age属性 #输出：73
2、通过self间接调用被封装的内容
执行类中的方法时，需要通过self间接调用被封装的内容
class Foo: def __init__(self, name, age): self.name = name self.age = age def detail(self): print("%s 吃完饭了"%self.name) print(self.age) obj1 = Foo('wupeiqi', 18) obj1.detail() # Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18 ''' 输出： wupeiqi 吃完饭了 18 ''' obj2 = Foo('alex', 73) obj2.detail() # Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78 ''' 输出： alex 吃完饭了 18 '''
#吃饭健身体重游戏 #吃一次长两斤，减肥一次瘦一斤 class Person: def __init__(self,name,age,weight): self.Name = name self.Age = age self.Weight = weight def chi(self): self.Weight += 2 def jianshen(self): self.Weight -= 1 person1 = Person("小明",18,200) person2 = Person("韩梅梅",23,101) person3 = Person("李磊",30,80) print(person1.Weight) #输出：200 原始体重200 person1.jianshen() print(person1.Weight) #输出：199 健身一次，减一斤：199 person1.chi() print(person1.Weight) #输出：201 吃一次长两斤：201 ''' 游戏中，被打一下掉血，打一下，掉一点血---->就可以通过上面这种面向对象实现 '''
#游戏存档：pickle import pickle class Person: def __init__(self,name,age,weight): self.Name = name self.Age = age self.Weight = weight def chi(self): self.Weight += 2 def jianshen(self): self.Weight -= 1 #玩过一次游戏，记录存档 person1 = Person("小明", 18, 200) person1.jianshen() person1.chi() person1.chi() person1.chi() pickle.dump(person1,open('cundang.log','wb')) ret = pickle.load(open('cundang.log','rb')) #加载游戏记录文件 print(ret) #输出：<__main__.Person object at 0x0000000002890470> Person对象类型 print(ret.Weight) #输出：205 记录的体重 if ret: #有存档 print(ret.Weight) else: #无存档 person1.jianshen() person1.chi() person1.chi() person1.chi() print(person1.Weight) #输出：210 pickle.dump(person1,open('cundang.log','wb'))
综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到 对象 中，然后通过对象直接或者self间接获取被封装的内容。
练习一：在终端输出如下信息
小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健
老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健
老张...
def kanchai(name, age, gender): print "%s,%s岁,%s,上山去砍柴" %(name, age, gender) def qudongbei(name, age, gender): print "%s,%s岁,%s,开车去东北" %(name, age, gender) def dabaojian(name, age, gender): print "%s,%s岁,%s,最爱大保健" %(name, age, gender) kanchai('小明', 10, '男') qudongbei('小明', 10, '男') dabaojian('小明', 10, '男') kanchai('老李', 90, '男') qudongbei('老李', 90, '男') dabaojian('老李', 90, '男')
class Foo: def __init__(self, name, age ,gender): self.name = name self.age = age self.gender = gender def kanchai(self): print "%s,%s岁,%s,上山去砍柴" %(self.name, self.age, self.gender) def qudongbei(self): print "%s,%s岁,%s,开车去东北" %(self.name, self.age, self.gender) def dabaojian(self): print "%s,%s岁,%s,最爱大保健" %(self.name, self.age, self.gender) xiaoming = Foo('小明', 10, '男') xiaoming.kanchai() xiaoming.qudongbei() xiaoming.dabaojian() laoli = Foo('老李', 90, '男') laoli.kanchai() laoli.qudongbei() laoli.dabaojian()
上述对比可以看出，如果使用函数式编程，需要在每次执行函数时传入相同的参数，如果参数多的话，又需要粘贴复制了... ；而对于面向对象只需要在创建对象时，将所有需要的参数封装到当前对象中，之后再次使用时，通过self间接去当前对象中取值即可。
练习二：游戏人生程序 1、创建三个游戏人物，分别是： 苍井井，女，18，初始战斗力1000 东尼木木，男，20，初始战斗力1800 波多多，女，19，初始战斗力2500 2、游戏场景，分别： 草丛战斗，消耗200战斗力 自我修炼，增长100战斗力 多人游戏，消耗500战斗力
# -*- coding:utf-8 -*- # ##################### 定义实现功能的类 ##################### class Person: def __init__(self, na, gen, age, fig): self.name = na self.gender = gen self.age = age self.fight =fig def grassland(self): """注释：草丛战斗，消耗200战斗力""" self.fight = self.fight - 200 def practice(self): """注释：自我修炼，增长100战斗力""" self.fight = self.fight + 200 def incest(self): """注释：多人游戏，消耗500战斗力""" self.fight = self.fight - 500 def detail(self): """注释：当前对象的详细情况""" temp = "姓名:%s ; 性别:%s ; 年龄:%s ; 战斗力:%s" % (self.name, self.gender, self.age, self.fight) print temp # ##################### 开始游戏 ##################### cang = Person('苍井井', '女', 18, 1000) # 创建苍井井角色 dong = Person('东尼木木', '男', 20, 1800) # 创建东尼木木角色 bo = Person('波多多', '女', 19, 2500) # 创建波多多角色 cang.incest() #苍井空参加一次多人游戏 dong.practice()#东尼木木自我修炼了一次 bo.grassland() #波多多参加一次草丛战斗 #输出当前所有人的详细情况 cang.detail() dong.detail() bo.detail() cang.incest() #苍井空又参加一次多人游戏 dong.incest() #东尼木木也参加了一个多人游戏 bo.practice() #波多多自我修炼了一次 #输出当前所有人的详细情况 cang.detail() dong.detail() bo.detail()
总结：封装：
使用场景：当同一类型的方法具有相同参数时，直接封装到对象即可
使用场景：把类当做模板，创建多个对象（对象内封装的数据可以不一样）
二、继承
继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。
例如：
猫可以：喵喵叫、吃、喝、拉、撒
狗可以：汪汪叫、吃、喝、拉、撒
如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，如下所示：
class 猫： def 喵喵叫(self): print '喵喵叫' def 吃(self): # do something def 喝(self): # do something def 拉(self): # do something def 撒(self): # do something class 狗： def 汪汪叫(self): print '喵喵叫' def 吃(self): # do something def 喝(self): # do something def 拉(self): # do something def 撒(self): # do something
上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：
动物：吃、喝、拉、撒
猫：喵喵叫（猫继承动物的功能）
狗：汪汪叫（狗继承动物的功能）
class 动物: def 吃(self): # do something def 喝(self): # do something def 拉(self): # do something def 撒(self): # do something # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类 class 猫(动物)： def 喵喵叫(self): print '喵喵叫' # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类 class 狗(动物)： def 汪汪叫(self): print '喵喵叫'
class Animal: def eat(self): print("%s 吃 " % self.name) def drink(self): print("%s 喝 " % self.name) def shit(self): print("%s 拉 " % self.name) def pee(self): print("%s 撒 " % self.name) class Cat(Animal): def __init__(self, name): self.name = name self.breed = '猫' def cry(self): print('喵喵叫') class Dog(Animal): def __init__(self, name): self.name = name self.breed = '狗' def cry(self): print('汪汪叫') # ######### 执行 ######### c1 = Cat('小白家的小黑猫') c1.eat() #输出：小白家的小黑猫 吃 c2 = Cat('小黑的小白猫') c2.drink() #输出：小黑的小白猫 喝 d1 = Dog('胖子家的小瘦狗') d1.eat() #输出：胖子家的小瘦狗 吃
所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。
注：除了子类和父类的称谓，你可能看到过 派生类 和 基类 ，他们与子类和父类只是叫法不同而已。
注：派生类（子类）可以继承基类（父类）中的所有功能
派生类和基类同时存在，优先找派生类（即：子类有xxx方法，父类也有xxx方法，子类继承了父类创建对象abc，abc.xxxx()优先找子类中的xxx方法）
以上只继承一个父类的属于单继承，那么问题又来了，多继承呢？
- 是否可以继承多个类
- 如果继承的多个类每个类中都定了相同的函数，那么那一个会被使用呢？
1、Python的类可以继承多个类，Java和C#中则只能继承一个类
2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先
深度优先：class D, class B(D), class C, class A(B,C), obj=A() obj.xx() 顺序：A---B---D----C
广度优先：class A(object), class B(A), class C(A), class D(B,C), obj=D() onj.xx() 顺序：D----B----C-----A
- 当类是经典类时，多继承情况下，会按照深度优先方式查找
- 当类是新式类时，多继承情况下，会按照广度优先方式查找
经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。
class D: 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() # 执行bar方法时 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错 # 所以，查找顺序：A --> B --> D --> C # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了 a.bar()
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() # 执行bar方法时 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错 # 所以，查找顺序：A --> B --> C --> D # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了 a.bar()
经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
新式类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
注意：在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
三、多态
Pyhon不支持Java和C#这一类强类型语言中多态的写法，但是原生多态，其Python崇尚“鸭子类型”。
class F1: pass class S1(F1): def show(self): print 'S1.show' class S2(F1): def show(self): print 'S2.show' # 由于在Java或C#中定义函数参数时，必须指定参数的类型 # 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类 # 而实际传入的参数是：S1对象和S2对象 def Func(F1 obj): """Func函数需要接收一个F1类型或者F1子类的类型""" print obj.show() s1_obj = S1() Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show s2_obj = S2() Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show
class F1: pass class S1(F1): def show(self): print 'S1.show' class S2(F1): def show(self): print 'S2.show' def Func(obj): print obj.show() s1_obj = S1() Func(s1_obj) #输出：S1.show s2_obj = S2() Func(s2_obj #输出：S2.show
"鸭子类型"就是Python中的多态
总结
以上就是本节对于面向对象初级知识的介绍，总结如下：
- 面向对象是一种编程方式，此编程方式的实现是基于对 类 和 对象 的使用
- 类 是一个模板，模板中包装了多个“函数”供使用
- 对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
- 面向对象三大特性：封装、继承和多态
- Python中无接口（接口是用来约束的）
问答专区
问题一：什么样的代码才是面向对象？
答：从简单来说，如果程序中的所有功能都是用 类 和 对象 来实现，那么就是面向对象编程了。
问题二：函数式编程 和 面向对象 如何选择？分别在什么情况下使用？
答：须知：对于 C# 和 Java 程序员来说不存在这个问题，因为该两门语言只支持面向对象编程（不支持函数式编程）。而对于 Python 和 PHP 等语言却同时支持两种编程方式，且函数式编程能完成的操作，面向对象都可以实现；而面向对象的能完成的操作，函数式编程不行（函数式编程无法实现面向对象的封装功能）。
所以，一般在Python开发中，全部使用面向对象 或 面向对象和函数式混合使用
面向对象的应用场景:
- 多函数需使用共同的值，如：数据库的增、删、改、查操作都需要连接数据库字符串、主机名、用户名和密码
Demo
class SqlHelper: def __init__(self, host, user, pwd): self.host = host self.user = user self.pwd = pwd def 增(self): # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接 # do something # 关闭数据库连接 def 删(self): # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接 # do something # 关闭数据库连接 def 改(self): # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接 # do something # 关闭数据库连接 def 查(self): # 使用主机名、用户名、密码（self.host 、self.user 、self.pwd）打开数据库连接 # do something # 关闭数据库连接# do something
- 需要创建多个事物，每个事物属性个数相同，但是值的需求
如：张三、李四、杨五，他们都有姓名、年龄、血型，但其都是不相同。即：属性个数相同，但值不相同
Democlass Person: def __init__(self, name ,age ,blood_type): self.name = name self.age = age self.blood_type = blood_type def detail(self): temp = "i am %s, age %s , blood type %s " % (self.name, self.age, self.blood_type) print temp zhangsan = Person('张三', 18, 'A') lisi = Person('李四', 73, 'AB') yangwu = Person('杨五', 84, 'A')
问题三：类和对象在内存中是如何保存？
答：类以及类中的方法在内存中只有一份，而根据类创建的每一个对象都在内存中需要存一份，大致如下图：
如上图所示，根据类创建对象时，对象中除了封装 name 和 age 的值之外，还会保存一个类对象指针，该值指向当前对象的类。
当通过 obj1 执行 【方法一】 时，过程如下：
- 根据当前对象中的 类对象指针 找到类中的方法
- 将对象 obj1 当作参数传给 方法的第一个参数 self
####################################补充######################################
1、多继承易错点
class A: def xxx(self): print("A") class B: def xxx(self): print("B") class C: def xxx(self): print("C") class D(C,B): pass obj = D() obj.xxx() #输出：C
class A: def bar(self): print("bar") self.xxx() class B(A): def xxx(self): print("B") class C: def xxx(self): print("C") class D(C,B): pass obj1 = D() obj1.bar() ''' 输出：bar C ''' #先去找bar()方法：C---B----A #在A中找到bar方法，执行，输出：bar，然后执行self.xxx()方法，因为这里的D类创建的self就是obj对象，所以找xxx()方法顺序还是：C---B----A #在C中找到xxx()方法执行，输出：C obj2 = B() obj2.bar() ''' 输出：bar B 顺序：B----A 找方法要从创建对象的类开始找 ''' obj3 = A() obj3.bar() ''' 输出：bar 然后报错 从A类开始找，但是找不到xxx方法所以报错 '''
2、执行基类的构造方法
之前的继承中都没有写构造方法，下面开始写构造方法的继承
class A: def __init__(self): print("A的构造方法") self.ty = "动物" class B(A): def __init__(self): print("B的构造方法") self.n = "猫" #执行父类的构造方法 super(B,self).__init__() #类的后面加上括号自动执行构造方法. 一种是：A() 此时就直接执行A的构造方法。 另一种是：obj = A() 创建对象时自动执行构造方法 #构造方法：数据初始化 ''' A() #输出：A的构造方法 B() #输出：B的构造方法 ''' lala = B() print(lala.__dict__) #没有super时 #只执行B的构造方法 #输出：B的构造方法 # {'n': '猫'} #有super时 #既执行B的构造方法，也执行A的构造方法 #输出：B的构造方法 # A的构造方法 # {'n': '猫', 'ty': '动物'} #super也可以换一种：A.__init__(self) 去执行A父类的构造方法
class A: class B(): obj = B()
此时子类B创建对象obj，并且自动执行构造方法，先去执行子类的构造方法，父类的构造方法不会去执行
但是若想要执行父类的构造方法，两种方式：
- 在子类中：super(B,self).__init__() #self：obj
- A.__init__(self)
注意：1、查看源码的过程（self.xxxx(),从底层（创建的类）开始找）
2、执行父类的构造方式：
a、super(当前类，self).__init__()
b、父类.__init__(self,xxxx)
浙公网安备 33010602011771号