Python实现缓存的两个简单方法

 更新时间:2024年11月17日 09:04:31   作者:python收藏家  
缓存是一种用于提高应用程序性能的技术,它通过临时存储程序获得的结果,以便在以后需要时重用它们,本文将学习Python中的不同缓存技术,感兴趣的可以了解下

缓存是一种用于提高应用程序性能的技术,它通过临时存储程序获得的结果,以便在以后需要时重用它们。

在本文中,我们将学习Python中的不同缓存技术,包括functools模块中的@ lru_cache和@ cache装饰器。

简单示例:Python缓存实现

要在Python中创建缓存,我们可以使用functools模块中的@cache装饰器。在下面的代码中,注意print()函数只执行一次:

import functools

@functools.cache
def square(n):
    print(f"Calculating square of {n}")
    return n * n

# Testing the cached function
print(square(4))  # Output: Calculating square of 4 \n 16
print(square(4))  # Output: 16 (cached result, no recalculation)

输出

Calculating square of 4
16
16

Python中的缓存是什么

假设我们需要解决一个数学问题,花一个小时得到正确的答案。如果第二天我们必须解决同样的问题,那么重用我们以前的工作而不是从头开始会很有帮助。

Python中的缓存遵循类似的原则–它在函数调用中计算值时存储这些值,以便在再次需要时重用它们。这种类型的缓存也称为记忆化。

让我们看一个简短的例子,它计算了两次大范围的数字之和:

output = sum(range(100_000_001))
print(output)
output = sum(range(100_000_001))
print(output)

输出

5000000050000000
5000000050000000

计算两次运行时间:

import timeit

print(
    timeit.timeit(
        "sum(range(100_000_001))",
        globals=globals(),
        number=1,
    )
)

print(
    timeit.timeit(
        "sum(range(100_000_001))",
        globals=globals(),
        number=1,
    )
)

输出

1.2157779589979327
1.1848394999979064

输出显示,两个调用所花费的时间大致相同(取决于我们的设置,我们可能会获得更快或更慢的执行时间)。

但是,我们可以使用缓存来避免多次计算相同的值。我们可以使用内置functools模块重新定义:

import functools
import timeit

sum = functools.cache(sum)

print(
    timeit.timeit(
        "sum(range(100_000_001))",
        globals=globals(),
        number=1,
    )
)

print(
    timeit.timeit(
        "sum(range(100_000_001))",
        globals=globals(),
        number=1,
    )
)

输出

1.2760689580027247
2.3330067051574588e-06

第二个调用现在需要几微秒的时间,而不是一秒钟,因为从0到100,000,000的数字之和的结果已经计算并缓存了-第二个调用使用之前计算和存储的值。

functools.cache()装饰器是在Python 3.9版本中添加的,但我们可以在旧版本中使用functools.lru_cache()。

Python缓存:不同的方法

Python的functools模块有两个装饰器用于将缓存应用于函数。让我们通过一个示例来探索functools.lru_cache()和functools.cache()。

让我们编写一个函数sum_digits(),它接受一个数字序列并返回这些数字的位数之和。例如,如果我们使用元组(23,43,8)作为输入,那么:

  • 23的数字之和是5
  • 43的数字之和是7
  • 8的数字之和是8
  • 因此,总和为20。

这是我们可以编写sum_digits函数的一种方式:

def sum_digits(numbers):
    return sum(
        int(digit) for number in numbers for digit in str(number)
    )

numbers = 23, 43, 8

print(sum_digits(numbers))

输出

20

让我们使用这个函数来探索创建缓存的不同方法。

Python手动缓存

让我们首先手动创建该高速缓存。虽然我们也可以很容易地自动化,但手动创建缓存有助于我们理解这个过程。

让我们创建一个字典,并在每次使用新值调用函数时添加键值对来存储结果。如果我们用一个已经存储在这个字典中的值调用函数,函数将返回存储的值,而不会再次计算:

import random
import timeit

def sum_digits(numbers):
    if numbers not in sum_digits.my_cache:
        sum_digits.my_cache[numbers] = sum(
            int(digit) for number in numbers for digit in str(number)
        )
    return sum_digits.my_cache[numbers]
sum_digits.my_cache = {}

numbers = tuple(random.randint(1, 1000) for _ in range(1_000_000))

print(
    timeit.timeit(
        "sum_digits(numbers)",
        globals=globals(),
        number=1
    )
)

print(
    timeit.timeit(
        "sum_digits(numbers)",
        globals=globals(),
        number=1
    )
)

输出

0.28875587500078836
0.0044607500021811575

第二次调用sum_digits(numbers)比第一次调用快得多,因为它使用了缓存的值。

现在让我们更详细地解释上面的代码。首先,请注意,我们在定义函数后创建了字典sum_digits.my_cache,即使我们在函数定义中使用了它。

函数的作用是:检查传递给函数的参数是否已经是sum_digits.my_cache字典中的键之一。仅当参数不在该高速缓存中时,才计算所有数字的和。

由于我们在调用函数时使用的参数作为字典中的键,因此它必须是可散列数据类型。列表是不可散列的,所以我们不能将它用作字典中的键。例如,让我们尝试用列表而不是元组来替换数字-这将引发TypeError:

# ...

numbers = [random.randint(1, 1000) for _ in range(1_000_000)]

# ...

输出

Traceback (most recent call last):
...
TypeError: unhashable type: 'list'

手动创建缓存非常适合学习,但现在让我们探索更快的方法。

使用functools.lru_cache()进行Python缓存

Python从3.2版开始就有了lru_cache()装饰器。函数名开头的“lru”代表“least recently used”。我们可以把缓存看作是一个用来存储经常使用的东西的盒子–当它填满时,LRU策略会扔掉我们很长时间没有使用过的东西,为新的东西腾出空间。

让我们用@functools.lru_cache来装饰sum_digits函数:

import functools
import random
import timeit

@functools.lru_cache
def sum_digits(numbers):
    return sum(
        int(digit) for number in numbers for digit in str(number)
    )

numbers = tuple(random.randint(1, 1000) for _ in range(1_000_000))

print(
    timeit.timeit(
        "sum_digits(numbers)",
        globals=globals(),
        number=1
    )
)

print(
    timeit.timeit(
        "sum_digits(numbers)",
        globals=globals(),
        number=1
    )
)

输出

0.28326129099878017
0.002184917000704445

多亏了缓存,第二个调用的运行时间大大缩短。

默认情况下,该高速缓存存储计算的前128个值。一旦所有128个位置都满了,算法就会删除最近最少使用的(LRU)值,为新值腾出空间。

当我们使用maxsize参数修饰函数时,我们可以设置不同的最大缓存大小:

import functools
import random
import timeit

@functools.lru_cache(maxsize=5)
def sum_digits(numbers):
    return sum(
        int(digit) for number in numbers for digit in str(number)
    )

# ...

在这种情况下,该高速缓存仅存储5个值。如果我们不想限制该高速缓存的大小,也可以将maxsize参数设置为None。

使用functools.cache()进行Python缓存

Python 3.9包含了一个更简单、更快速的缓存装饰器——functools. cache()。这个装饰器有两个主要特点:

  • 它没有最大大小-这类似于调用functools.lru_cache(maxsize=None)。
  • 它存储所有函数调用及其结果(它不使用LRU策略)。这适用于输出相对较小的函数,或者当我们不需要担心缓存大小限制时。

让我们在sum_digits函数上使用@functools.cache装饰器:

import functools
import random
import timeit

@functools.cache
def sum_digits(numbers):
    return sum(
        int(digit) for number in numbers for digit in str(number)
    )

numbers = tuple(random.randint(1, 1000) for _ in range(1_000_000))

print(
    timeit.timeit(
        "sum_digits(numbers)",
        globals=globals(),
        number=1
    )
)

print(
    timeit.timeit(
        "sum_digits(numbers)",
        globals=globals(),
        number=1
    )
)

输出

0.16661812500024098
0.0018135829996026587

使用@functools.cache修饰sum_digits()等效于将sum_digits赋值给functools.cache():

# ...

def sum_digits(numbers):
    return sum(
        int(digit) for number in numbers for digit in str(number)
    )

sum_digits = functools.cache(sum_digits)

请注意,我们也可以使用不同的导入方式:

from functools import cache

这样,我们就可以只使用@cache来装饰我们的函数。

其他缓存策略

Python自己的工具实现了LRU缓存策略,删除最近最少使用的条目,为新值腾出空间。

让我们来看看其他一些缓存策略:

  • 先进先出(FIFO):当该高速缓存已满时,删除添加的第一个项,为新值腾出空间。LRU和FIFO之间的区别在于,LRU将最近使用的项保存在该高速缓存中,而FIFO丢弃最旧的项而不管是否使用。
  • 后进先出(LIFO):当该高速缓存已满时,删除最近添加的项。想象一下自助餐厅里的一堆盘子。我们最近放入堆栈的盘子(最后一个)是我们将首先取出的盘子(第一个)。
  • Most-recently used(MRU):当该高速缓存中需要空间时,将丢弃最近使用的值。
  • 随机替换(RR):该策略随机丢弃一个项目,为新项目腾出空间。

这些策略还可以与有效生存期的度量相结合,有效生存期指的是该高速缓存中的一段数据被认为有效或相关的时间。想象一下缓存中的一篇新闻文章。它可能经常被访问(LRU会保留它),但一周后,新闻可能会过时。

Python中缓存时的常见挑战

我们已经了解了Python中缓存的优点。在实现缓存时,还需要记住一些挑战和缺点:

  • 缓存失效和一致性:数据可能会随着时间而变化。因此,存储在缓存中的值也可能需要更新或删除。
  • 内存管理:在缓存中存储大量数据需要内存,如果缓存无限增长,这可能会导致性能问题。
  • 复杂性:添加缓存会在创建和维护该高速缓存时给系统带来复杂性。通常,好处大于这些成本,但这种增加的复杂性可能会导致难以发现和纠正的错误。

结论

当对同一数据重复执行计算密集型操作时,我们可以使用缓存来优化性能。

Python有两个装饰器在调用函数时创建缓存:functools模块中的@lru_cache和@cache。

但是,我们需要确保该高速缓存保持最新,并正确管理内存。

到此这篇关于Python实现缓存的两个简单方法的文章就介绍到这了,更多相关Python缓存内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • python模拟登陆网站的示例

    python模拟登陆网站的示例

    这篇文章主要介绍了python模拟登陆网站的示例,帮助大家更好的理解和学习使用python,感兴趣的朋友可以了解下
    2021-03-03
  • python列表插入append(), extend(), insert()用法详解

    python列表插入append(), extend(), insert()用法详解

    在本篇文章里小编给大家整理了关于python列表插入append(), extend(), insert()用法以及相关知识点,有需要的朋友们参考下。
    2019-09-09
  • Python中threading模块的Lock和RLock区别详解

    Python中threading模块的Lock和RLock区别详解

    这篇文章主要介绍了Python中threading模块的Lock和RLock区别详解,Lock锁是Python的原始锁,在锁定时不属于任何一个线程,在调用了 lock.acquire() 方法后,进入锁定状态,lock.release()方法可以解锁,底层是通过一个函数来实现的,需要的朋友可以参考下
    2023-09-09
  • Flask Web开发入门之文件上传(八)

    Flask Web开发入门之文件上传(八)

    这篇文章主要为大家详细介绍了Flask Web开发入门之文件上传的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2018-08-08
  • 利用python打印出菱形、三角形以及矩形的方法实例

    利用python打印出菱形、三角形以及矩形的方法实例

    最近在开发中遇到一个问题,需要利用python实现菱形、三角形以及矩形等形状,发现网上这方面的资料较少,所以总结分享下,这篇文章主要给大家介绍了关于利用python打印出菱形、三角形以及矩形的相关资料,需要的朋友可以参考借鉴,下面来一起看看吧。
    2017-08-08
  • Python光学仿真wxpython透镜演示系统计算与绘图

    Python光学仿真wxpython透镜演示系统计算与绘图

    这篇文章主要为大家介绍了Python光学仿真wxpython透镜演示系统计算与绘图的实现示例。有需要的朋友可以借鉴参考下,希望能够有所帮助
    2021-10-10
  • 使用PyV8在Python爬虫中执行js代码

    使用PyV8在Python爬虫中执行js代码

    PyV8是chrome用来执行javascript的引擎,据说是最快的js引擎,通过pyv8的封装,可以在python中使用。下面这篇文章主要介绍了使用PyV8在Python爬虫中执行js代码的相关资料,需要的朋友可以参考下。
    2017-02-02
  • tensorflow 环境变量设置方式

    tensorflow 环境变量设置方式

    今天小编就为大家分享一篇tensorflow 环境变量设置方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2020-02-02
  • python基础教程之while循环

    python基础教程之while循环

    这篇文章主要给大家介绍了关于python基础教程之while循环的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用python具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
    2019-08-08
  • 使用django-guardian实现django-admin的行级权限控制的方法

    使用django-guardian实现django-admin的行级权限控制的方法

    这篇文章主要介绍了使用django-guardian实现django-admin的行级权限控制的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2018-10-10

最新评论