#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()
