标签：
这两个都是构造器方法，但是__init__()方法是在类实例创建之后调用，而__new__()正式创建这个类实例的方法
#coding=utf-8 class Person(object): def __init__(self,name,age): print ‘__init__ called‘ self.name = name self.age = age def __new__(cls,name,age): print ‘__new__ called‘ return super(Person,cls).__new__(cls,name,age) # 返回Person类的一个实例 p = Person(‘xiaoming‘,21)
运行输出结果
__new__ called __init__ called
所以，init 和 new 最主要的区别在于：
1，init()通常用于初始化一个新实例，控制这个初始化的过程，比如添加一些属性， 做一些额外的操作，发生在类实例被创建完以后。它是实例级别的方法。
2，new()通常用于控制生成一个新实例的过程。它是类级别的方法。
3，init()一定要返回None，不能返回其他类型
我们可以使用__new__()方法实现对象的单例
class Singleton(object): def __new__(cls): if not hasattr(cls,‘instance‘): cls.instance = super(Singleton,cls).__new__(cls) return cls.instance obj1 = Singleton() obj2 = Singleton() print obj1 is obj2 #输出结果为True
class TestStaticMethod(object): @staticmethod def foo(): print ‘calling static method foo()‘ class TestClassMethod(object): @classmethod def foo(cls): print ‘calling class method foo()‘ print ‘foo() is part of class:‘,cls.__name__ tsm = TestStaticMethod() TestStaticMethod.foo() #calling static method foo() tsm.foo() #calling static method foo() print ‘###########################‘ tcm = TestClassMethod() TestClassMethod.foo() #calling class method foo() foo() is part of class: TestClassMethod tcm.foo() #calling class method foo() foo() is part of class: TestClassMethod
继承描述了基类的属性如何‘遗传’给派生类，一个子类可以继承基类的任何属性，不管是数据属性还是方法
#coding=utf-8 class P(object): #父类 ‘p class‘ def __init__(self): print ‘created an instance of‘, self.__class__.__name__ class C(P): #子类 pass
创建的P有文档字符串（doc）和构造器，当实例化P对象时它被执行，如下的交互会话所示：
>>> p = P() created an instance of P >>> p.__class__ <class constru.P at 0x7fdfb2730328> >>> p.__doc__ ‘p class‘
“created an instance”是有__init__()直接输出的，现在来实例化C，展示构造方法在执行过程种是如何继承的
>>> c = C() created an instance of C >>> c.__class__ <class ‘constru.C‘> >>> C.__bases__ (<class ‘constru.P‘>,) >>> c.__doc__ >>>
C没有声明__init__()方法，但是C继承了P的__init__()。__bases__元组列出了其父类P。需要注意的是文档字符串对类，函数/方法，还有模块来说都是唯一的。所以特殊属性__doc__不会从基类种继承过来。
对任何类，它包含其父类的集合的元组。那些没有父类的类，它们的__bases__属性是空
>>> class A(object):pass #定义类A ... >>> class B(A):pass #A的子类 ... >>> class C(B):pass #B的子类(A的间接子类) ... >>> class D(B,A):pass #请注意这里的顺序，一定要B然后在A， ... >>> A.__bases__ (<type ‘object‘>,) >>> C.__bases__ (<class ‘__main__.B‘>,) >>> D.__bases__ (<class ‘__main__.B‘>, <class ‘__main__.A‘>) >>>
class P(object): def foo(self): print ‘Hi, I am P-foo()‘ class C(P): def foo(self): print ‘Hi, I am C-foo()‘ >>> p = P() >>> p.foo() Hi, I am P-foo() >>> c = C() >>> c.foo() Hi, I am C-foo()
尽管C继承了P的foo()方法，但是C定义了自己的foo()方法，所以P中的foo()方法被覆盖了。但是我们还是可以调用被覆盖的方法。只需要调用一个未绑定的基类方法，给出子类的实例
>>> P.foo(c)
Hi, I am P-foo()
注意在上面的例子，没有使用已经存在的P的实例p。我们不需要P的实例调用P的方法，我们已经有一个P的子类的实例c可用。所以：
class C(P): def foo(self): super(C,self).foo() #等同于P.foo(self),但是使用super()。可以不需要明确提供父类。 print ‘Hi, I am C-foo()‘
调用
>>> c = C() >>> c.foo() Hi, I am P-foo() Hi, I am C-foo()
issubclass()布尔函数，判断一个类是否是另一个类的子类或者子孙类，语法
issubclass(sub,sup)，sup可以是父类组成的元组
返回True：子类sub是父类sup的子类。这个函数允许不严格的子类，意味着一个类可以视为其自身的子类
>>> issubclass(int,int)
True
isinstance()布尔函数判断一个对象是否是给定类的实例，语法：
isinstance(obj1,obj2)，obj2可以是一个元组
isinstance()在obj1是类obj2的一个实例，或者是obj2的子类的一个实例时，返回True。
>>> class C1(object):pass ... >>> class C2(object):pass ... >>> c1 = C1() >>> c2 = C2() >>> isinstance(c1,C1) True >>> isinstance(c2,C1) False >>> isinstance(c1,(C1,C2)) True
super()函数可以简化搜索一个合适祖先的任务，并且调用它时，替你传入实例或类型对象。事实上super()函数是一个工厂函数，它创造一个super object，为一个给定的类使用___mro__去查找相应的父类
class P(object): def foo(self): print ‘Hi, I am P-foo()‘ class C(P): def foo(self): super(C,self).foo() #调用父类的foo()方法 print ‘Hi, I am C-foo()‘
vars()和dir()相似，只是给定的对象参数都必须有一个__dict__属性。vars()返回一个字典，它包含了对象存储于其__dict__中的属性和值。如果没有给参数，它将显示包含本地名字空间的属性和值的字典，也就是locals()
>>> class C(object): ... pass ... >>> c = C() >>> c.foo = 100 >>> c.bar = ‘python‘ >>> c.__dict__ {‘foo‘: 100, ‘bar‘: ‘python‘} >>> vars(c) {‘foo‘: 100, ‘bar‘: ‘python‘}
标签：
原文地址：http://www.cnblogs.com/mrylong/p/5089677.html
