py 面向对象

1.类的定义

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

2. 构造/析构 函数

__init__( self [,args...])方法为构造函数.
__del__( self )方法为析构函数. 调用 del obj 就可以删除.

3. 成员方法

使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self, 且为第一个参数.
函数不支持重载! 不然报错信息为 Duplicated signature.

3.1 形参中的self

假如你有一个类称为MyClass,它有一个方法是method(arg1, arg2)。当你调用这个对象的方法MyObject.method(arg1, arg2)的时候，这会由Python自动转为MyClass.method(MyObject, arg1, arg2),——这就是self的原理了。

3.2 私有方法 & 专有方法

• 私有方法
  __private_method()：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods.
• 专有方法
  以双下划线开始, 且以双下划线结束. 如 __str__(), 是object类的内置函数, 可以覆写. 用于返回str.

3.3 嵌套调用

需要使用self.fun()来调用.

def fun1(self):
    self.fun2();
def fun2(self):
    print 'hi'

3.4 一些注解

• @staticmethod
  可以当做静态函数来用.
  在函数前加上@staticmethod注解, 形参中移除self字段即可.

@staticmethod
def hi():
    print 'hhh';

• @property
  把函数当字段用. 把一个getter方法变成属性，只需要加上@property就可以了.

class foo():
    def __init__(self):
        self._name='tom'

    @property
    def name(self):
        return self._name

x=foo()
print(x.name)
print(x.name()) #这个时候就会报错, 因为已经把name当字段看了, 而它是 not callable的
"""
tom
TypeError: 'str' object is not callable
"""

• @classmethod
  如果在成员方法上添加此注解, 那么就可以通过A.fun() 而非 A().fun 来调用这个方法.

4. 成员字段

4.1 普通字段

在构造函数中通过self.field_1=x; self.field_2=x来添加普通字段.
py是动态语言, 可以随意声明类中没有声明的成员变量.

4.2 静态字段

在类中直接写field_1=x; field_2=x来添加静态字段.
可参看例子中的Employee类.

4.3 私有字段

在类中直接写__field_1=x;__field_2=x来添加私有字段.
__private_attrs：
两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs.

4.4 内置字段

__dict__, 会以dict的形式输出对象的成员变量. 在json.dumps( )时常用到.

4.4 hasattr(obj, name)

判断一个对象有没有指定的属性, 即字段.

class A:
    def a(self):
        self.name='tom'

ele=A()
print(hasattr(ele,'name'))
ele.a()
print(hasattr(ele,'name'))
"""
False
True
"""

5.例子

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);

    def entry(self):
            "创建 Employee 类的第一个对象"
            emp1 = Employee("Zara", 2000)
            "创建 Employee 类的第二个对象"
            emp2 = Employee("Manni", 5000)
            emp1.displayEmployee()
            emp2.displayEmployee()
            print ("Total Employee %d" % Employee.empCount)

if __name__=="__main__":
    Employee.__doc__;
    emp1 = Employee("Zara", 2000);
    emp1.entry();

6. 继承与重写

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

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

c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法

7.内部类

从下面的例子中可以看到, Child是Parent的内部类.

class Parent:

    def __init__(self):
        self.name = "parent"

    def getName(self):
        print (self.name)

    class Child:

        def __init__(self):
            self.name = "child"

        def getName(self):
            print (self.name)

if __name__ == "__main__":

    p = Parent()
    p.getName()

    c = p.Child()
    c.getName()
"""
parent
child

"""