一 面向对象的程序设计的由来
本节重点：
- 使学员了解面向对象概念、与面向过程的区别
编程范式
编程即写程序or写代码，具体是指程序员用特定的语法+数据结构+算法编写代码，目的是用来告诉计算机如何执行任务 。
如果把编程的过程比喻为练习武功，那么编程范式指的就是武林中的各种流派，而在编程的世界里最常见的两大流派便是：面向过程与面向对象。
“功夫的流派没有高低之分，只有习武的人才有高低之分“，在编程世界里更是这样，面向过程与面向对象在不同的场景下都各有优劣，谁好谁坏不能一概而论，下面就让我们来详细了解它们。
面向过程的程序设计
概念：
核心是“过程”二字，“过程”指的是解决问题的步骤，即先干什么再干什么......，基于面向过程设计程序就好比在设计一条流水线，是一种机械式的思维方式。若程序一开始是要着手解决一个大的问题，面向过程的基本设计思路就是把这个大的问题分解成很多个小问题或子过程，这些子过程在执行的过程中继续分解，直到小问题足够简单到可以在一个小步骤范围内解决。
优点是：
复杂的问题流程化，进而简单化（一个复杂的问题，分成一个个小的步骤去实现，实现小的步骤将会非常简单）
举个典型的面向过程的例子， 写一个数据远程备份程序， 分三步，本地数据打包，上传至云服务器，测试备份文件可用性。
import os def data_backup(folder): print("找到备份目录: %s" %folder) print('正在备份......') zip_file='/tmp/backup20181103.zip' print('备份成功，备份文件为: %s' %zip_file) return zip_file def cloud_upload(file): print(" connecting cloud storage center...") print("cloud storage connected.") print("upload file...%s...to cloud..." %file) link='http://www.xxx.com/bak/%s' %os.path.basename(file) print('close connection.....') return link def data_backup_test(link): print(" 下载文件: %s , 验证文件是否无损" %link) def main(): #步骤一：本地数据打包 zip_file = data_backup("c:\users\alex欧美100G高清无码") #步骤二：上传至云服务器 link=cloud_upload(zip_file) #步骤三：测试备份文件的可用性 data_backup_test(link) if __name__ == '__main__': main()
缺点是：
一套流水线或者流程就是用来解决一个问题，比如生产汽水的流水线无法生产汽车，即便是能，也得是大改，改一个组件，与其相关的组件都需要修改，牵一发而动全身，扩展性极差。
比如我们修改了步骤二的函数cloud_upload的逻辑，那么依赖于步骤二结果才能正常执行的步骤三的函数data_backup_test相关的逻辑也需要修改，这就造成了连锁反应，而这一弊端会随着程序的增大而变得越发的糟糕，我们程序的维护难度将会越来越大。
import os def data_backup(folder): print("找到备份目录: %s" %folder) print('正在备份......') zip_file='/tmp/backup20181103.zip' print('备份成功，备份文件为: %s' %zip_file) return zip_file def cloud_upload(file): #加上异常处理，在出现异常的情况下，没有link返回 try: print(" connecting cloud storage center...") print("cloud storage connected.") print("upload file...%s...to cloud..." % file) link = 'http://www.xxx.com/bak/%s' % os.path.basename(file) return link except Exception: print('upload error') finally: print('close connection.....') def data_backup_test(link): #加上对参数link的判断 if link: print(" 下载文件: %s , 验证文件是否无损" %link) else: print(' 链接不存在') def main(): #步骤一：本地数据打包 zip_file = data_backup("c:\users\alex欧美100G高清无码") #步骤二：上传至云服务器 link=cloud_upload(zip_file) #步骤三：测试备份文件的可用性 data_backup_test(link) if __name__ == '__main__': main()
应用场景：
面向过程的程序设计思想一般用于那些功能一旦实现之后就很少需要改变的场景， 如果你只是写一些简单的脚本，去做一些一次性任务，用面向过程的方式是极好的，著名的例子有Linux內核，git，以及Apache HTTP Server等。但如果你要处理的任务是复杂的，且需要不断迭代和维护 的， 那还是用面向对象最方便了。
面向对象的程序设计
概念：
核心是“对象”二字，要理解对象为何物，必须把自己当成上帝，在上帝眼里，世间存在的万物皆为对象，不存在的也可以创造出来。程序员基于面向对象设计程序就好比如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来并没有考虑问题的解决流程，而是设计出了负责取经的师傅四人：唐僧，沙和尚，猪八戒，孙悟空，负责骚扰的一群妖魔鬼怪，以及负责保驾护航的一众神仙，这些全都是对象，然后取经开始，就是师徒四人与妖魔鬼怪神仙交互着直到完成取经任务。所以说基于面向对象设计程序就好比在创造一个世界，世界是由一个个对象组成，而你就是这个世界的上帝。
我们从西游记中的任何一个人物对象都不难总结出：对象是特征与技能的结合体。比如孙悟空的特征是：毛脸雷公嘴，技能是：七十二变、火眼金睛等。
与面向过程机械式的思维方式形成鲜明对比，面向对象更加注重对现实世界而非流程的模拟，是一种“上帝式”的思维方式。
优点是：
解决了面向过程可扩展性低的问题，这一点我们将在5.2小节中为大家验证，需要强调的是，对于一个软件质量来说，面向对象的程序设计并不代表全部，面向对象的程序设计只是用来解决扩展性问题。
缺点是：
编程的复杂度远高于面向过程，不了解面向对象而立即上手并基于它设计程序，极容易出现过度设计的问题，而且在一些扩展性要求低的场景使用面向对象会徒增编程难度，比如管理linux系统的shell脚本程序就不适合用面向对象去设计，面向过程反而更加适合。
应用场景：
当然是应用于需求经常变化的软件中，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方。
二 什么是面向对象的程序设计 及 为什么要有它
面向过程的程序设计：核心是过程二字，过程指的是解决问题的步骤，即先干什么再干什么......面向过程的设计就好比精心设计好一条流水线，是一种机械式的思维方式。
优点是：复杂度的问题流程化，进而简单化（一个复杂的问题，分成一个个小的步骤去实现，实现小的步骤将会非常简单）
缺点是：一套流水线或者流程就是用来解决一个问题，生产汽水的流水线无法生产汽车，即便是能，也得是大改，改一个组件，牵一发而动全身。
应用场景：一旦完成基本很少改变的场景，著名的例子有Linux內核，git，以及Apache HTTP Server等。
面向对象的程序设计：核心是对象二字，（要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。面向对象的程序设计好比如来设计西游记，如来要解决的问题是把经书传给东土大唐，如来想了想解决这个问题需要四个人：唐僧，沙和尚，猪八戒，孙悟空，每个人都有各自的特征和技能（这就是对象的概念，特征和技能分别对应对象的数据属性和方法属性），然而这并不好玩，于是如来又安排了一群妖魔鬼怪，为了防止师徒四人在取经路上被搞死，又安排了一群神仙保驾护航，这些都是对象。然后取经开始，师徒四人与妖魔鬼怪神仙交互着直到最后取得真经。如来根本不会管师徒四人按照什么流程去取),对象是特征与技能的结合体，基于面向对象设计程序就好比在创造一个世界，你就是这个世界的上帝，存在的皆为对象，不存在的也可以创造出来，与面向过程机械式的思维方式形成鲜明对比，面向对象更加注重对现实世界的模拟，是一种“上帝式”的思维方式。
优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。
缺点：
1. 编程的复杂度远高于面向过程，不了解面向对象而立即上手基于它设计程序，极容易出现过度设计的问题。一些扩展性要求低的场景使用面向对象会徒增编程难度，比如管理linux系统的shell脚本就不适合用面向对象去设计，面向过程反而更加适合。
2. 无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法准确地预测最终结果。于是我们经常看到对战类游戏，新增一个游戏人物，在对战的过程中极容易出现阴霸的技能，一刀砍死3个人，这种情况是无法准确预知的，只有对象之间交互才能准确地知道最终的结果。
应用场景：需求经常变化的软件，一般需求的变化都集中在用户层，互联网应用，企业内部软件，游戏等都是面向对象的程序设计大显身手的好地方
面向对象的程序设计并不是全部。对于一个软件质量来说，面向对象的程序设计只是用来解决扩展性。
三 类与对象
类即类别、种类，是面向对象设计最重要的概念，对象是特征与技能的结合体，而类则是一系列对象相似的特征与技能的结合体
那么问题来了，先有的一个个具体存在的对象（比如一个具体存在的人），还是先有的人类这个概念，这个问题需要分两种情况去看
在现实世界中：先有对象，再有类
世界上肯定是先出现各种各样的实际存在的物体，然后随着人类文明的发展，人类站在不同的角度总结出了不同的种类，如人类、动物类、植物类等概念
也就说，对象是具体的存在，而类仅仅只是一个概念，并不真实存在
在程序中：务必保证先定义类，后产生对象
这与函数的使用是类似的，先定义函数，后调用函数，类也是一样的，在程序中需要先定义类，后调用类
不一样的是，调用函数会执行函数体代码返回的是函数体执行的结果，而调用类会产生对象，返回的是对象
按照上述步骤，我们来定义一个类（我们站在老男孩学校的角度去看，在座的各位都是学生）
在现实世界中：先有对象，再有类
#在现实世界中，站在老男孩学校的角度：先有对象，再有类 对象1：李坦克 特征: 学校=oldboy 姓名=李坦克 性别=男 年龄=18 技能： 学习 吃饭 睡觉 对象2：王大炮 特征: 学校=oldboy 姓名=王大炮 性别=女 年龄=38 技能： 学习 吃饭 睡觉 对象3：牛榴弹 特征: 学校=oldboy 姓名=牛榴弹 性别=男 年龄=78 技能： 学习 吃饭 睡觉 现实中的老男孩学生类 相似的特征: 学校=oldboy 相似的技能： 学习 吃饭 睡觉 在现实世界中：先有对象，再有类
在程序中：先定义类，后产生对象
#在程序中，务必保证：先定义（类），后使用（产生对象） PS: 1. 在程序中特征用变量标识，技能用函数标识 2. 因而类中最常见的无非是：变量和函数的定义 #程序中的类 class OldboyStudent: school='oldboy' def learn(self): print('is learning') def eat(self): print('is eating') def sleep(self): print('is sleeping') #注意： 1.类中可以有任意python代码，这些代码在类定义阶段便会执行 2.因而会产生新的名称空间，用来存放类的变量名与函数名，可以通过OldboyStudent.__dict__查看 3.对于经典类来说我们可以通过该字典操作类名称空间的名字（新式类有限制），但python为我们提供专门的.语法 4.点是访问属性的语法，类中定义的名字，都是类的属性 #程序中类的用法 .:专门用来访问属性，本质操作的就是__dict__ OldboyStudent.school #等于经典类的操作OldboyStudent.__dict__['school'] OldboyStudent.school='Oldboy' #等于经典类的操作OldboyStudent.__dict__['school']='Oldboy' OldboyStudent.x=1 #等于经典类的操作OldboyStudent.__dict__['x']=1 del OldboyStudent.x #等于经典类的操作OldboyStudent.__dict__.pop('x') #程序中的对象 #调用类，或称为实例化，得到对象 s1=OldboyStudent() s2=OldboyStudent() s3=OldboyStudent() #如此，s1、s2、s3都一样了，而这三者除了相似的属性之外还各种不同的属性，这就用到了__init__ #注意：该方法是在对象产生之后才会执行，只用来为对象进行初始化操作，可以有任意代码，但一定不能有返回值 class OldboyStudent: ...... def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex ...... s1=OldboyStudent('李坦克','男',18) #先调用类产生空对象s1，然后调用OldboyStudent.__init__(s1,'李坦克','男',18) s2=OldboyStudent('王大炮','女',38) s3=OldboyStudent('牛榴弹','男',78) #程序中对象的用法 #执行__init__,s1.name='牛榴弹'，很明显也会产生对象的名称空间 s2.__dict__ {'name': '王大炮', 'age': '女', 'sex': 38} s2.name #s2.__dict__['name'] s2.name='王三炮' #s2.__dict__['name']='王三炮' s2.course='python' #s2.__dict__['course']='python' del s2.course #s2.__dict__.pop('course') 在程序中：先定义类，后产生对象
PS：
1. 站的角度不同，定义出的类是截然不同的，详见面向对象实战之需求分析
2. 现实中的类并不完全等于程序中的类，比如现实中的公司类，在程序中有时需要拆分成部门类，业务类......
3. 有时为了编程需求，程序中也可能会定义现实中不存在的类，比如策略类，现实中并不存在，但是在程序中却是一个很常见的类
#python为类内置的特殊属性 类名.__name__# 类的名字(字符串) 类名.__doc__# 类的文档字符串 类名.__base__# 类的第一个父类(在讲继承时会讲) 类名.__bases__# 类所有父类构成的元组(在讲继承时会讲) 类名.__dict__# 类的字典属性 类名.__module__# 类定义所在的模块 类名.__class__# 实例对应的类(仅新式类中) 类的特殊属性(了解即可)
！！！补充说明：从代码级别看面向对象 ！！！
#1、在没有学习类这个概念时，数据与功能是分离的 def exc1(host,port,db,charset): conn=connect(host,port,db,charset) conn.execute(sql) return xxx def exc2(host,port,db,charset,proc_name) conn=connect(host,port,db,charset) conn.call_proc(sql) return xxx #每次调用都需要重复传入一堆参数 exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;') exc2('127.0.0.1',3306,'db1','utf8','存储过程的名字') #2、我们能想到的解决方法是，把这些变量都定义成全局变量 HOST=‘127.0.0.1’ PORT=3306 DB=‘db1’ CHARSET=‘utf8’ def exc1(host,port,db,charset): conn=connect(host,port,db,charset) conn.execute(sql) return xxx def exc2(host,port,db,charset,proc_name) conn=connect(host,port,db,charset) conn.call_proc(sql) return xxx exc1(HOST,PORT,DB,CHARSET,'select * from tb1;') exc2(HOST,PORT,DB,CHARSET,'存储过程的名字') #3、但是2的解决方法也是有问题的，按照2的思路，我们将会定义一大堆全局变量，这些全局变量并没有做任何区分，即能够被所有功能使用，然而事实上只有HOST，PORT，DB，CHARSET是给exc1和exc2这两个功能用的。言外之意：我们必须找出一种能够将数据与操作数据的方法组合到一起的解决方法，这就是我们说的类了 class MySQLHandler: def __init__(self,host,port,db,charset='utf8'): self.host=host self.port=port self.db=db self.charset=charset def exc1(self,sql): conn=connect(self.host,self.port,self.db,self.charset) res=conn.execute(sql) return res def exc2(self,sql): conn=connect(self.host,self.port,self.db,self.charset) res=conn.call_proc(sql) return res obj=MySQLHandler('127.0.0.1',3306,'db1') obj.exc1('select * from tb1;') obj.exc2('存储过程的名字') #改进 class MySQLHandler: def __init__(self,host,port,db,charset='utf8'): self.host=host self.port=port self.db=db self.charset=charset self.conn=connect(self.host,self.port,self.db,self.charset) def exc1(self,sql): return self.conn.execute(sql) def exc2(self,sql): return self.conn.call_proc(sql) obj=MySQLHandler('127.0.0.1',3306,'db1') obj.exc1('select * from tb1;') obj.exc2('存储过程的名字') 数据与专门操作该数据的功能组合到一起
四 属性查找
类有两种属性：数据属性和函数属性
1. 类的数据属性是所有对象共享的
2. 类的函数属性是绑定给对象用的
#类的数据属性是所有对象共享的,id都一样 print(id(OldboyStudent.school)) print(id(s1.school)) print(id(s2.school)) print(id(s3.school)) ''' 4377347328 4377347328 ''' #类的函数属性是绑定给对象使用的,obj.method称为绑定方法,内存地址都不一样 #ps:id是python的实现机制,并不能真实反映内存地址,如果有内存地址,还是以内存地址为准 print(OldboyStudent.learn) print(s1.learn) print(s2.learn) print(s3.learn) ''' <function OldboyStudent.learn at 0x1021329d8> <bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x1021466d8>> <bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x102146710>> <bound method OldboyStudent.learn of <__main__.OldboyStudent object at 0x102146748>> '''
在obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类...最后都找不到就抛出异常
练习：编写一个学生类，产生一堆学生对象，要求有一个计数器（属性），统计总共实例了多少个对象
五 绑定到对象的方法的特殊之处
#改写 class OldboyStudent: school='oldboy' def __init__(self,name,age,sex): self.name=name self.age=age self.sex=sex def learn(self): print('%s is learning' %self.name) #新增self.name def eat(self): print('%s is eating' %self.name) def sleep(self): print('%s is sleeping' %self.name) s1=OldboyStudent('李坦克','男',18) s2=OldboyStudent('王大炮','女',38) s3=OldboyStudent('牛榴弹','男',78)
类中定义的函数（没有被任何装饰器装饰的）是类的函数属性，类可以使用，但必须遵循函数的参数规则，有几个参数需要传几个参数
OldboyStudent.learn(s1) #李坦克 is learning OldboyStudent.learn(s2) #王大炮 is learning OldboyStudent.learn(s3) #牛榴弹 is learning
类中定义的函数（没有被任何装饰器装饰的）,其实主要是给对象使用的，而且是绑定到对象的，虽然所有对象指向的都是相同的功能，但是绑定到不同的对象就是不同的绑定方法
强调：绑定到对象的方法的特殊之处在于，绑定给谁就由谁来调用，谁来调用，就会将‘谁’本身当做第一个参数传给方法，即自动传值（方法__init__也是一样的道理）
s1.learn() #等同于OldboyStudent.learn(s1) s2.learn() #等同于OldboyStudent.learn(s2) s3.learn() #等同于OldboyStudent.learn(s3)
注意：绑定到对象的方法的这种自动传值的特征，决定了在类中定义的函数都要默认写一个参数self，self可以是任意名字，但是约定俗成地写出self。
类即类型
提示：python的class术语与c++有一定区别，与 Modula-3更像。
python中一切皆为对象，且python3中类与类型是一个概念，类型就是类
#类型dict就是类dict >>> list <class 'list'> #实例化的到3个对象l1,l2,l3 >>> l1=list() >>> l2=list() >>> l3=list() #三个对象都有绑定方法append,是相同的功能,但内存地址不同 >>> l1.append <built-in method append of list object at 0x10b482b48> >>> l2.append <built-in method append of list object at 0x10b482b88> >>> l3.append <built-in method append of list object at 0x10b482bc8> #操作绑定方法l1.append(3),就是在往l1添加3,绝对不会将3添加到l2或l3 >>> l1.append(3) >>> l1 [3] >>> l2 [] >>> l3 [] #调用类list.append(l3,111)等同于l3.append(111) >>> list.append(l3,111) #l3.append(111) >>> l3 [111]
六 对象之间的交互
class Garen: #定义英雄盖伦的类，不同的玩家可以用它实例出自己英雄; camp='Demacia' #所有玩家的英雄(盖伦)的阵营都是Demacia; def __init__(self,nickname,aggressivity=58,life_value=455): #英雄的初始攻击力58...; self.nickname=nickname #为自己的盖伦起个别名; self.aggressivity=aggressivity #英雄都有自己的攻击力; self.life_value=life_value #英雄都有自己的生命值; def attack(self,enemy): #普通攻击技能，enemy是敌人; enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。
我们可以仿照garen类再创建一个Riven类
class Riven: camp='Noxus' #所有玩家的英雄(锐雯)的阵营都是Noxus; def __init__(self,nickname,aggressivity=54,life_value=414): #英雄的初始攻击力54; self.nickname=nickname #为自己的锐雯起个别名; self.aggressivity=aggressivity #英雄都有自己的攻击力; self.life_value=life_value #英雄都有自己的生命值; def attack(self,enemy): #普通攻击技能，enemy是敌人; enemy.life_value-=self.aggressivity #根据自己的攻击力，攻击敌人就减掉敌人的生命值。
实例出俩英雄
>>> g1=Garen('草丛伦')
>>> r1=Riven('锐雯雯')
交互：锐雯雯攻击草丛伦，反之一样
>>> g1.life_value 455 >>> r1.attack(g1) >>> g1.life_value 401
补充：
garen_hero.Q()称为向garen_hero这个对象发送了一条消息，让他去执行Q这个功能，类似的有：
garen_hero.W()
garen_hero.E()
garen_hero.R()