#tests1.py

class MyClass(object):

    def foo(self):

        print('MyClass.foo')

my_class_obj=MyClass()

from .tests1 import my_class_obj

my_class_obj.foo()

class MyClass(object):

    _instance = None

    def __new__(cls, *args, **kwargs):

        if not cls._instance:

            cls._instance = super(MyClass, cls).__new__(cls, *args, **kwargs)

        return cls._instance

class HerClass(MyClass):

    a = 1

one = HerClass()

two = HerClass()

print(one == two)   #True

print(one is two)   #True

print(id(one), id(two)) #42818864 42818864

 from functools import wraps

 def singleton(cls):

     instances = {}

     @wraps(cls)

     def getinstance(*args, **kwargs):

         if cls not in instances:

             instances[cls] = cls(*args, **kwargs)

         return instances[cls]

     return getinstance

 @singleton

 class MyClass(object):

     a = 1

class Singleton(type):

    _instances = {}

    def __call__(cls, *args, **kwargs):

        if cls not in cls._instances:

            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)

        return cls._instances[cls]

# Python2

# class MyClass(object):

#     __metaclass__ = Singleton

# Python3

class MyClass(metaclass=Singleton):

   pass

补充：元类(metaclass)

类也是对象

只要你使用关键字class，Python解释器在执行的时候就会创建一个对象。

下面的代码段：

class MyClass(object):

    pass

将在内存中创建一个对象，名字就是MyClass。这个对象（类）自身拥有创建对象（类实例）的能力，而这就是为什么它是一个类的原因。但是，它的本质仍然是一个对象，于是乎你可以对它做如下的操作：

1)   你可以将它赋值给一个变量

2)   你可以拷贝它

3)   你可以为它增加属性

4)   你可以将它作为函数参数进行传递

 class MyClass(object):

     pass

 print(MyClass)     # 你可以打印一个类，因为它其实也是一个对象

 # <class '__main__.MyClass'>

 def echo(o):

     print(o)

 echo(MyClass)       # 你可以将类做为参数传给函数

 # <class '__main__.MyClass'>

 MyClass.new_attribute = 'foo'   #  你可以为类增加属性

 print(hasattr(MyClass,'new_attribute')) #True

 print(MyClass.new_attribute)    #foo

 MyClassMirror=MyClass　　　　# 你可以将类赋值给一个变量

 print(MyClassMirror())

 # <__main__.MyClass object at 0x00000000028CDE10>

动态地创建类

因为类也是对象，你可以在运行时动态的创建它们，就像其他任何对象一样。首先，你可以在函数中创建类，使用class关键字即可。

def choose_class(name):

    if name == 'foo':

        class Foo(object):

            pass

        return Foo  # 返回的是类，不是类的实例

    else:

        class Bar(object):

            pass

        return Bar

MyClass = choose_class('foo')

print(MyClass)      # 函数返回的是类，不是类的实例

# <class '__main__.choose_class.<locals>.Foo'>

print(MyClass())    # 你可以通过这个类创建类实例，也就是对象

# <__main__.choose_class.<locals>.Foo object at 0x00000000021E5CF8>

但这还不够动态。

由于类也是对象，所以它们必须是通过什么东西来生成的才对。

还记得内建函数type吗？这个古老但强大的函数能够让你知道一个对象的类型是什么，就像这样：

print(type(1))          #<class 'int'>

print(type(''))        #<class 'str'>

print(type(MyClass))    #<class 'type'>

print(type(MyClass()))  #<class '__main__.MyClass'>

type也能动态的创建类。

type可以像这样工作：

type(类名, 父类的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）)

比如下面的代码：

class MyShinyClass(object):

    pass

可以手动像这样创建：

MyShinyClass=type('MyShinyClass',(),{})     # 返回一个类对象

print(MyShinyClass)

# <class '__main__.MyShinyClass'>

print(MyShinyClass())   #  创建一个该类的实例

# <__main__.MyShinyClass object at 0x0000000002737D68>

type 接受一个字典来为类定义属性，因此：

class Foo(object):

    bar=True

可以翻译为：

Foo = type('Foo', (), {'bar':True})

并且可以将Foo当成一个普通的类一样使用：

class Foo(object):

    bar=True

print(Foo)      #<class '__main__.Foo'>

print(Foo.bar)  #True

f=Foo()

print(f)        #<__main__.Foo object at 0x0000000001F7DE10>

print(f.bar)    #True

当然，你可以向这个类继承，所以，如下的代码：

class FooChild(Foo):

    pass

就可以写成：

class Foo(object):

    bar=True

FooChild = type('FooChild', (Foo,),{})

print(FooChild)

# <class '__main__.FooChild'>

print(FooChild.bar)     # bar属性是由Foo继承而来

# True

最终你会希望为你的类增加方法。只需要定义一个有着恰当签名的函数并将其作为属性赋值就可以了。

class Foo(object):

    bar=True

def echo_bar(self):

    print(self.bar)

FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})

print(hasattr(Foo, 'echo_bar'))         #False

print(hasattr(FooChild, 'echo_bar'))    #True

my_foo = FooChild()

my_foo.echo_bar()   #True

你可以看到，在Python中，类也是对象，你可以动态的创建类。这就是当你使用关键字class时Python在幕后做的事情，而这就是通过元类来实现的。

到底什么是元类

元类就是用来创建类的“东西”。元类就是类的类。

函数type实际上是一个元类。type就是Python在背后用来创建所有类的元类。

type就是创建类对象的类。你可以通过检查__class__属性来看到这一点。

Python中所有的东西，注意，我是指所有的东西——都是对象。这包括整数、字符串、函数以及类。它们全部都是对象，而且它们都是从一个类创建而来。

 age = 35

 print(age.__class__)    #<class 'int'>

 name = 'bob'

 print(name.__class__)   #<class 'str'>

 def foo():

     pass

 print(foo.__class__)    #<class 'function'>

 class Bar(object):

     pass

 b = Bar()

 print(b.__class__)      #<class '__main__.Bar'>

现在，对于任何一个__class__的__class__属性又是什么呢？

print(age.__class__.__class__)  #<class 'type'>

print(name.__class__.__class__) #<class 'type'>

print(foo.__class__.__class__)  #<class 'type'>

print(b.__class__.__class__)    #<class 'type'>

因此，元类就是创建类这种对象的东西。

type就是Python的内建元类，当然了，你也可以创建自己的元类。

__metaclass__属性

你可以在写一个类的时候为其添加__metaclass__属性。

class Foo(object):

    __metaclass__ = something...

如果你这么做了，Python就会用元类来创建类Foo。小心点，这里面有些技巧。你首先写下class Foo(object)，但是类对象Foo还没有在内存中创建。Python会在类的定义中寻找__metaclass__属性，如果找到了，Python就会用它来创建类Foo，如果没有找到，就会用内建的type来创建这个类。

当你写如下代码时 :

class Foo(Bar):

    pass

Python做了如下的操作：

Foo中有__metaclass__这个属性吗？如果是，Python会在内存中通过__metaclass__创建一个名字为Foo的类对象（我说的是类对象，请紧跟我的思路）。如果Python没有找到__metaclass__，它会继续在Bar（父类）中寻找__metaclass__属性，并尝试做和前面同样的操作。如果Python在任何父类中都找不到__metaclass__，它就会在模块层次中去寻找__metaclass__，并尝试做同样的操作。如果还是找不到__metaclass__,Python就会用内置的type来创建这个类对象。

现在的问题就是，你可以在__metaclass__中放置些什么代码呢？

答案就是：可以创建一个类的东西。那么什么可以用来创建一个类呢？type，或者任何使用到type或者子类化type的东东都可以。

内容：自定义元类、为什么要用metaclass类而不是函数?、究竟为什么要使用元类？

参考博文：http://blog.jobbole.com/21351/