python核心编程 13章类

#encoding=utf-8
#绑定，存在一个实例时，方法认为绑定到实例
#调用非绑定方法，调用子类覆盖掉的父类的构造方法
#def __init__(self,nm,em):
#    Baseclass.__init__(self,nm)

#静态方法和类方法
class TestStaticMethod:
    def foo():
        print 'calling static method foo()'
    foo = staticmethod(foo)
class TestClassMethod:
    def foo(cls):
        print 'calling class method foo()'
        print 'foo() is part of class:',cls.__name__
    foo = classmethod(foo)
tsm = TestStaticMethod()
TestStaticMethod.foo()
tsm.foo()
tcm = TestClassMethod()
tcm.foo()
TestClassMethod.foo()
#类和实例均可以调用

#现在更常用函数修饰符
class TestStaticMethod:
    #实例方法
    #。实例方法隐含的参数为类实例ｓｅｌｆ
    def InstanceFun(self):
        print 'InstanceFun'
    #静态方法
    #静态方法无隐含参数，主要为了类实例也可以直接调用静态方法
    @staticmethod
    def foo():
        print 'calling static method foo()'
class TestClassMethod:
    #类方法
    #类方法隐含的参数为类本身ｃｌｓ
    @classmethod
    def foo(cls):
        print 'calling class method foo()'
        print 'foo() is part of class:', cls.__name__
#逻辑上类方法应当只被类调用，实例方法实例调用，静态方法两者都能调用
#　Ｐｙｔｈｏｎ实现了一定的灵活性使得类方法和静态方法，都能够被实例和类二者调用


#组合
#一个类由他本身和其他类组合而成，has-a的关系。
class Name(object):
    def __init__(self,nm):
        self.name = nm
class Phone(object):
    def __init__(self,ph):
        self.phone = ph
#New类拥有Name类实例和Phone类实例
class NewAddrBookEntry(object):
    def __init__(self,nm,ph):
        self.name = Name(nm)  #创建name实例
        self.phone = Phone(ph) #创建Phone实例
        print 'create instance for:',self.name
book = NewAddrBookEntry('hh','57788')


'''=============子类和派生=============='''

class Parent(object):
    def parentMethod(self):
        print 'calling parent method'
class Child(Parent):
    def childMethod(self):
        print 'calling child method'
p = Parent()
p.parentMethod()
c = Child()
c.childMethod()
c.parentMethod()
#子类调用父类方法

'''===============继承==================='''
#继承，基类的属性遗传给派生类
class P:
    'P class'
    def __init__(self):
        print 'create an instance of ', 
            self.__class__.__name__
class C(P):
    pass
#类P，有文档字符串（__doc__）,构造器。
#类C，文档字符串是各自的，会继承P的构造器
p = P()
print p.__class__,P.__bases__,P.__doc__ #所属类名，父类，文档字符串
c = C()
print c.__class__,C.__bases__,C.__doc__

#__bases__包含父类的集合的元组，没有父类，显示空
class A(object):
    pass
class B(A):
    pass
class C(B):
    pass
class D(A):    #会报错，不知道什么原因
    pass
print A.__bases__
print C.__bases__
print D.__bases__

#通过继承覆盖方法、
class P(object):
    def foo(self):
        print 'hi,i am P-foo()'
p = P()
p.foo()
class C(P):
    #C继承自P，定义了自己的foo方法时候会覆盖
    def foo(self):
        print 'hi, i am c-foo()'
c = C()
c.foo()
#调用未绑定的基类方法,明确给出子类的实例
P.foo(c)

print '====='
class C(P):
    def foo(self):
        P.foo(self)    #未绑定的方法显示地传递了self,调用p-foo
        print 'hi i am c-foo()'
c = C()
c.foo()
print '===='
#更好使用super()方法 
class C(P):
    def foo(self):
        super(C,self).foo()    #调用p-foo，super不需要明确给出任何基类的名字
        print 'hi , i am c-foo()'
c = C()
c.foo()

'''=======多重继承==========='''
#子类继承自多个父类，究竟调用哪个方法,深度优先搜索
class P1(object):
    def foo(self):
        print 'i am P1-foo()'
class P2(object):
    def foo(self):
        print 'i am P2-foo()'
    def bar(self):
        print 'i am P2-bar()'

class C1(P1,P2):
    pass
class C2(P1,P2):
    def bar(self):
        print 'i am C2-bar()'

class CC(C1,C2):
    pass
#P1：foo      P2：foo，bar
#C1继承P1，P2    C2：bar 继承C1，C2
#CC继承C1，C2
cc = CC()
cc.foo()  #CC==C1==C2==P1   CC找最亲的父类C1，在找父类C2。C1找父类，广度优先搜索
cc.bar() #CC==C1==C2  CC找最亲父类C1，再找父类C2
C2.bar(cc)

#查找顺序
print '======',CC.__mro__

'''=========类，实例，和其他对象的内建函数======='''
#issubclass(sub,sup)sub子类是不是sup父类的子类
#isinstance(obj1,class)obj1实例是不是类class的实例
#hasattr，getattr，setattr，delattr， 属性
#dir(),vars()