Reckoner wrote:
I am writing an algorithm that takes objects (i.e. graphs with
thousands of nodes) into a "hypothetical" state. I need to keep a
history of these hypothetical objects depending on what happens to
them later. Note that these hypothetical objects are intimately
operated on, changed, and made otherwise significantly different from
the objects they were copied from.
I've been using deepcopy to push the objects into the hypothetical
state where I operate on them heavily. This is pretty slow since the
objects are very large.
Is there another way to do this without resorting to deepcopy?
by the way, the algorithm works fine. It's just this part of it that I
am trying to change.
This is similar to implementing "Undo" functionality in applications. One
solution is to define every operation you can do on the data structure as a pair
of functions, one which does the "forward" operation on the data structure and
one which does the "backward" operation which will return the modified data
structure back to its original state. Each time you do a forward operation,
append the pair of functions to a list (along with any auxiliary data that you
need). Once you have finished with the hypothetical operations, you can work
your way backwards through the list and using the "backwards" operations.
This works fairly well if you have a single data structure that you are managing
this way and a limited set of operations to track. If you have multiple
interacting objects and a large set of operations, things can become cumbersome.
--
Robert Kern
"I have come to believe that the whole world is an enigma, a harmless enigma
that is made terrible by our own mad attempt to interpret it as though it had
an underlying truth."
-- Umberto Eco
--
http://mail.python.org/mailman/listinfo/python-list
