Эффективная память в Python

У меня есть некоторая задача для решения, и самая важная часть на данный момент состоит в том, чтобы сделать script максимально эффективным по времени. Одним из элементов, которые я пытаюсь оптимизировать, является memoization внутри одной из функций.

Итак, мой вопрос: Какой из следующих 3-4 методов является наиболее эффективным/быстрым методом реализации memoization в Python?

Я предоставил код только в качестве примера - если один из методов более эффективен, но не в том случае, о котором я упоминал, пожалуйста, поделитесь тем, что вы знаете.

Решение 1 - использование изменяемой переменной из внешней области

Это решение часто отображается как пример memoization, но я не уверен, насколько он эффективен. Я слышал, что использование глобальных переменных (в данном случае это переменная из внешней, а не глобальной области) менее эффективно.

def main():
    memo = {}
    def power_div(n):
        try:
            return memo[n]
        except (KeyError):
            memo[n] = (n ** 2) % 4  # example expression, should not matter
            return memo[n]
    # extensive usage of power_div() here

Решение 2 - использование аргумента по умолчанию, изменяемого аргумента

Я где-то нашел, что использование измененных по умолчанию аргументов использовалось в прошлом для передачи переменных из внешней области, когда Python сначала искал переменную в локальной области, а затем в глобальной области пропускал нелокальную область (в этом случае область действия внутри функции main()). Поскольку аргумент по умолчанию инициализируется только в момент, когда функция определена и доступна только внутри внутренней функции, возможно, она более эффективна?

def main():
    def power_div(n, memo={}):
        try:
            return memo[n]
        except (KeyError):
            memo[n] = (n ** 2) % 4  # example expression, should not matter
            return memo[n]
    # extensive usage of power_div() here

Или, может быть, более эффективна следующая версия (на самом деле комбинация решений 1 и 2)?

def main():
    memo = {}
    def power_div(n, memo=memo):
        try:
            return memo[n]
        except (KeyError):
            memo[n] = (n ** 2) % 4  # example expression, should not matter
            return memo[n]
    # extensive usage of power_div() here

Решение 3 - атрибут функции

Это еще один довольно распространенный пример memoization в Python - объект memoization сохраняется как атрибут самой функции.

def main():
    def power_div(n):
        memo = power_div.memo
        try:
            return memo[n]
        except (KeyError):
            memo[n] = (n ** 2) % 4  # example expression, should not matter
            return memo[n]
    # extensive usage of power_div() here

Резюме

Мне очень интересно ваше мнение о четырех вышеупомянутых решениях для memoization. Важно также, что функция, использующая memoization, находится в пределах другой функции.

Я знаю, что есть и другие решения для memoization (например, Memoize decorator), но мне трудно поверить, что это более эффективное решение чем перечисленные выше. Исправьте меня, если я ошибаюсь.

Спасибо заранее.

Ответы

from fastcache import clru_cache

@clru_cache(maxsize=128, typed=False)
def foo(cat_1, cat_2, cat_3):
    return cat_1 + cat_2 + cat_3

pip install fastcache

conda install fastcache