python面向对象

 面向对象就是抽取某一方面共有的属性出来，构建一个类Class。这个类就叫父类（超类）。

python构建类的方式：

class Employee:
    '员工类'
    empCount = 0;'用于计数总共有多少个员工'
    '构造方法'
    def __init__(self,name,salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1

    '获取当前有多少员工'
    def displayCount(self):
        print(u'当前有 %d 员工'% Employee.empCount)

    '展示员工的信息'
    def displayEmployee(self):
        print(u'名字：',self.name,u'工资:',self.salary)

语法 class 类名: ,（类名与文件名一致）类的构造方法是系统默认的__init__(self)方法,当你在创建对象的时候系统会调用这个方法。你也可以对这个方法重写，python对重写方法没有什么特别的标志。值得注意的是，在类中所有的方法，必须在第一个位置多写一个self参数。这个self指的是当前实例化对象本身。

类中可以有私有，受保护，公开的属性和方法。具体如下：

另外还有一个 __system__ 表示系统的

在构建类的方法时需要注意第一个位置参数self(当然参数名字可以随便取，但是self是行规，方便代码可读性)必须要有。

python内置类属性：

• __dict__ : 类的属性（包含一个字典，由类的数据属性组成）
• __doc__ :类的文档字符串
• __name__: 类名
• __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
• __bases__ : 类的所有父类构成元素（包含了以个由所有父类组成的元组）

调用如下

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

class Employee:
   '所有员工的基类'
   empCount = 0

   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

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__

python垃圾回收：

　　同Java语言一样，Python使用了引用计数这一简单技术来追踪内存中的对象。

　　在Python内部记录着所有使用中的对象各有多少引用。

　　一个内部跟踪变量，称为一个引用计数器。

　　当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。

　　垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。这种情况下，仅使用引用计数是不够的。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

==========================================================================

类的继承：

python支持多继承。

语法：class 类名（基类1[,基类2][,基类3]...）.

在创建子类实例对象的时候，系统不会自已去调用父类中的构造方法。需要在子类中手动添加父类的构造方法。如：

#!/user/bin/python
# -*- coding:utf-8 -*-
'''父类'''
class SupClass:
    '父类'
    supAttribution = 100;
    def __init__(self):
        print('调用父类构造方法');

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

    def setAttr(self):
        SupClass.supAttribution = self.supAttribution;

    def getAttr(self):
        print('父类中的属性',SupClass.supAttribution);

#!/user/bin/python
# -*- coding:utf-8 -*-
from SupClass import *
class SubClass(SupClass):
    '子类'
    def __init__(self):
        SupClass.__init__(self);
        print('调用子类构造方法');

    def childMethod(self):
        print('调用子类中的childMethod 方法');

你可以使用issubclass()或者isinstance()方法来检测。

• issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)
• isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

还需注意的是python中导入的两种方式的区别：

from ... import ... 与 import ...

这两者唯一的区别在于：

第一种导入，在调用类里面的属性方法时，直接类名.方法名；

第二种导入，在调用类里面的属性方法时，需要全限定名才能调用。

============================================================================

子类中的方法重写

python类中方法的重写没有什么特殊的标志，你只需在子类中用父类中的方法名就行。python在调用方法的时候，首先会去自身中去找有没有该方法，有的话就调用自身的方法。如果没有就往父类中去寻找，一级一级往上找。如果父类中也没有的话就会报一个属性错误：

AttributeError: 'SubClass' object has no attribute 'lss'

=====================================================================

基础重载方法：

下面列出了一些通用的功能，你可以在自己的类重写：

 　　__init__(self[,args...]) 构造函数

　　__del__(self)析构方法，删除一个对象

　　__repr__(self)转化为供解释器读取的形式

　　__str__(self) 格式化输出方法

　　__cmp__(self,x)对象比较

======================================================================

python 支持运算符重载

#!/usr/bin/python

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print v1 + v2

最后，python中类的私有属性不是绝对意义上的私有，在外部也可以改变类的私有属性的值。

#!/user/bin/python
# -*- coding:utf-8 -*-
class ClassAttr:
    __secreCount = 0;#类的封闭属性
    publicCount = 0;#类的公开属性

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

私有属性 __secreCount 可以通过这样访问修改

类中的私有属性被修改了