Блог

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

Чего вы достигнете (это самая захватывающая часть, поэтому я ставлю ее на первое место):

 m1 = MyListRef([1, 2, 3, 4])
m2 = m1.remove(2)
m3 = m2.swap(0, 2)
m4 = m2.swap(0, 1) #not a linear series of transformations

print(m1, m2, m3, m4, m1)
#[1, 2, 3, 4] [1, 2, 4] [4, 2, 1] [2, 1, 4] [1, 2, 3, 4]

print (m1.list is m2.list is m3.list is m4.list)
# True
  

Код для достижения этого:

Во-первых, вам нужен объект для хранения единственной копии списка. Кроме того, он хранит текущую историю выполненных преобразований, чтобы он мог «сбросить» список в исходное состояние, выполнив обратные преобразования:

 class MyList(object):
    def __init__(self, src):
        self.src = src
        self.history = []

    def doTransformations(self, transformations):
        self._resetTransformations()
        self.history = transformations[:]
        for transformation in transformations:
            self.src = transformation.transform(self.src)

    def _resetTransformations(self):
        self.history.reverse()
        for transformation in self.history:
            self.src = transformation.reversetransform(self.src)
  

Во-вторых, вам нужен объект, с которым вы будете взаимодействовать, который будет запрашивать преобразования MyList . Он также хранит список преобразований, выполненных для обеспечения возможности нелинейных преобразований (как в приведенном выше примере):

 class MyListRef(object):
    ''' OBS: Call 'self.list.doTransformations(self.transformations)' in every
             builtin function you want to use, such as __str__(). '''
    def __init__(self, src, transformations=[]):
        self.list = MyList(src) if type(src) == list else src
        self.transformations = transformations
    def __str__(self):
        self.list.doTransformations(self.transformations)
        return str(self.list.src)

    def _doTransformation(self, transformation):
        transformations = self.transformations   [transformation]
        self.list.doTransformations(transformations)
        return MyListRef(self.list, transformations)

    def remove(self, idx):
        return self._doTransformation(RemoveTransformation(idx))
    def swap(self, idx1, idx2):
        return self._doTransformation(SwapTransformation(idx1, idx2))
  

И не забывать, наконец, о самих объектах преобразования. Убедитесь, что вы меняете только списки, а не копируете их. Кроме того, всем им нужен reversetransform() метод, который противоположен самому преобразованию. Это вызывается, когда MyList сбрасывает свои преобразования:

 class Transformation(object):
    pass

class SwapTransformation(Transformation):
    def __init__(self, idx1, idx2):
        self.idx1 = idx1
        self.idx2 = idx2

    def transform(self, mylist):
        tmp1 = mylist[self.idx1]
        mylist[self.idx1] = mylist[self.idx2]
        mylist[self.idx2] = tmp1
        return mylist

    def reversetransform(self, mylist):
        return self.transform(mylist)

class RemoveTransformation(Transformation):
    def __init__(self, idx):
        self.idx = idx

    def transform(self, mylist):
        self.removed = mylist.pop(self.idx)
        return mylist

    def reversetransform(self, mylist):
        mylist.insert(self.idx, self.removed)
        return mylist
  

Этого достаточно, чтобы приведенный выше пример работал так, как вы хотите.