Skip to main content

处理多层嵌套循环

list1 = range(1,3)
list2 = range(4,6)
list3 = range(7,9)

for item1 in list1:
    for item2 in list2:
        for item3 in list3:
              print(item1+item2+item3)

这里仅仅是三个 for 循环，在实际编码中，有可能会有更层。

  • 优化
from itertools import product

list1 = range(1,3)
list2 = range(4,6)
list3 = range(7,9)

for item1,item2,item3 in product(list1, list2, list3):
    print(item1+item2+item3)

计算函数运行时间

import time

start = time.time()

# run the function

end = time.time()
print(round(end-start, 3))
  • 优化
import time
import timeit

def run_sleep(second):
    print(second)
    time.sleep(second)

# 只用这一行
print(timeit.timeit(lambda :run_sleep(2), number=5))

内置的缓存 lru_cache

缓存是一种将定量数据加以保存，以备迎合后续获取需求的处理方式，旨在加快数据获取的速度。

数据的生成过程可能需要经过计算，规整，远程获取等操作，如果是同一份数据需要多次使用，每次都重新生成会大大浪费时间。所以，如果将计算或者远程请求等操作获得的数据缓存下来，会加快后续的数据获取需求。

为了实现这个需求，Python 3.2 + 中给我们提供了一个机制，可以很方便的实现，而不需要你去写这样的逻辑代码。

这个机制实现于 functool 模块中的 lru_cache 装饰器。

语法：

@functools.lru_cache(maxsize=None, typed=False)

参数解读：

  • maxsize：最多可以缓存多少个此函数的调用结果，如果为None，则无限制，设置为 2 的幂时，性能最佳
  • typed：若为 True，则不同参数类型的调用将分别缓存。

使用示例：

from functools import lru_cache

@lru_cache(None)
def add(x, y):
    print("calculating: %s + %s" % (x, y))
    return x + y

print(add(1, 2))
print(add(1, 2))
print(add(2, 3))

程序退出前执行代码

使用 atexit 这个内置模块，可以很方便的注册退出函数。

如果clean()函数有参数，那么你可以不用装饰器，而是直接调用atexit.register(clean_1, 参数1, 参数2, 参数3='xxx')。

可能你有其他方法可以处理这种需求，但肯定比上不使用 atexit 来得优雅，来得方便，并且它很容易扩展。

但是使用 atexit 仍然有一些局限性，比如：

  • 如果程序是被你没有处理过的系统信号杀死的，那么注册的函数无法正常执行。
  • 如果发生了严重的 Python 内部错误，你注册的函数无法正常执行。
  • 如果你手动调用了os._exit()，你注册的函数无法正常执行。

延迟调用机制​

import "fmt"

func myfunc() {
    fmt.Println("B")
}

func main() {
    defer myfunc()
    fmt.Println("A")
}

# A
# B
import contextlib

def callback():
    print('B')

with contextlib.ExitStack() as stack:
    stack.callback(callback)
    print('A')

# A
# B