python 系列(10) 面向对象

Posted on Posted in python

### 面向对象技术简介

- 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
- 类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
- 数据成员:类变量或者实例变量用于处理类及其实例对象的相关的数据。
- 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
- 实例变量:定义在方法中的变量,只作用于当前实例的类。
- 继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。
- 实例化:创建一个类的实例,类的具体对象。
- 方法:类中定义的函数。
- 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

### 创建类

> 语法格式

  1. class ClassName:  
  2.    '类的帮助信息'   #类文档字符串  
  3.    class_suite  #类体  

> 例子

  1. #!/usr/bin/env python  
  2.   
  3. class Yuangong:  
  4.     '''all eg1'''  
  5.     empCount = 0  
  6.   
  7.     def __init__(self, name, gongzi):  
  8.         self._name = name  
  9.         self._gongzi = gongzi  
  10.         Yuangong.empCount += 1  
  11.   
  12.     def displayCount(self):  
  13.         print "all yuangong %d " % Yuangong.empCount  
  14.   
  15.     def displayYuangong(self):  
  16.         print "name :", self._name, ", xinshui:", self._gongzi  
  17.   
  18. p1 = Yuangong("p1",1000)  
  19. p1.displayYuangong()  
  20.   
  21. p2 = Yuangong("p2",2000)  
  22. p2.displayYuangong()  
  23.   
  24. print "all %d " % Yuangong.empCount   
  25.   
  26. p1.age = 20 # 添加一个age属性  
  27. p1.age = 30 # 修改一个age属性  
  28. del p1.age # 删除一个age属性  
  29.   
  30.   
  31. print hasattr(p2, 'age') # 如果存在age属性返回True  
  32. #getattr(p2, 'age') # 获取age属性,不存在会报错  
  33. setattr(p2, 'age', 9) # 设置age属性  
  34. delattr(p2, 'age') # 深处age属性  
  35.   
  36. print Yuangong.__doc__ # 类的文档字符串  
  37. print Yuangong.__name__ # 类名  
  38. print Yuangong.__module__ # 类定义所在的模块  
  39. print Yuangong.__bases__ # 类的所有父类构成元素(包含了一个忧所有父类组成的元祖)  
  40. print Yuangong.__dict__ # 类的属性(包含一个字典,由类的数据属性组成)  

### python 类的继承

  1. #!/usr/bin/env python  
  2. class A():  
  3.         def __init__(self, name):  
  4.                 self._name = name  
  5.                 print "A name : ", self._name  
  6.         def getName(self):  
  7.                 print "A getname", self._name  
  8.   
  9. class B(A): # 继承A,如果多继承,class B(A, C)  
  10.         def __init__(self, name): # 如果不写,会执行父类的__init__  
  11.                 print "B init"  
  12.         def getName(self): # B会重写父类的方法  
  13.                 print "B getname"  
  14.   
  15. a = B('a')  
  16. a.getName()  

> super 方法访问父类__init__

  1. #!/usr/bin/env python  
  2. class A(object): # 这里加上object  
  3.         def __init__(self, name):  
  4.                 self._name = name  
  5.                 print "A name : ", self._name  
  6.         def getName(self):  
  7.                 print "A getname", self._name  
  8.   
  9. class B(A):   
  10.         def __init__(self, name):  
  11.                 super(B,self).__init__(name) # 使用super方法调用父类的__init__方法  
  12.                 print "B init"  
  13.         def getName(self):   
  14.                 print "B getname"  
  15.   
  16. a = B('a')  
  17. a.getName()  

### 私有方法

  1. #!/usr/bin/env python  
  2. class A:  
  3.     __secretCount = 0   # 私有变量  
  4.     publicCount = 0 # 公共变量  
  5.       
  6.     def count(self):  
  7.         self.__secretCount += 1  
  8.         self.publicCount += 1  
  9.         print self.__secretCount  
  10.   
  11. a = A()  
  12. a.count()  
  13. a.count()  
  14. print a.publicCount  
  15. print a.__secretCount # 这里访问会报错,因为是私有的  
  16. print a._A__secretCount # 这里不会报错,所有python的私有机制是伪私有  
» 转载请注明来源:若我若鱼 » python 系列(10) 面向对象

Leave a Reply

Your email address will not be published. Required fields are marked *

2 × three =