1、面向对象和函数的区别面向过程：根据业务逻辑从上到下写垒代码函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可面向对象：对函数进行分类和封
1、面向对象和函数的区别
面向过程：根据业务逻辑从上到下写垒代码
函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可
面向对象：对函数进行分类和封装，让开发“更快更好更强
2、面向对象是一种编程方式，此编程方式一般使用“类”和“对象”来实现，所以面向对象编程就是对类和对象的使用。
类就是一个模板，模板里面包含很多函数，在函数中实现一些功能。
对象就是根据模板创建的实例，通过实例对象可以执行类中的函数。
1 class foo(object): #class是关键字，表示要创建类，foo是类的名称。 2 def bar(self): #创建类中的函数 3 print("he is jason") # 4 5 obj = foo() #根据类foo创建对象 6 obj.bar() #传参数
备注：类中函数的第一个参数必须是self，表示类中的对象。类中定义的函数叫做方法。
简单类的创建及其方法的调用等
1 class foo: #创建类 2 def bar(self): 3 print("i am bar") 4 5 def hello(self,name): 6 print("i am %s" %name) 7 8 obj = foo() #根据类foo创建对象obj 9 obj.bar() #执行bar方法 10 obj.hello("wupeiqi") #执行hello方法
3、面向对象的三大特性
面向对象的三大特征是指封装、继承和多态
一、封装：封装就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
所以在使用面向对象封装特性时，需要：
- 将内容封装到某处
- 从某处调用被封装的内容
第一步：将内容封装到某处
1 class foo(object): #创建类 2 3 def __init__(self,name,age): 4 self.name = name 5 self.age = age 6 7 8 obj1 = foo("haha",20) #根据类创建对象，自动执行foo类的__init__方法 9 obj2 = foo("hehe",21) #讲hehe和21分别封装到self 的name和age里面 10 11 print(obj1.name,obj1.age) #打印obj1的名字和年龄 12 print(obj2.name,obj2.age) #打印obj2的名字和年龄
self 是一个形式参数，当执行obj1 = foo("haha",20)时，self ==obj1
当执行obj2 = foo(“hehe”,21)时，self == obj2
所以，内容被封装到了对象obj1和obj2中，每个对象中都有name和age属性。
第二步：从某处调用被封装的内容
调用被封装的内容时，有两种情况：
- 通过对象直接调用
- 通过self间接调用
1、通过对象直接调用被封装的内容
1 class foo(object): #创建类 2 3 def __init__(self,name,age): 4 self.name = name 5 self.age = age 6 7 8 obj1 = foo("haha",20) #根据类创建对象，自动执行foo类的__init__方法 9 obj2 = foo("hehe",21) #讲hehe和21分别封装到self 的name和age里面 10 11 print(obj1.name) #直接调用obj1对象的name属性 12 print(obj1.age) #直接调用obj1对象的age属性 13 print(obj2.name) #直接调用obj2对象的name属性 14 print(obj2.age) #直接调用boj2对象的age属性
2、通过self间接调用被封装的内容
执行类中的方法时，需要通过self间接调用被封装的内容
1 class foo(object): #创建类 2 3 def __init__(self,name,age): 4 self.name = name 5 self.age = age 6 def detail(self): 7 print(self.name) 8 print(self.age) 9 10 obj1 = foo("haha",20) #根据类创建对象，自动执行foo类的__init__方法 11 obj1.detail() 12 obj2 = foo("hehe",21) #讲hehe和21分别封装到self 的name和age里面 13 obj2.detail()
如上所示：python首先执行init函数，把obj 传给self。并通过detail函数打印出结果
综上所述，对于面向对象的封装来说，就是使用构造方法将内容封装到对象中，然后通过对象直接或者间接通过self获取被封装的内容。
封装的练习
练习一：在终端输出如下信息
- 小明，10岁，男，上山去砍柴
- 小明，10岁，男，开车去东北
- 小明，10岁，男，最爱大保健
- 老李，90岁，男，上山去砍柴
- 老李，90岁，男，开车去东北
- 老李，90岁，男，最爱大保健
- 老张...
面向对象实现一
1 class foo(object): #创建类 2 3 def __init__(self,name,age,gender,profession): 4 self.name = name 5 self.age = age 6 self.gender = gender 7 self.profession = profession 8 9 10 obj1 = foo("小明",10,"男","上山去砍柴") 11 12 obj2 = foo("小明",10,"男","开车去东北") 13 14 obj3 = foo("小明",10,"男","最爱大保健") 15 obj4 = foo("老李",90,"男","上山去砍柴") 16 obj5 = foo("老李",90,"男","开车去东北") 17 obj6 = foo("老李",90,"男","最爱大保健") 18 19 print obj1.name,obj1.age,obj1.gender,obj1.profession 20 print obj2.name,obj2.age,obj2.gender,obj2.profession 21 print obj3.name,obj3.age,obj3.gender,obj3.profession 22 print obj4.name,obj4.age,obj4.gender,obj4.profession 23 print obj5.name,obj5.age,obj5.gender,obj5.profession 24 print obj6.name,obj6.age,obj6.gender,obj6.profession
面向对象实现二：
1 class foo(object): #创建类 2 3 def __init__(self,name,age,gender): 4 self.name = name 5 self.age = age 6 self.gender = gender 7 def kanchai(self): 8 print "%s,%s岁，%s,上山去砍柴" %(self.name,self.age,self.gender) 9 def qudongbei(self): 10 print "%s,%s,%s,开车去东北" %(self.name,self.age,self.gender) 11 def dabaojian(self): 12 print "%s,%s,%s,最爱大保健" %(self.name,self.age,self.gender) 13 14 obj = foo("小明",10,"男") 15 obj.kanchai() 16 obj.qudongbei() 17 obj.dabaojian() 18 19 laoli = foo("老李",90,'男') 20 laoli.kanchai() 21 laoli.qudongbei() 22 laoli.dabaojian()
函数实现方法：
1 def kanchai(name,age,gender): 2 print "%s,%s岁，%s,上山去砍柴" %(name,age,gender) 3 def qudongbei(name,age,gender): 4 print "%s,%s岁,%s,开车去东北" %(name,age,gender) 5 def dabaojian(name,age,gender): 6 print "%s,%s岁,%s,最爱大保健" %(name,age,gender) 7 8 kanchai("小明",10,"男") 9 qudongbei("小明",10,"男") 10 dabaojian("小明",10,"男") 11 12 kanchai("老李",10,"男") 13 qudongbei("老李",10,"男") 14 dabaojian("老李",10,"男")
封装的练习二：游戏人生程序
1、创建三个游戏人物，分别是：
- 苍井井，女，18，初始战斗力1000
- 东尼木木，男，20，初始战斗力1800
- 波多多，女，19，初始战斗力2500
2、游戏场景，分别：
- 草丛战斗，消耗200战斗力
- 自我修炼，增长100战斗力
- 多人游戏，消耗500战斗力
代码实现如下：
1 class game(object): 2 def __init__(self,name,gender,age,fight): 3 self.name = name 4 self.gender = gender 5 self.age = age 6 self.fight = fight 7 8 def caocong(self): 9 print self.fight - 200 10 def xiulian(self): 11 print self.fight +100 12 def youxi(self): 13 print self.fight - 500 14 def detail(self): 15 temp = "姓名:%s;性别:%s;年龄:%s;战斗力:%s" %(self.name,self.gender,self.age,self.fight) 16 print temp 17 18 cang = game("仓京京","女",18,1000) 19 dong = game("东尼木木","女",20,1800) 20 bo = game("波多多","女",19,2500) 21 22 cang.caocong() 23 dong.xiulian() 24 bo.youxi() 25 26 cang.detail() 27 dong.detail() 28 bo.detail()
4、继承
面向对象的继承和现实生活中的继承相同，即 子可以继承父的内容。
例如：猫可以 叫、吃、喝、拉
狗可以，叫、吃、和、拉
如果要分别为猫和狗创建一个类，那么就需要为猫和狗实现他们 所有的功能，如下所示：
1 class cat: 2 def catcall(self): 3 print "call" 4 def eat(self): 5 print "eat" 6 def drunk(self): 7 print "drunk" 8 def shit(self): 9 print "shit" 10 class dog: 11 def dogcall(self): 12 print "call" 13 def eat(self): 14 print "eat" 15 def drunk(self): 16 print "drunk" 17 def shit(self): 18 print "shit"
上述代码可以看出，吃、喝拉都屎猫和狗具有的共同功能，我们分别为狗和猫的类中写了两次。如果使用继承的思想，如下实现：
动物：吃、喝、拉
猫：猫叫（猫继承动物的功能）
狗：狗叫（狗继承动物的功能）
1 class animal: 2 def eat(self): 3 print "%s 吃" %self.name 4 def drunk(self): 5 print "%s 喝" %self.name 6 def shit(self): 7 print "%s 拉" %self.name 8 class cat(animal): 9 def __init__(self,name): 10 self.name = name 11 self.breed = "猫" 12 def cry(self): 13 print "猫叫" 14 class dog(animal): 15 def __init__(self,name): 16 self.name = name 17 self.breed = "狗" 18 def cry(self): 19 print "狗叫" 20 21 c1 = cat("A小猫") 22 c1.eat() 23 24 c2 = cat("B小猫") 25 c2.drunk() 26 d1 = dog("A狗") 27 d1.eat() 28 29 ———————————————————————————————————— 30 31 打印结果： 32 A小猫 吃 33 B小猫 喝 34 A狗 吃
对于面向对象的继承来说，就是将多个类共有的方法提取到父类中，子类仅需继承父类，而不再一一写下此功能，统一在父类中实现即可。
