Как избежать вычисления каждый раз, когда модуль Python перезагружается

Если 'отложить' решение оказывается слишком медленным или трудным, существуют другие возможности:

• толчок
• Durus
• ZopeDB
• pyTables

Вычислите свой глобальный var на первое использование.

class Proxy:
    @property
    def global_name(self):
        # calculate your global var here, enable cache if needed
        ...

_proxy_object = Proxy()
GLOBAL_NAME = _proxy_object.global_name

Или еще лучше, доступ necessery данные через специальный объект данных.

class Data:
    GLOBAL_NAME = property(...)

data = Data()

Пример:

from some_module import data

print(data.GLOBAL_NAME)

Посмотрите настройки Django.

Я предполагаю, что Вы вставили dict литерал в источник, и это - то, что занимает минуту? Я не знаю, как обойти это, но Вы могли, вероятно, постараться не инстанцировать этого dict на импорт... Вы могли лениво - инстанцировать его в первый раз, когда это на самом деле используется.

Вы могли попытаться использовать модуль маршала вместо c? Засолите тот; это могло быть быстрее. Этот модуль используется Python для хранения значений в двоичном формате. Отметьте особенно следующий параграф, чтобы видеть, соответствует ли маршал Вашим потребностям:

Не все типы объектов Python поддерживаются; в целом только объекты, значение которых независимо от конкретного вызова Python, могут быть записаны и считаны этим модулем. Следующие типы поддерживаются: Ни один, целые числа, длинные целые, числа с плавающей точкой, строки, объекты Unicode, кортежи, списки, наборы, словари и объекты кода, где нужно подразумевать, что кортежи, списки и словари только поддерживаются пока значения, содержавшие там, самостоятельно не поддерживаются; и рекурсивные списки и словари не должны быть записаны (они вызовут бесконечные циклы).

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

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

Отложите засолит значения dict также, но сделает (ООН) рассол не при запуске для всех объектов, но только во время доступа для каждого объекта самого.

Подробно останавливаясь на идее отложенного вычисления, почему бы не повернуть dict в класс, который предоставляет (и кэши) элементы по мере необходимости?

Вы могли бы также использовать психо для ускорения полного выполнения...

ИЛИ Вы могли просто использовать базу данных для хранения значений в? Проверьте SQLObject, который делает очень легким сохранить материал к базе данных.

1. Включите в вычислительном отношении интенсивную часть в отдельный модуль. Затем, по крайней мере, на перезагрузке, Вы не должны будете ожидать.

2. Попытайтесь вывести структуру данных с помощью протокола 2. Команда для попытки была бы cPickle.dump(FD, protocol=2). От docstring для cPickle.Pickler:

   Protocol 0 is the
   only protocol that can be written to a file opened in text
   mode and read back successfully.  When using a protocol higher
   than 0, make sure the file is opened in binary mode, both when
   pickling and unpickling. 
   

Несколько вещей, которые помогут ускорить импорт:

1. Вы могли бы попробовать под управлением Python с помощью - флаг OO когда под управлением Python. Это сделает некоторую оптимизацию, которая уменьшит время импорта модулей.
2. Есть ли какая-либо причина, почему Вы не могли разбить словарь в меньшие словари в отдельных модулях, которые могут быть загружены более быстро?
3. Как последнее прибежище Вы могли сделать вычисления асинхронно так, чтобы они не задерживали Вашу программу, пока ей не будут нужны результаты. Или возможно даже помещенный словарь в отдельный процесс и данные передачи назад и вперед с помощью IPC, если Вы хотите использовать в своих интересах многоядерную архитектуру.

После этих слов я соглашаюсь, что Вы не должны испытывать задержку импорта модулей после первого раза, когда Вы импортируете его. Вот несколько других общих мыслей:

1. Вы импортируете модуль в функции? Если так, это может привести к проблемам производительности, так как это должно проверить и видеть, загружается ли модуль каждый раз, когда это поражает оператора импорта.
2. Действительно ли Ваша программа является многопоточной? Я видел случаи, где выполнение кода на импорт модуля в многопоточном приложении может вызвать некоторый wonkiness и нестабильность приложения (прежде всего с cgitb модулем).
3. Если это - глобальная переменная, знают, что времена поиска глобальной переменной могут быть значительно дольше, чем времена поиска локальной переменной. В этом случае можно достигнуть значительного повышения производительности путем привязки словаря с локальной переменной при использовании его многократно в том же контексте.

После этих слов это - немного бита, трудного дать Вам любой определенный совет без немного большего количества контекста. Строго говоря, где Вы импортируете его? И каковы вычисления?

Существует другое довольно очевидное решение для этой проблемы. Когда код перезагружается, исходный объем все еще доступен.

Так... выполнение что-то вроде этого удостоверится, что этот код выполнен только однажды.

try:
    FD
except NameError:
    FD = FreqDist(word for word in brown.words())

полка работает очень медленно с большими наборами данных. Я довольно успешно использовал redis и написал вокруг него оболочку FreqDist . Это очень быстро, и к нему можно обращаться одновременно.

Я столкнулся с той же проблемой ... полки, базы данных и т. Д. Слишком медленные для этого типа проблем. Вам нужно будет принять удар один раз, вставить его в хранилище ключей / val inmemory, например Redis. Он просто будет жить там в памяти (предупреждаем, что он может использовать хороший объем памяти, поэтому вам может понадобиться выделенный ящик). Вам никогда не придется перезагружать его, и вы просто будете искать в памяти ключи

r = Redis()
r.set(key, word)

word = r.get(key)