Эффективная мемоизация в Python

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

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

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

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

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

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 - атрибут функции

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

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

Резюме

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

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

Заранее спасибо.