在类上调用任意方法，如 xmlrpclib.ServerProxy

Question

我有一个远程 api，只接受可能被称为类似的 XML

api = xmlrpclib.ServerProxy(IP)
result = api.Execute({"Method": 'Method_name', "Params": [P1, P2],
                      ...  # technical values - authentication, etc
                      })

技术值不会经常更改 - 整个脚本通常会为它们使用相同的值，因此我创建了一个具有方法的类

def call(self, method_name, params):
    self.api.Execute(<constructed dictionary>)

我想知道是否可以将这些方法直接调用为self.api 的方法，例如：

self.api.method_name(params)

这将依次填写.Execute 和我的其余部分，总体思路如下：

def __getattr__(self, item):
    if item in self.__dict__:
        return self.item
    else:
        return functools.partial(self.call, method_name=item)

所以，如果我在类中定义了一个方法（self.foo、self.bar 等）——调用它会产生self.foo 和self.bar 的真实结果。

像self.api.METHOD(params) 这样调用它，其中METHOD 是一个自定义的方法，但是这种方法“污染”了我没有定义的其他方法，比如self.api.__repr__ 等等

根据this question，我覆盖__getitem__ 的方法是否完全不正确？如果是这样 - 我应该如何实施？

Answer 1

我最近看了a talk by Raymond Hettinger，这篇文章让我想起了这个帖子，所以我想我会链接到它。我认为这为您在帖子中描述的方法提供了一个很好的论据：

让 API 为您服务

首先，我认为覆盖 __getattr__ 并不像那篇帖子可能让你相信的那样有罪。

class MyAPI(object):
  base_args = {'token': 'foobarauthtoekn'}

  def __init__(self, ip):
    self._api = ServerProxy(ip)

  def _execute(self, method='', **kwargs):
    argdict = {'Method': method}
    argdict.update(MyAPI2.base_args)
    argdict.update(kwargs)
    self._api.Execute(argdict)

  def __getattr__(self, attr):
    return self.__dict__.get(
      attr, partial(self._execute, method=attr))


api = MyAPI('127.0.0.1')

# Execute({'token': ..., 'Method': 'get_users', 'arg1': 'foo' ...}) =
api.get_users(arg1='foo', arg2='bar')

# Execute({'token': ..., 'Method': 'get_data', 'foo': 'stuff' ...}) =
api.get_data(foo='stuff', bar='zxcv')

我喜欢这个，因为它的代码不多，而且它让我们可以更方便地使用Execute（使用关键字 args），而无需依赖内部 API 的支持。

通过元类的特殊行为

另一种方法可以防止我们不得不重写__getattr__，以防我低估了它的错误程度，而且它也可以被认为是更pythonic，因为我们明确列举了我们将提供的方法API 包装器：

class APIMeta(type):
  def __new__(cls, clsname, bases, attrs):

    def exec_generic(name):
      base_args = {'token': 'foobarauthtoekn'}
      def exec_wrapper(self, params):
        args = {'Method': name}
        args.update(base_args)
        args.update(params)
        return self._api.Execute(args)
      return exec_wrapper

    new_attrs = {
      name: val if name.startswith('__') else exec_generic(name)
      for name, val in attrs.items() }

    return super(APIMeta, cls).__new__(cls, clsname, bases, new_attrs)

class MyAPI(object, metaclass=APIMeta):
  def __init__(self, ip):
    self._api = ServerProxy(ip)

  def get_users(self):
    pass

  def get_data(self):
    pass

  # ...

实际上，我不喜欢这样，因为它只不过是一种非常复杂的写作方式：

class MyAPI(object):
  _base_args = {'token': 'foobarauthtoken'}

  def __init__(self, ip):
    self._api = ServerProxy(ip)

  def get_users(self, params):
    argdict = {'Method': 'get_users'}
    argdict.update(MyAPI._base_args)
    argdict.update(params)
    return self._api.Execute(argdict)

  # ...

如果你有很多方法，它会为你节省大量的打字时间，如果你想深入了解或加深对 python 语言的理解，这也是元编程的好习惯。

Here's 两者都有的演示。