Python面向对象编程

    本来想顺便讲一讲面向对象编程的思想，但是随便一搜发现资料好多，而且内容都是洋洋洒洒几百上千字，所以本文就不在啰嗦了，有兴趣的童鞋自行百度撒~；

    面向对象三个特征：封装，继承，多态。

    封装：就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏；

    继承：可以使用现有类的所有功能，并在无需重新编译原来类的情况下对这些功能进行扩展；

    多态： 一个基类的引用符，可以指向多种派生类对象，具有多种不同的形态，这种现象叫多态性；

Python中类的定义格式：

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

下面通过例子直接来理解class的使用方法。

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
    '所有员工的基类'
    empCount=0            #类变量，它的值在这个类的所有实例之间共享，可以使用Employee.empCount访问

    def __init__(self,name,salary):     #类的构造函数或者初始化方法
        self.name=name
        self.salary=salary
        Employee.empCount +=1

    def displayCount(self):
        print "Total Employee %d" % Employee.empCount

    def displayEmployee(self):
        print "Name:",self.name,",Salary:",self.salary


"创建类的第一个对象"
emp1=Employee("Zara",2000)
"创建类的第二个对象"
emp2=Employee("Manni",5000)

emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

run C:\Anaconda\tclass.py
Name: Zara ,Salary: 2000
Name: Manni ,Salary: 5000
Total Employee 2

#添加删除修改属性  
emp1.age=7
emp1.age=8
del emp1.age

#访问属性
hasattr(emp1,'age')
getattr(emp1,'age')
setattr(emp1,'age',8)
delattr(emp1,'age')

Python访问内置类属性：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
    '所有员工的基类'
    empCount=0            #类变量，它的值在这个类的所有实例之间共享，可以使用Employee.empCount访问

    def __init__(self,name,salary):     #类的构造函数或者初始化方法
        self.name=name
        self.salary=salary
        Employee.empCount +=1

    def displayCount(self):
        print "Total Employee %d" % Employee.empCount

    def displayEmployee(self):
        print "Name:",self.name,",Salary:",self.salary


#"创建类的第一个对象"
#emp1=Employee("Zara",2000)
#"创建类的第二个对象"
#emp2=Employee("Manni",5000)

#emp1.displayEmployee()
#emp2.displayEmployee()
#print "Total Employee %d" % Employee.empCount



#内置类属性
print "Employee.__doc__:", Employee.__doc__
print "Employee.__name__:", Employee.__name__
print "Employee.__module__:", Employee.__module__
print "Employee.__bases__:", Employee.__bases__
print "Employee.__dict__:", Employee.__dict__

run C:\Anaconda\tclass.py
Employee.__doc__: 所有员工的基类
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount': <function displayCount at 0x0000000003B92B38>, 'empCount': 0, 'displayEmployee': <function displayEmployee at 0x0000000003B92BA8>, '__doc__': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', '__init__': <function __init__ at 0x0000000003B92AC8>}

Python对象垃圾回收

析构函数 __del__ ，__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方法运行：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "销毁"

pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # 打印对象的id
del pt1
del pt2
del pt3

以上实例运行结果如下：

3083401324 3083401324 3083401324
Point 销毁

Python对象类的继承：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Parent:
    parentAttr=100
    def __init__(self):
        print "调用类构造函数"

    def parentMethod(self):
        print '调用父类方法'

    def setAttr(self,attr):        #设置属性
        Parent.parentAttr=attr

    def getAttr(self):
        print "父类属性：", Parent.parentAttr   #获取属性

class Child(Parent):
    def __init__(self):
        print "调用子类构造方法"

    def childMethod(self):
        print '调用子类方法 child method'

c=Child()
c.childMethod()
c.parentMethod()
c.setAttr(200)
c.getAttr()


# 你可以继承多个类
class A:
    ...

class B:
    ...

class C(A,B):
    ...

运行结果：

run C:\Anaconda\jclass.py
调用子类构造方法
调用子类方法 child method
调用父类方法
父类属性： 200

Python方法重写：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Parent:
    def myMethod(self):
        print '调用父类方法'

class Child(Parent):
    def myMethod(self):
        print '调用子类方法'

c=Child()
c.myMethod()

run C:\Anaconda\cclass.py
调用子类方法

Python类的私有属性：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class JustCounter:
    __secretCount=0     #私有变量
    publicCount=0

    def count(self):
        self.__secretCount +=1
        self.publicCount +=1
        print self.__secretCount

counter=JustCounter()
counter.count()
counter.count()
print counter.publicCount
#print counter.__secretCount  # 出错 实例无法访问私有变量

# 可以这样访问私有变量
print counter._JustCounter__secretCount

运行结果：

run C:\Anaconda\cclass.py
1
2
2
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
C:\Anaconda\cclass.py in <module>()
     15 counter.count()
     16 print counter.publicCount
---> 17 print counter.__secretCount  # 出错 实例无法访问私有变量
AttributeError: JustCounter instance has no attribute '__secretCount'


run C:\Anaconda\cclass.py
1
2
2
2

参考资料：http://www.runoob.com/python/python-object.html