400-616-5551

您所在位置: 首页> 学习课程> python装饰器有哪些作用?python特性你知道多少?

python装饰器有哪些作用?python特性你知道多少?

发布百知教育 来源:学习课程 2019-10-11

实际上,在日常的工作中,我们很多需求,无论是常见的、还是不常见的,Python 都为我们提供了一些独特的解决方案,既不需要自己造轮子,也不需要引入新的依赖(引入新的依赖势必会增加项目的复杂度)。

但是 Python 有太多功能和特性被我们忽略了,导致我们在遇到问题的时候,没法第一时间作出良好的决策。

所以,干脆来一起扫清这些被我们忽略的 Python 死角。

装饰器的妙用

我们经常会想完成一些注册&调用的功能,比如我们有四个函数:

  1. def add(a: int, b: int) -> float:

  2.    return a + b



  3. def sub(a: int, b: int) -> float:

  4.    return a - b



  5. def mul(a: int, b: int) -> float:

  6.    return a * b



  7. def div(a: int, b: int) -> float:

  8.    return a / b


现在我们想将这四个函数和 +、-、*、/ 四个操作符绑定,那么我们该怎么做?

可能我们第一反应是这样:

  1. operator_map = {}



  2. def add(a: int, b: int) -> float:

  3.    return a + b



  4. def sub(a: int, b: int) -> float:

  5.    return a - b



  6. def mul(a: int, b: int) -> float:

  7.    return a * b



  8. def div(a: int, b: int) -> float:

  9.    return a / b



  10. operator_map["+"] = add


  11. operator_map["-"] = sub


  12. operator_map["*"] = mul


  13. operator_map["/"] = div

但这样写起来,有一个很大的问题就是太不美观了。因为直接对于 dict 的操作从实际上来讲可维护性是很差的,那么我们这个地方应该怎么做?

在改进这段代码之前,我们首先要明确 Python 中一个很重要的概念,即:函数/方法是:First Class Member 。用不精确的话来讲,就是函数/方法可以作为参数被传递、被使用。

举个例子:

  1. import typing



  2. def execute(func: typing.Callable, *args, **kwargs) -> typing.Any:

  3.    return func(*args, **kwargs)



  4. def print_func(data: int) -> None:

  5.    print(data)



  6. execute(print, 2)

大家可以看到我们将 print_func 这个函数作为参数传递给 execute 函数并被调用。

那么我们来改造下之前的代码:

  1. import typing


  2. operator_map = {}



  3. def add(a: int, b: int) -> float:

  4.    return a + b



  5. def sub(a: int, b: int) -> float:

  6.    return a - b



  7. def mul(a: int, b: int) -> float:

  8.    return a * b



  9. def div(a: int, b: int) -> float:

  10.    return a / b



  11. def register_operator(operator: str, func: typing.Callable) -> None:

  12.    operator_map[operator] = func



  13. register_operator("+", add)

  14. register_operator("-", sub)

  15. register_operator("*", mul)

  16. register_operator("/", div)


好了,大家看看,目前整体代码的可读性以及可维护性是不是改了很多?

但是我们现在的问题在于,每次都需要在单独调用一次 register_operator 函数,这样也太烦了吧!要不要再改进一下?要得。我们可以用装饰器来改进一下。

首先,看一个最简单的装饰器例子:

  1. import functools

  2. import typing

  3. import time



  4. def execute(func: typing.Callable) -> typing.Callable:

  5.    @functools.wraps(func)

  6.    def wraps(*args, **kwargs) -> typing.Any:

  7.        start_time = time.time()

  8.        result = func(*args, **kwargs)

  9.        print("{}".format(time.time() - start_time))

  10.        return result


  11.    return wraps



  12. @execute

  13. def add(a: int, b: int) -> float:

  14.    return a + b

我们能看到这段函数的意义是计算函数的执行时间。那么这个原理是什么?

实际上装饰器是一个语法糖,具体可以参见 PEP318 Decorators for Functions and Methods。

简而言之,实际上是 Python 替我们做了一个替换过程。以上面的例子为例,这个替换过程就是 add=execute(add) 。

好了,我们就用这个知识点来改进下之前的代码:

  1. import typing


  2. operator_map = {}



  3. def register_operator(operator: str) -> typing.Callable:

  4.    def wraps(func: typing.Callable) -> typing.Callable:

  5.        operator_map[operator] = func

  6.        return func


  7.    return wraps



  8. @register_operator("+")

  9. def add(a: int, b: int) -> float:

  10.    return a + b



  11. @register_operator("-")

  12. def sub(a: int, b: int) -> float:

  13.    return a - b



  14. @register_operator("*")

  15. def mul(a: int, b: int) -> float:

  16.    return a * b



  17. @register_operator("/")

  18. def div(a: int, b: int) -> float:

  19.    return a / b

这样我们这段代码的注册过程是不是就显得更优雅了?
嗯,是的!实际上 Python 中有很多特性会帮助我们的代码更简洁,更优美。
接下来这个例子很可能帮我们减轻工作量。

聊聊 OrderedDict

dict 是我们经常使用的一种数据解构。但是在 Python 3.6 之前 dict 都是无序的,即我插入的顺序,和数据在 dict 中存放的顺序并无关联(笔者注:Python 3.6 dict 有序只是新版实现的顺带产物,Python 3.7 正式作为 feature 被固定下来)。
但是很多时候,比如在验签等场景,我们需要保证 dict 数据存放顺序,和我们插入顺序是一致的。那么我们该怎么办?
老板有需求下来了,我们肯定不能告诉老板这个需求没法做。那我们就自己实现一个ordereddict 吧。于是,想了想,写了如下的代码:

  1. import typing



  2. class OrderedDict:

  3.    def __init__(self, *args, **kwargs):

  4.        self._data = {}

  5.        self._ordered_key = []


  6.    def __getitem__(self, key: typing.Any) -> typing.Any:

  7.        return self._data[key]


  8.    def __setitem__(self, key: typing.Any, value: typing.Any) -> None:

  9.        if key not in self._data:

  10.            return

  11.        self._data[key] = value

  12.        self._ordered_key.append(key)


  13.    def __delitem__(self, key: typing.Any):

  14.        del self._data[key]

  15.        self._ordered_key.remove(key)

通过额外维护一个 list 来维护 key 插入的顺序。这段代码,看似完成了我们的需求,但是实则存在很大问题。大家可以猜猜问题在哪?

3,2,1!

揭晓答案,这段代码利用 list 来保证 key 的有序性,在删除的时候, list 的删除操作,是一个时间复杂度 O(n) 的操作。换句话说,我们的删除操作随着内部数据的增多,所需的删除时间也变得越长。这对于某些性能敏感的场景是无法接受的。

那要怎么办呢?事实上,Python 在很早之前就已经内置了有序字典,即很多人可能都用过的 collections.OrderedDict 。

 OrderedDict 中, Python 维护了一个双向链表解构,来保证插入的有序性,如下图所示:


python培训



在最左侧维护一个卫兵节点,卫兵节点的 next 指针恒指向于数据中最后插入的节点。那么插入新的数据时,我们将新的数据插入到卫兵节点之后,从而达成维护插入顺序的目的。

在删除的时候,通过额外维护的一个字典找到待删除的 key 所对应的节点。这个操作是 O(1) 的复杂度,然后大家都知道,双向链表删除一个节点的时间复杂度也是 O(1) 。通过这样保证我们在即便有大量数据的情况下,也能保证相应的性能。
好了,我们按照这个思路来做一个最简单的实现:

  1. import typing



  2. class Node:

  3.    def __init__(self, key: typing.Any, value: typing.Any) -> None:

  4.        self.key = key

  5.        self.value = value

  6.        self.prev = None

  7.        self.next = None



  8. class OrderedDict:

  9.    def __init__(self, *args, **kwargs):

  10.        self._data = {}

  11.        self._head = Node(None, None)

  12.        self._last = self._head


  13.    def __getitem__(self, key: typing.Any) -> typing.Any:

  14.        if key in self._data:

  15.            return self._data[key].value

  16.        raise ValueError


  17.    def __setitem__(self, key: typing.Any, value: typing.Any) -> None:

  18.        if key not in self._data:

  19.            return

  20.        value_node = Node(key, value)

  21.        next_node = self._head.next

  22.        if not next_node:

  23.            self._head.next = value_node

  24.            value_node.prev = self._head

  25.            self._last = value_node

  26.        else:

  27.            value_node.next = next_node

  28.            next_node.prev = value_node

  29.            value_node.prev = self._head

  30.            self._head.next = value_node

  31.        self._data[key] = value_node


  32.    def __delitem__(self, key: typing.Any):

  33.        if key not in self._data:

  34.            return

  35.        value_node = self._data[key]

  36.        if value_node == self._last:

  37.            self._last = value_node.prev

  38.            self._last.next = None

  39.        else:

  40.            prev_node = value_node.prev

  41.            next_node = value_node.next

  42.            prev_node.next = next_node

  43.            next_node.prev = prev_node

  44.        del self._data[key]

  45.        del value_node

(此段代码,如有错乱,烦请将浏览字体调小几号)

这只是一个 OrderedDict 的简化版,如果想完成一个完整的 OrderedDict 还有很多很多的 corner case 要去处理。不过现在,我们可以使用内置的数据结构去完成我们需求。怎么样,是不是有了一种幸福的感觉?


python培训:http://www.baizhiedu.com/python2019

上一篇:0础自学Python难吗?有哪些快速入门的秘籍?

下一篇:应届生去公司找个Java程序员的职位需要什么技能?

相关推荐

www.baizhiedu.com

有位老师想和您聊一聊

关闭

立即申请