Python学习笔记（五）—第七、八天，面向对象概念

这两天学习类、属性、方法、对象等概念，由于原来基础比较薄弱，没接触过面向对象的语言，一遍看下来，彻底懵逼了。

啃了两天，才算是不那么懵了。简单记录下。

Class是一种抽象概念，比如我们定义的Class——Student，是指学生这个概念，而实例（Instance）则是一个个具体的Student，比如，Bart Simpson和Lisa Simpson是两个具体的Student。

所以，面向对象的设计思想是抽象出Class，根据Class创建Instance。参考廖雪峰的官方网站Python3

类和对象主要是封装、继承、多态几个知识点。

类包括属性和方法，这是它与函数不同的地方，函数只有方法。

封装，我的理解是将一些数据和方法隐藏在函数内部了，外部不需要知道为什么，只要实例调用就好了。

就好像我们知道 +，既可以1 + 2，也可以‘a’+‘b’，至于为什么，在它的内部，我们不需要知道。

继承是指，子类继承父类的数据和方法。

比如，我们定义了一个名为Animal的class，它有一个run()de 方法，那么，当我们创建Dog、Cat等子类时，就可以继承Animal的属性和方法，不需要重复创建。

 1 >>> class Animal(object):
 2     def run(self):
 3         print('Animal is running...')
 4 
 5         
 6 >>> class Dog(Animal): #继承类Animal
 7     pass
 8 
 9 >>> class Cat(Animal):
10     pass

在class Dog和Cat中，我都没有创建任何函数，接下来我创建子类的实例，并调用run():

1 >>> dog = Dog()
2 >>> cat = Cat()
3 >>> dog.run()
4 Animal is running...
5 >>> cat.run()
6 Animal is running...

子类Dog和Cat，都可以调用从父类Animal继承的run()方法。都打印出Animal is running...

但是，如果子类中定义与父类同名的方法或属性，则会自动覆盖父类对应的方法或属性。不同名，则可以新增，属于子类。

如上面的例子，Dog肯定不希望仅仅打印出Animal。

 1 >>> class Dog(Animal):
 2     def rund(self):
 3         print('Dog is running...')
 4 
 5 
 6 >>> class Cat(Animal):
 7     def run(self):
 8         print('Cat is running...')
 9 
10 
11 >>> dog = Dog()
12 >>> cat = Cat()
13 >>> dog.run()
14 Animal is running...
15 >>> dog.rund()
16 Dog is running...
17 >>> cat.run()
18 Cat is running...

这里面，类对象Dog新增了方法，rund()，所以实例dog，既可以调用从父类继承来的方法run(),输出Animal is running，

也可以调用自己新增的方法rund()，输出Dog is running；

而类对象Cat，因为新增的方法run(),与父类方法重名，所以覆盖了父类对应的方法。所以，cat.run()输出，Cat is running。

继承属性可以使用super函数或者在子类的__init__函数里面调用父类的__init__函数。

实例：父类Student，有学生的属性名字、性别、分数。

 1 # -*- coding: utf-8 -*-
 2 # 创建类对象Student
 3 class Student(object):
 4     """docstring for Student"""
 5     count = 0
 6     def __init__(self,name,gender,score):#各项属性
 7         self.__name = name
 8         self.__gender = gender
 9         self.score = score
10         Student.count = Student.count + 1   
11     
12 #打印学生分数，创建方法
13     def print_score(self):
14         print("%s的分数为%s"% (self.__name,self.score))
15 #打印学生信息
16     def print_info(self):
17         print("学生：%s=======性别：%s=======分数：%s"% (self.__name,self.__gender,self.score))
18     def print_count():
19          print('学生总数为：%d'% Student.count)
20 
21 #创建学生实例
22 xiaoming = Student('小明','男',80)
23 xiaohong = Student('小红','女',90)
24 xiaowang = Student('小王','男',60)
25 xiaohua  = Student('小花','女',85)
26 
27 #小明的分数
28 xiaoming.print_score()
29 #小花的学生信息
30 xiaohua.print_info()
31 #学生总数32 Student.print_count()

其实最后的学生总数也可以使用实例.count，求属性的方法获得。如，xiaoming.count。

执行结果为：

继承，那如果我们再加上父母以及对应的关系的话：

 1 # -*- coding: utf-8 -*-
 2 # 创建类对象Student
 3 class Student(object):
 4     """docstring for Student"""
 5     count = 0
 6     def __init__(self,name,gender,score):#各项属性
 7         self.name = name        #因为在子类中引用了self.name，无法隐藏了，改为self.name
 8         self.gender = gender
 9         self.score = score
10         Student.count = Student.count + 1   
11     
12 #打印学生分数，创建方法
13     def print_score(self):
14         print("%s的分数为%s"% (self.name,self.score))
15 #打印学生信息
16     def print_info(self):
17         print("学生：%s=======性别：%s=======分数：%s"% (self.name,self.gender,self.score))
18     def print_count():
19          print('学生总数为：%d'% Student.count)
20 
21 #创建学生实例
22 xiaoming = Student('小明','男',80)
23 xiaohong = Student('小红','女',90)
24 xiaowang = Student('小王','男',60)
25 xiaohua  = Student('小花','女',85)
26 
27 #小明的分数
28 xiaoming.print_score()
29 #小花的学生信息
30 xiaohua.print_info()
31 #学生总数
32 Student.print_count()
33 
34 #创建Student的子类Parent，除了Student的各项属性，又要新增关系，以及他们的name。
35 class Parent(Student):
36     def __init__(self,relation,pname,name,gender,score):
37         super(Parent,self).__init__(name,gender,score)
38         self.relation = relation
39         self.pname = pname
40 
41     def print_relation(self):
42         print("%s是%s的%s,%s考了%s分"% (self.pname,self.name,self.relation,self.name,self.score))
43         if self.gender == '男':
44             print('%s是%s的儿子'%(self.name,self.pname))
45         else:
46             print('%s是%s的女儿'%(self.name,self.pname))
47 #创建家长实例
48 laoming = Parent('父亲','老明','小明','男',80)
49 
50 
51 laohua = Parent('母亲','老花','小花','女',90)
52 laoming.print_relation()
53 laohua.print_relation()

类Parent继承了Student，使用了super函数。

运行结果为：

然后，子类的实例也继承了父类的方法：

1 >>> laoming.print_info()
2 学生：小明=======性别：男=======分数：80
3 >>> laohua.print_info()
4 学生：小花=======性别：女=======分数：90

因为又创建了两个子类的实例，所以如果最后再求count的话，就会变为6，学生总数已经不准确了。

如要计算的话，我想应该是把学生的实例对象组成一个数列，然后与家长类的实例对象的数列里name作对比，

然后判断，是减去或加上Parent类的count。

唉，这么一个东西，写得贼丑陋了。。。

菜鸟很捉急