oop - Python中一个元类是什么?

  显示原文与译文双语对照的内容

什么是元类你将它们用于什么?

时间:

元类是类的类。 类定义了类的实例的行为方式,元类定义了类的行为方式。 类是元类的一个实例。

在 python 可以使用任意callables元类( 就像 Jerub ), 更有用的方法实际上是一个实际的类本身。 ''type'是 python 中常见的元类。 如果你想知道,'type'本身就是一个类,它是它自己的类型。 你将不能重新创建类似于 python'type'纯粹,但 python 欺骗一点点。 你真的想在 python 中创建你自己的元类。

元类最常用作为 class-factory 。 像通过调用类创建类的一个实例,python 通过调用元类创建一个新的类( 当它执行的时候'类'语句) 。 结合正常 __init____new__ 方法,因此元类允许你做'额外的东西'当创建一个类,如注册这个新类和一些注册表,甚至完全用别的东西代替类。

执行'class'语句时,python 首先将'class'语句的正文作为一个普通代码块执行。 生成的命名空间( 辞典) 包含class-to-be的属性。 元类是由观察的baseclasses class-to-be ( 元类继承),__metaclass__ 属性的class-to-be ( 如果有的话) 或者'__metaclass__'全局变量。 然后使用类的名称,基和属性调用元类来实例化它。

然而,元类定义一个类的类型,不仅仅是一个工厂,所以你可以做得更多。 例如你可以在元类上定义普通方法。 这些 metaclass-methods classmethods一样,在他们可以被称为类没有实例,但他们也不像classmethods在他们不能被称为类的一个实例。 type.__subclasses__() 是'type'元类的一个方法示例。 你还可以定义普通的'魔幻'方法,比如 __add____iter____getattr__,来实现或者改变类的行为方式。

下面是一些Fragment和Fragment的聚合示例:


def make_hook(f):
"""Decorator to turn 'foo' method into '__foo__'"""
 f.is_hook = 1
 return f

class MyType(type):
 def __new__(cls, name, bases, attrs):

 if name.startswith('None'):
 return None

 # Go over attributes and see if they should be renamed.
 newattrs = {}
 for attrname, attrvalue in attrs.iteritems():
 if getattr(attrvalue, 'is_hook', 0):
 newattrs['__%s__' % attrname] = attrvalue
 else:
 newattrs[attrname] = attrvalue

 return super(MyType, cls).__new__(cls, name, bases, newattrs)

 def __init__(self, name, bases, attrs):
 super(MyType, self).__init__(name, bases, attrs)

 # classregistry.register(self, self.interfaces)
 print"Would register class %s now." % self

 def __add__(self, other):
 class AutoClass(self, other):
 pass
 return AutoClass
 # Alternatively, to autogenerate the classname as well as the class:
 # return type(self.__name__ + other.__name__, (self, other), {})

 def unregister(self):
 # classregistry.unregister(self)
 print"Would unregister class %s now." % self

class MyObject:
 __metaclass__ = MyType


class NoneSample(MyObject):
 pass

# Will print"NoneType None"
print type(NoneSample), repr(NoneSample)

class Example(MyObject):
 def __init__(self, value):
 self.value = value
 @make_hook
 def add(self, other):
 return self.__class__(self.value + other.value)

# Will unregister the class
Example.unregister()

inst = Example(10)
# Will fail with an AttributeError
#inst.unregister()

print inst + inst
class Sibling(MyObject):
 pass

ExampleSibling = Example + Sibling
# ExampleSibling is now a subclass of both Example and Sibling (with no
# content of its own) although it will believe it's called 'AutoClass'
print ExampleSibling
print ExampleSibling.__mro__

将类作为对象

在理解元类之前,你需要在 python 中掌握类。 python 对从Smalltalk语言借用的类有一个非常独特的概念。

在大多数语言中,类只是描述如何生成对象的代码 Fragment 。 python 也是如此:


>>> class ObjectCreator(object):
... pass
... 

>>> my_object = ObjectCreator()
>>> print(my_object)
<__main__.ObjectCreator object at 0x8974f2c>

但类不仅仅是 python 中的。 类也是对象。

是,对象。

当你使用关键字 class 时,python 会执行它并创建一个对象。 指令


>>> class ObjectCreator(object):
... pass
... 

在内存中创建名为"ObjectCreator"的对象。

这个对象( 该类) ( 实例) 本身就是能够创建对象,这就是为什么它是一个类

但仍然是一个对象,因此:

  • 你可以将它分配给变量
  • 你可以复制它
  • 你可以向它添加属性
  • 你可以将它作为函数参数传递

比如:


>>> print(ObjectCreator) # you can print a class because it's an object
<class '__main__.ObjectCreator'>
>>> def echo(o):
... print(o)
... 
>>> echo(ObjectCreator) # you can pass a class as a parameter
<class '__main__.ObjectCreator'>
>>> print(hasattr(ObjectCreator, 'new_attribute'))
False
>>> ObjectCreator.new_attribute = 'foo' # you can add attributes to a class
>>> print(hasattr(ObjectCreator, 'new_attribute'))
True
>>> print(ObjectCreator.new_attribute)
foo
>>> ObjectCreatorMirror = ObjectCreator # you can assign a class to a variable
>>> print(ObjectCreatorMirror.new_attribute)
foo
>>> print(ObjectCreatorMirror())
<__main__.ObjectCreator object at 0x8997b4c>

动态创建类

由于类是对象,你可以随时创建它们,像任何对象一样。

首先,你可以使用 class 在函数中创建类:


>>> def choose_class(name):
... if name == 'foo':
... class Foo(object):
... pass
... return Foo # return the class, not an instance
... else:
... class Bar(object):
... pass
... return Bar
... 
>>> MyClass = choose_class('foo') 
>>> print(MyClass) # the function returns a class, not an instance
<class '__main__.Foo'>
>>> print(MyClass()) # you can create an object from this class
<__main__.Foo object at 0x89c6d4c>

但它不是那么动态的,因为你仍然需要自己编写整个类。

因为类是对象,它们必须由一些。

使用 class 关键字时,python 会自动创建这里对象。 但是与 python 中的大多数东西一样,它提供了一种手工执行它的方式。

还记得函数 type好旧函数让你知道对象是什么类型:?


>>> print(type(1))
<type 'int'>
>>> print(type("1"))
<type 'str'>
>>> print(type(ObjectCreator))
<type 'type'>
>>> print(type(ObjectCreator()))
<class '__main__.ObjectCreator'>

type web 具有完全不同的功能,它也可以动态创建类。 type 可以将类的描述作为参数,并返回一个类。

( 我知道,同样的函数可以有两个完全不同的使用,根据你传递给它的参数。 由于 python 中的向后兼容性,这是一个问题

type 以这种方式运行:


type(name of the class, 
 tuple of the parent class (for inheritance, can be empty), 
 dictionary containing attributes names and values)

比如:


>>> class MyShinyClass(object):
... pass

可以通过以下方式手动创建:


>>> MyShinyClass = type('MyShinyClass', (), {}) # returns a class object
>>> print(MyShinyClass)
<class '__main__.MyShinyClass'>
>>> print(MyShinyClass()) # create an instance with the class
<__main__.MyShinyClass object at 0x8997cec>

你会注意到,我们使用"myshinyclass"作为类的名称,作为变量来保存类引用。 它们可以是不同的,但是没有理由让事情复杂化。

type 接受字典来定义类的属性。 所以:


>>> class Foo(object):
... bar = True

可以转换为:


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

并用作普通类:


>>> print(Foo)
<class '__main__.Foo'>
>>> print(Foo.bar)
True
>>> f = Foo()
>>> print(f)
<__main__.Foo object at 0x8a9b84c>
>>> print(f.bar)
True

当然,你可以从它继承,所以:


>>> class FooChild(Foo):
... pass

将是:


>>> FooChild = type('FooChild', (Foo,), {})
>>> print(FooChild)
<class '__main__.FooChild'>
>>> print(FooChild.bar) # bar is inherited from Foo
True

最终你将想要向类添加方法。 只需定义具有适当签名的函数并将它的指定为属性。


>>> def echo_bar(self):
... print(self.bar)
... 
>>> FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar})
>>> hasattr(Foo, 'echo_bar')
False
>>> hasattr(FooChild, 'echo_bar')
True
>>> my_foo = FooChild()
>>> my_foo.echo_bar()
True

你可以看到我们的目的地: 在 python 中,类是对象,你可以动态地动态创建类。

这就是 python 在使用关键字 class 时做的事情,它使用一个元类。

什么是元类( 最终)

元类是创建类的'物料'。

定义类以创建对象,对?

但是我们知道 python 类是对象。

元类就是创建这些对象的对象。 它们是类类,你可以通过以下方式来绘制它们:


MyClass = MetaClass()
MyObject = MyClass()

你已经看到 type 允许你执行如下操作:


MyClass = type('MyClass', (), {})

因为函数 type 实际上是一个元类。 type 是元类 python 用来创建场景背后的所有类。

现在你想知道为什么它是用小写写的,而不是 type

嗯,我想这是与 str的一致性,创建字符串对象的类,以及创建整型对象的类。 type 只是创建类对象的类。

通过检查 __class__ 属性可以看到。

一切,我所说的一切都是 python 中的一个对象。 包括整型,字符串,函数和类。 所有这些都是对象。 它们都是从一个类创建的:


>>> age = 35
>>> age.__class__
<type 'int'>
>>> name = 'bob'
>>> name.__class__
<type 'str'>
>>> def foo(): pass
>>> foo.__class__
<type 'function'>
>>> class Bar(object): pass
>>> b = Bar()
>>> b.__class__
<class '__main__.Bar'>

现在,什么是 __class__的?


>>> age.__class__.__class__
<type 'type'>
>>> name.__class__.__class__
<type 'type'>
>>> foo.__class__.__class__
<type 'type'>
>>> b.__class__.__class__
<type 'type'>

所以,元类就是创建类对象的东西。

如果你愿意,你可以把它叫做'类工厂'。

type 是内置的元类 python 用法,当然,你可以创建自己的元类。

__metaclass__ 属性

你可以在编写类时添加 __metaclass__ 属性:


class Foo(object):
 __metaclass__ = something...
 [...]

如果这样做,python 将使用元类创建类 Foo

小心点,这很棘手。

首先写入 class Foo(object),但类对象 Foo 还没有在内存中创建。

python 将在类定义中查找 __metaclass__ 。 如果找到它,它将使用它创建对象类 Foo 。 如果没有,它将使用 type 创建类。

多次阅读。

当你执行以下操作时:


class Foo(Bar):
 pass

python 执行以下操作:

有在 Foo__metaclass__ 属性?

如果是的,在内存中创建一个类对象( 我说了一个类对象,在这里跟我呆在一起), 名声在 __metaclass__Foo 使用是什么。

如果 python 找不到 __metaclass__,它将在模块级别寻找 __metaclass__,并尝试执行相同的( 但只有那些不继承任何东西的类,基本上是old-style类) 。

如果它根本找不到任何 __metaclass__,它将使用 Bar ( 第一个父级的) 自己的元类( 可能是默认的type ) 来创建类对象。

在这里小心,__metaclass__ 属性将不会被继承,父( Bar.__class__ )的元类将是。 如果使用 Bar__metaclass__ 属性创建与 type()Bar ( 而不是 type.__new__() ), 子类不能继承行为。

现在最大的问题是,你可以在 __metaclass__ 中放入什么?

答案是:可以创建类的东西。

什么可以创建一个类? type,或者任何子类或者使用它的任何东西。

自定义元类

元类的主要目的是在创建类时自动改变类。

你通常对api执行这里操作,你希望在其中创建与当前上下文匹配的类。

想象一个愚蠢的例子,在这里你可以决定模块中的所有类都应该用大写字母写。 有几种方法可以做到这一点,但是一种方法是在模块级别设置 __metaclass__

这样,这个模块的所有类都会使用这个元类创建,我们只需要告诉元类将所有属性转换成大写。

幸运的是,__metaclass__ 实际上可以是任何可以调用的,它不需要是一个正式的类( 我知道,有些东西'类'在它的名称中不需要是类,go 。 但这很有用。

我们将从一个简单的例子开始,使用一个函数。


# the metaclass will automatically get passed the same argument
# that you usually pass to `type`
def upper_attr(future_class_name, future_class_parents, future_class_attr):
"""
 Return a class object, with the list of its attribute turned 
 into uppercase.
"""

 # pick up any attribute that doesn't start with '__' and uppercase it
 uppercase_attr = {}
 for name, val in future_class_attr.items():
 if not name.startswith('__'):
 uppercase_attr[name.upper()] = val
 else:
 uppercase_attr[name] = val

 # let `type` do the class creation
 return type(future_class_name, future_class_parents, uppercase_attr)

__metaclass__ = upper_attr # this will affect all classes in the module

class Foo(): # global __metaclass__ won't work with"object" though
 # but we can define __metaclass__ here instead to affect only this class
 # and this will work with"object" children
 bar = 'bip'

print(hasattr(Foo, 'bar'))
# Out: False
print(hasattr(Foo, 'BAR'))
# Out: True

f = Foo()
print(f.BAR)
# Out: 'bip'

现在,让我们完全一样,但是使用一个类作为元类:


# remember that `type` is actually a class like `str` and `int`
# so you can inherit from it
class UpperAttrMetaclass(type): 
 # __new__ is the method called before __init__
 # it's the method that creates the object and returns it
 # while __init__ just initializes the object passed as parameter
 # you rarely use __new__, except when you want to control how the object
 # is created.
 # here the created object is the class, and we want to customize it
 # so we override __new__
 # you can do some stuff in __init__ too if you wish
 # some advanced use involves overriding __call__ as well, but we won't
 # see this
 def __new__(upperattr_metaclass, future_class_name, 
 future_class_parents, future_class_attr):

 uppercase_attr = {}
 for name, val in future_class_attr.items():
 if not name.startswith('__'):
 uppercase_attr[name.upper()] = val
 else:
 uppercase_attr[name] = val

 return type(future_class_name, future_class_parents, uppercase_attr)

但这并不是真正的OOP 。 我们直接调用 type 并且不重写或者调用父 __new__ 。 我们来吧


class UpperAttrMetaclass(type): 

 def __new__(upperattr_metaclass, future_class_name, 
 future_class_parents, future_class_attr):

 uppercase_attr = {}
 for name, val in future_class_attr.items():
 if not name.startswith('__'):
 uppercase_attr[name.upper()] = val
 else:
 uppercase_attr[name] = val

 # reuse the type.__new__ method
 # this is basic OOP, nothing magic in there
 return type.__new__(upperattr_metaclass, future_class_name, 
 future_class_parents, uppercase_attr)

你可能已经注意到额外的参数 upperattr_metaclass 。 没有什么特别的: 方法总是将当前实例作为第一个参数接收。 就像你对普通方法的self

当然,我这里使用的名称很长,但对于 self 来说,所有的参数都有常规名称。 因此,真正的生产元类看起来像这样:


class UpperAttrMetaclass(type): 

 def __new__(cls, clsname, bases, dct):

 uppercase_attr = {}
 for name, val in dct.items():
 if not name.startswith('__'):
 uppercase_attr[name.upper()] = val
 else:
 uppercase_attr[name] = val

 return type.__new__(cls, clsname, bases, uppercase_attr)

通过使用 super,我们可以使它更加简洁,这将简化继承( 因为是的,你可以拥有元类,继承元类,从类型继承):


class UpperAttrMetaclass(type): 

 def __new__(cls, clsname, bases, dct):

 uppercase_attr = {}
 for name, val in dct.items():
 if not name.startswith('__'):
 uppercase_attr[name.upper()] = val
 else:
 uppercase_attr[name] = val

 return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr)

就是这样,没有更多关于元类的东西了。

使用元类代码的复杂性背后的原因不是因为元类,因为你通常使用元类 Twisted 东西依靠内省,操纵继承,var如 __dict__ 等等。

确,元类对做黑魔法特别有用,因此复杂的东西。 但它们本身很简单:

  • 拦截类创建
  • 修改类别
  • 返回修改后的类

为什么你要使用元类类而不是函数?

既然 __metaclass__ 可以接受任何调用,为什么你会使用一个类,因为它显然更复杂?

这样做有几个原因:

  • 意图是明确的。当你阅读 UpperAttrMetaclass(type) 时,你会知道接下来会发生什么
  • 你可以使用 OOP 。元类可以继承元类,重写父方法。 元类甚至可以使用元类。
  • 你可以更好地构造代码。 你从不使用元类,比如上面的示例。 通常是为了复杂的事情。 能够在一个类中创建多个方法并将它们分组,这对使代码更易于阅读非常有用。
  • 你可以挂接 __new____init____call__ 。 这将允许你做不同的事情。 即使你通常都能在 __new__ 中做到这一点,但有些人使用 __init__ 更舒服。
  • 这些叫做元类,该死的 ! 这一定意味着什么 !

为什么你要使用元类?

现在最大的问题是,为什么你要使用一些容易出错的特性?

通常情况下,你没有:

元类是一个比 99%的用户更深入的魔法。 如果你想知道你是否需要它们,你不需要( 真正需要他们的人确信他们需要他们,而不需要解释) 。

python 大师 Tim

元类的主要用例是创建一个 API 。 一个典型的例子是 Django ORM 。

它允许你定义类似这样的东西:


class Person(models.Model):
 name = models.CharField(max_length=30)
 age = models.IntegerField()

但如果你这样做:


guy = Person(name='bob', age='35')
print(guy.age)

它不会返回 IntegerField 对象。 它将返回一个 int,甚至可以直接从数据库中获取。

这是可能的,因为 models.Model 定义了 __metaclass__,它使用了一些魔术,将你刚才用简单语句定义的Person 转换成一个数据库字段的复杂钩子。

通过公开一个简单的API和使用元类,重新创建代码来完成幕后的真正任务,Django使得一些复杂的东西看起来很简单。

最后一个词

首先,你知道类是可以创建实例的对象。

实际上,类本身就是实例。 元类。


>>> class Foo(object): pass
>>> id(Foo)
142630324

所有东西都是 python 中的一个对象,它们都是类或者元类实例的实例。

除了 type

type 实际上是它自己的元类。 这不是在纯 python 中重现的,它是通过在实现级别上欺骗来实现的。

其次,元类很复杂。你可能不想将它们用于非常简单的类修改。 你可以使用两种不同的技术来更改类:

99%需要类更改的时间,最好使用这些。

但是 99%的时间,你根本不需要类修改。

元类是使'类'工作的秘方。 一个新样式对象的默认元类叫做'类型'。


class type(object)
 | type(object) -> the object's type
 | type(name, bases, dict) -> a new type

元类接受 3个参数。'','基准'和''

这是秘密开始的地方。 查找这个示例类定义中的名称,base和 dict 。


class ThisIsTheName(Bases, Are, Here):
 All_the_code_here
 def doesIs(create, a):
 dict

让我们定义一个元类,它演示了': '调用它。


def test_metaclass(name, bases, dict):
 print 'The Class Name is', name
 print 'The Class Bases are', bases
 print 'The dict has', len(dict), 'elems, the keys are', dict.keys()

 return"yellow"

class TestName(object, None, int, 1):
 __metaclass__ = test_metaclass
 foo = 1
 def baz(self, arr):
 pass

print 'TestName = ', repr(TestName)

# output => 
The Class Name is TestName
The Class Bases are (<type 'object'>, None, <type 'int'>, 1)
The dict has 4 elems, the keys are ['baz', '__module__', 'foo', '__metaclass__']
TestName = 'yellow'

现在,一个例子,实际上意味着什么,这将自动使列表中的变量"属性"上设置的类,并设置为none。


def init_attributes(name, bases, dict):
 if 'attributes' in dict:
 for attr in dict['attributes']:
 dict[attr] = None

 return type(name, bases, dict)

class Initialised(object):
 __metaclass__ = init_attributes
 attributes = ['foo', 'bar', 'baz']

print 'foo =>', Initialised.foo
# output=>
foo => None

注意,'Initalised'通过 init_attributes 获得的魔力行为并没有传递到Initalised的子类。

这是一个更具体的例子,说明你可以子类'类型'让一个元类创建类时执行一个操作。 这相当棘手:


class MetaSingleton(type):
 instance = None
 def __call__(cls, *args, **kw):
 if cls.instance is None:
 cls.instance = super(MetaSingleton, cls).__call__(*args, **kw)
 return cls.instance

 class Foo(object):
 __metaclass__ = MetaSingleton

 a = Foo()
 b = Foo()
 assert a is b

元类的一个用途是自动向实例添加新属性和方法。

例如如果你查看 Django模型,它们的定义看起来有点混乱。 看起来你只是在定义类属性:


class Person(models.Model):
 first_name = models.CharField(max_length=30)
 last_name = models.CharField(max_length=30)

然而,在运行时,Person对象被各种有用的方法填充。 查看,获得一些令人惊奇的metaclassery 。

我认为对元类编程的ONLamp介绍已经编写好了,并给出了一个非常好的介绍,尽管已经有几年了。

http://www.onlamp.com/pub python/1 2003/04/17 1/metaclasses. html

简而言之:类是创建实例的蓝图,元类是创建类的蓝图。 可以很容易地看到,在 python 类中,需要成为一流的对象来启用这种行为。

我自己从来没有写过,但是我认为元类最好的用法之一可以在 Django框架中看到。 模型类使用元类方法来启用编写新模型或者表单类的声明式样式。 当元类创建类时,所有成员都可以自定义类本身。

要说的是: 如果你不知道什么是元类,的概率你是 99%不需要他们。

其他人解释了元类如何工作以及它们如何适应 python 类型系统。 下面是他们可以用来做什么的例子。 在我编写的测试框架中,我想跟踪类定义的顺序,这样以后就可以按照这个顺序实例化它们。 我发现使用一个元类来做到这一点最简单。


class MyMeta(type):

 counter = 0

 def __init__(cls, name, bases, dic):
 type.__init__(cls, name, bases, dic)
 cls._order = MyMeta.counter
 MyMeta.counter += 1

class MyType(object):

 __metaclass__ = MyMeta

任何是 MyType 子类的类都会得到一个类属性 _order,它记录类的定义顺序。

我读过的最好的元类解释是"元类阐释" http://cleverdevil.org/computing/78/,它最初出现在 python 杂志中。

编辑:这里是一个存档版本,直到 乔纳森的站点被修复:

http://web.archive.org/web/20120503014702/http://cleverdevil.org/computing/78/

我有一个非常复杂的问题,可能是用不同的方法解决的,但是我选择用一个元类来解决它。 由于复杂性,它是为数不多的模块我已经写在模块中的注释超过编写的代码的数量。 在这里。。


#!/usr/bin/env python

# Copyright (C) 2013-2014 Craig Phillips. All rights reserved.

# This requires some explaining. The point of this metaclass excercise is to
# create a static abstract class that is in one way or another, dormant until
# queried. I experimented with creating a singlton on import, but that did
# not quite behave how I wanted it to. See now here, we are creating a class
# called GsyncOptions, that on import, will do nothing except state that its
# class creator is GsyncOptionsType. This means, docopt doesn't parse any
# of the help document, nor does it start processing command line options.
# So importing this module becomes really efficient. The complicated bit
# comes from requiring the GsyncOptions class to be static. By that, I mean
# any property on it, may or may not exist, since they are not statically
# defined; so I can't simply just define the class with a whole bunch of
# properties that are @property @staticmethods.
#
# So here's how it works:
#
# Executing 'from libgsync.options import GsyncOptions' does nothing more
# than load up this module, define the Type and the Class and import them
# into the callers namespace. Simple.
#
# Invoking 'GsyncOptions.debug' for the first time, or any other property
# causes the __metaclass__ __getattr__ method to be called, since the class
# is not instantiated as a class instance yet. The __getattr__ method on
# the type then initialises the class (GsyncOptions) via the __initialiseClass
# method. This is the first and only time the class will actually have its
# dictionary statically populated. The docopt module is invoked to parse the
# usage document and generate command line options from it. These are then
# paired with their defaults and what's in sys.argv. After all that, we
# setup some dynamic properties that could not be defined by their name in
# the usage, before everything is then transplanted onto the actual class
# object (or static class GsyncOptions).
#
# Another piece of magic, is to allow command line options to be set in
# in their native form and be translated into argparse style properties.
#
# Finally, the GsyncListOptions class is actually where the options are
# stored. This only acts as a mechanism for storing options as lists, to
# allow aggregation of duplicate options or options that can be specified
# multiple times. The __getattr__ call hides this by default, returning the
# last item in a property's list. However, if the entire list is required,
# calling the 'list()' method on the GsyncOptions class, returns a reference
# to the GsyncListOptions class, which contains all of the same properties
# but as lists and without the duplication of having them as both lists and
# static singlton values.
#
# So this actually means that GsyncOptions is actually a static proxy class...
#
#.. .And all this is neatly hidden within a closure for safe keeping.
def GetGsyncOptionsType():
 class GsyncListOptions(object):
 __initialised = False

 class GsyncOptionsType(type):
 def __initialiseClass(cls):
 if GsyncListOptions._GsyncListOptions__initialised: return

 from docopt import docopt
 from libgsync.options import doc
 from libgsync import __version__

 options = docopt(
 doc.__doc__ % __version__,
 version = __version__,
 options_first = True
 )

 paths = options.pop('<path>', None)
 setattr(cls,"destination_path", paths.pop() if paths else None)
 setattr(cls,"source_paths", paths)
 setattr(cls,"options", options)

 for k, v in options.iteritems():
 setattr(cls, k, v)

 GsyncListOptions._GsyncListOptions__initialised = True

 def list(cls):
 return GsyncListOptions

 def __getattr__(cls, name):
 cls.__initialiseClass()
 return getattr(GsyncListOptions, name)[-1]

 def __setattr__(cls, name, value):
 # Substitut option names: --an-option-name for an_option_name
 import re
 name = re.sub(r'^__',"", re.sub(r'-',"_", name))
 listvalue = []

 # Ensure value is converted to a list type for GsyncListOptions
 if isinstance(value, list):
 if value:
 listvalue = [] + value
 else:
 listvalue = [ None ]
 else:
 listvalue = [ value ]

 type.__setattr__(GsyncListOptions, name, listvalue)

 # Cleanup this module to prevent tinkering.
 import sys
 module = sys.modules[__name__]
 del module.__dict__['GetGsyncOptionsType']

 return GsyncOptionsType

# Our singlton abstract proxy class.
class GsyncOptions(object):
 __metaclass__ = GetGsyncOptionsType()

...