【Python】Class

面对对象编程的三大特性：封装,继承，多态。

封装：create class

class封装了Attribute和method，提供给外部访问是属性，如A.attribute，或者方法A.function(*argx)。

类需要实例化为对象,如a=A()，因此类中有__init__函数，先假定义一个self来表示实例并给它赋值。self必须存在的原因是，需要通过self实例化对象来传递数据和调用类内函数。

def function():
    print(A)
class Dog():
    def __init__(self,x,y,z):
        self.attribute1=x
        self.attribute2=y
        self.attribute3=z
    def function(self):
        print (B)
    def useself(self):
        self.function() # function in class B
        function() #function out of class A

Create Class 示例代码

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class Employee:
   '所有员工的基类'
   empCount = 0
 
   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
  #第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
#类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

   def displayCount(self):
     print "Total Employee %d" % Employee.empCount
 
   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary
    
    
emp1=Employee("zara",2000)
#创建对象
emp1.displayEmployee()
#调用方法
emp1.empcount
#调用属性

hasattr(emp1, 'age')    
# 如果存在 'age' 属性返回 True。
getattr(emp1, 'age')    
# 返回 'age' 属性的值
setattr(emp1, 'age', 8) 
# 添加属性 'age' 值为 8
delattr(empl, 'age')    
# 删除属性 'age'


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

继承：create sub class

继承：子类能继承父类的方法属性，也可以自己加方法和属性，加入的如果名字一样会覆盖原来的。父类无法访问子类新方法。

class Parents():
    def _init_(self):
        self.name=name
        self.age=age
    def walk(self):
        pass
# 父类定义
class child(Parents):
    def _init_(self):
        self.name=name+'!'
    def new_method(self):
        pass   
# 子类定义

super()

super() 函数是用于调用父类(超类)的一个方法。

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

class A:
     def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super().add(x)
b = B()
b.add(2)  # 3

subclass 示例代码

#!/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()# 再次调用父类的方法

多态：methods overwrite

子类的方法可以重写父类，但要名字不一样

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
class Parent:        # 定义父类
   def myMethod(self):
      print '调用父类方法'
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print '调用子类方法'
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法

调用：

调用类的实例方法是否加self？
无参数时，如果没有直接实例该类，必须加：self；或者在调用方法时，提前定义这个类的实例，才能直接调用该类的实例方法。
有参数时，也要加self，必须加后面的参数。调用类的静态方法，不用加self，跟据参数匹配进行调用。调用类的类方法时，根据参数匹配即可。