python 24day--python面向对象编程

首先说明一下说有程序中都会出现的语句：if __name__ == "__main__"

通俗的理解__name__ == '__main__'：假如你叫小明.py，在朋友眼中，你是小明(__name__ == '小明')；在你自己眼中，你是你自己(__name__ == '__main__')。
if __name__ == '__main__'的意思是：

当.py文件被直接运行时，if __name__ =='__main__'之下的代码块将被运行；

当.py文件以模块形式被导入时，if __name__ == '__main__'之下的代码块不被运行。

一、编程的三大范式：

1、面向过程编程

2、函数式编程

3、面向对象编程

二、什么是面向对象编程：

面向对象编程是一种编程方式，此编程方式的落地需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

类就是一个模板，模板里可以包含多个函数，函数里实现一些功能

对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

 1 class Protection:
 2     def __init__(self,name,):
 3         self.name = name
 4     def diff_cur(self):
 5         print('%s have diff_cur function'%self.name)
 6     def distance(self):
 7         print('%s have distance function'%self.name)
 8     def over_current(self):
 9         print('%s have over_currrent function'%self.name)
10 csc103 = Protection('线路光差保护')
11 csc103.diff_cur()
12 csc103.over_current()
13 csc101 = Protection('线路距离保护')
14 csc101.distance()
15 csc101.over_current()

三、面向对象的三大特性：继承、封装、多态

1、对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容

练习一：在终端输出如下信息

小明，10岁，男，上山去砍柴
小明，10岁，男，开车去东北
小明，10岁，男，最爱大保健
老李，90岁，男，上山去砍柴
老李，90岁，男，开车去东北
老李，90岁，男，最爱大保健

函数式编程：

 1 def kanchai(name, age, gender):
 2     print "%s,%s岁,%s,上山去砍柴" %(name, age, gender)
 3 
 4 
 5 def qudongbei(name, age, gender):
 6     print "%s,%s岁,%s,开车去东北" %(name, age, gender)
 7 
 8 
 9 def dabaojian(name, age, gender):
10     print "%s,%s岁,%s,最爱大保健" %(name, age, gender)
11 
12 
13 kanchai('小明', 10, '男')
14 qudongbei('小明', 10, '男')
15 dabaojian('小明', 10, '男')
16 
17 
18 kanchai('老李', 90, '男')
19 qudongbei('老李', 90, '男')
20 dabaojian('老李', 90, '男')

面向对象编程：

 1 class Foo:
 2     
 3     def __init__(self, name, age ,gender):
 4         self.name = name
 5         self.age = age
 6         self.gender = gender
 7 
 8     def kanchai(self):
 9         print "%s,%s岁,%s,上山去砍柴" %(self.name, self.age, self.gender)
10 
11     def qudongbei(self):
12         print "%s,%s岁,%s,开车去东北" %(self.name, self.age, self.gender)
13 
14     def dabaojian(self):
15         print "%s,%s岁,%s,最爱大保健" %(self.name, self.age, self.gender)
16 
17 
18 xiaoming = Foo('小明', 10, '男')
19 xiaoming.kanchai()
20 xiaoming.qudongbei()
21 xiaoming.dabaojian()
22 
23 laoli = Foo('老李', 90, '男')
24 laoli.kanchai()
25 laoli.qudongbei()
26 laoli.dabaojian()

2、继承：

 1 class people:
 2 
 3     def __init__(self, name, age, weight):
 4         self.name = name
 5         self.age = age
 6         self.__weight = weight
 7 
 8     def speak(self):
 9         print("%s 说: 我 %d 岁。" % (self.name, self.age))
10 
11 # 单继承示例
12 class student(people):
13 
14     def __init__(self, name, age, weight, grade):
15         # 调用父类的实例化方法
16         people.__init__(self, name, age, weight)
17         self.grade = grade
18 
19     # 重写父类的speak方法
20     def speak(self):
21         print("%s 说: 我 %d 岁了，我在读 %d 年级" % (self.name, self.age, self.grade))
22 
23 s = student('ken', 10, 30, 3)
24 s.speak()

3、多态

狗、猫、猪都继承了动物类，并各自重写了kind方法。show_kind()函数接收一个animal参数，并调用它的kind方法。可以看出，无论我们给animal传递的是狗、猫还是猪，都能正确的调用相应的方法，打印对应的信息。这就是多态。

实际上，由于Python的动态语言特性，传递给函数show_kind()的参数animal可以是任何的类型，只要它有一个kind()的方法即可。动态语言调用实例方法时不检查类型，只要方法存在，参数正确，就可以调用。这就是动态语言的“鸭子类型”，它并不要求严格的继承体系，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。

 1 class Animal:
 2 
 3     def kind(self):
 4         print("i am animal")
 5 
 6 
 7 class Dog(Animal):
 8 
 9     def kind(self):
10         print("i am a dog")
11 
12 
13 class Cat(Animal):
14 
15     def kind(self):
16         print("i am a cat")
17 
18 
19 class Pig(Animal):
20 
21     def kind(self):
22         print("i am a pig")
23 
24 # 这个函数接收一个animal参数，并调用它的kind方法
25 def show_kind(animal):
26     animal.kind()
27 
28 
29 d = Dog()
30 c = Cat()
31 p = Pig()
32 
33 show_kind(d)
34 show_kind(c)
35 show_kind(p)
36 
37 ------------------
38 打印结果：
39 
40 i am a dog
41 i am a cat
42 i am a pig