python实现restful api链式调用

最新推荐文章于 2024-08-08 16:43:27 发布

lvhdbb

最新推荐文章于 2024-08-08 16:43:27 发布

阅读量819

点赞数

文章标签： rest api 链式调用 python

getattr

正常情况下，当我们调用类的方法或属性时，如果不存在，就会报错。比如定义Student类：

class Student(object):
    
    def __init__(self):
        self.name = 'Michael'

调用name属性，没问题，但是，调用不存在的score属性，就有问题了：

>>> s = Student()
>>> print(s.name)
Michael
>>> print(s.score)
Traceback (most recent call last):
  ...
AttributeError: 'Student' object has no attribute 'score'

错误信息很清楚地告诉我们，没有找到score这个attribute。

要避免这个错误，除了可以加上一个score属性外，Python还有另一个机制，那就是写一个__getattr__()方法，动态返回一个属性。修改如下：

class Student(object):

    def __init__(self):
        self.name = 'Michael'

    def __getattr__(self, attr):
        if attr=='score':
            return 99

当调用不存在的属性时，比如score，Python解释器会试图调用__getattr__(self, 'score')来尝试获得属性，这样，我们就有机会返回score的值：

>>> s = Student()
>>> s.name
'Michael'
>>> s.score
99

返回函数也是完全可以的：

class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25

只是调用方式要变为：

>>> s.age()
25

注意，只有在没有找到属性的情况下，才调用__getattr__，已有的属性，比如name，不会在__getattr__中查找。

此外，注意到任意调用如s.abc都会返回None，这是因为我们定义的__getattr__默认返回就是None。要让class只响应特定的几个属性，我们就要按照约定，抛出AttributeError的错误：

class Student(object):

    def __getattr__(self, attr):
        if attr=='age':
            return lambda: 25
        raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr)

这实际上可以把一个类的所有属性和方法调用全部动态化处理了，不需要任何特殊手段。

这种完全动态调用的特性有什么实际作用呢？作用就是，可以针对完全动态的情况作调用。

举个例子：

现在很多网站都搞REST API，比如新浪微博、豆瓣啥的，调用API的URL类似：

http://api.server/user/friends
http://api.server/user/timeline/list

如果要写SDK，给每个URL对应的API都写一个方法，那得累死，而且，API一旦改动，SDK也要改。

利用完全动态的__getattr__，我们可以写出一个链式调用：

class Chain(object):

    def __init__(self, path=''):
        self._path = path

    def __getattr__(self, path):
        return Chain('%s/%s' % (self._path, path))

    def __str__(self):
        return self._path

    __repr__ = __str__

试试：

>>> Chain().status.user.timeline.list
'/status/user/timeline/list'

这样，无论API怎么变，SDK都可以根据URL实现完全动态的调用，而且，不随API的增加而改变！

还有些REST API会把参数放到URL中，比如GitHub的API：

GET /users/:user/repos

调用时，需要把:user替换为实际用户名。如果我们能写出这样的链式调用：

Chain().users('michael').repos

就可以非常方便地调用API了。有兴趣的童鞋可以试试写出来。（思路见最后，不要偷看哦）

call

一个对象实例可以有自己的属性和方法，当我们调用实例方法时，我们用instance.method()来调用。能不能直接在实例本身上调用呢？在Python中，答案是肯定的。

任何类，只需要定义一个__call__()方法，就可以直接对实例进行调用。请看示例：

class Student(object):
    def __init__(self, name):
        self.name = name

    def __call__(self):
        print('My name is %s.' % self.name)

调用方式如下：

>>> s = Student('Michael')
>>> s() # self参数不要传入
My name is Michael.

__call__()还可以定义参数。对实例进行直接调用就好比对一个函数进行调用一样，所以你完全可以把对象看成函数，把函数看成对象，因为这两者之间本来就没啥根本的区别。

如果你把对象看成函数，那么函数本身其实也可以在运行期动态创建出来，因为类的实例都是运行期创建出来的，这么一来，我们就模糊了对象和函数的界限。

那么，怎么判断一个变量是对象还是函数呢？其实，更多的时候，我们需要判断一个对象是否能被调用，能被调用的对象就是一个Callable对象，比如函数和我们上面定义的带有__call__()的类实例：

>>> callable(Student())
True
>>> callable(max)
True
>>> callable([1, 2, 3])
False
>>> callable(None)
False
>>> callable('str')
False

通过callable()函数，我们就可以判断一个对象是否是“可调用”对象。

思路：

实现Chain().users('michael').repos输出/users/michael/repos

无图无真相，上代码：

class Chain(object):
    def __init__(self, path=''):
       self.__path = path

   def __getattr__(self, path):
       return Chain('%s/%s' % (self.__path, path))

   def __call__(self, path):
       return Chain('%s/%s' % (self.__path, path))

   def __str__(self):
       return self.__path

   __repr__ = __str__

   print(Chain().users('michael').repos) # /users/michael/repos

来来回回看了好几天，总算是有点理解。（每天在脑子最清醒的时候返回来学最困惑的）

Chain().users('michael').repos这是一串什么东西，链式调用？没学过，分分钟想跳过看下一章。

分解成能看懂的：

urls = Chain()    # 初始化一个实例
urls = urls.users    # 查找实例的一个属性
urls = urls('michael)    # 调用一个函数
urls = urls.repos    # 还是实例的属性

还原成常规方式就成了最基础的东西。

1.第一步

urls = Chain()

初始化一个实例，此时urls等于，因为定义了默认值path=''；

2.第二步

urls = urls.users

查找urls的属性users，没找到定义的属性，那就调用__getattr__方法，返回了一个函数调用：

def __getattr__(self, users):
    return Chain('%s/%s' % (self.__path, users))

这一步调用了Chain()，而且把要查找的属性users作为参数传递了进去，也就是Chain(users),那么根据Chain()的逻辑，最后返回的是：/users，然后跟上一步的结果拼接，最终返回：/users；

3.第三步

urls = urls('michael')

每次迷茫都在这一步。举例子理解一下：

f = abs
print(f.__name__)    # 'abs'
print(f(-123))    # 123
print(callable(f))    # True

由于f可以被调用，那就可以称：f为可调用对象；

def func():
    pass

print(callable(func))    # True

函数本身就可以被调用，这点无需质疑，所以函数也是可调用对象；

class Test(object):
    def __init__(self):
    pass

print(callable(Test))    # True

类本身也是可调用对象，不然怎么生成实例化对象；

class Test(object):
    def __init__(self):
    pass

test = Test()
print(callable(test))    # False

咦？发现个不一样的，类的实例化对象不可以被调用，那它就仅仅只是个纯粹的对象了；

终于对课程上描述__call__的话有所理解了， 对实例进行直接调用就好比对一个函数进行调用一样，所以你完全可以把对象看成函数，把函数看成对象，因为这两者之间本来就没啥根本的区别。

你把对象看成函数，那么函数本身其实也可以在运行期动态创建出来，因为类的实例都是运行期创建出来的，这么一来，我们就模糊了对象和函数的界限。 原来是为了让实例化对象和函数一样可以被使用；

那这一步就简单了，可以抽象的理解为：

class urls(Chain):
    def __init__(self, path='/users'):
       self.__path = path

   def __getattr__(self, path):
       return urls(('%s/%s' % (self.__path, path)))

    def __call__(self, path):
       return urls(('%s/%s' % (self.__path, path)))

   def __str__(self):
       return self.__path

   __repr__ = __str__

然后调用urls = urls('michael')，那么最终返回：/users/michael

4.最后一步