[FIXED] How to tell when an item in a list has changed position in Python

Issue

This feels like a fairly simple concept I'm trying to do.

Just as an example:

Say I have a list [1, 2, 3, 4]

That changes to [2, 3, 4, 1]

I need to be able to identify the change so that I can represent and update the data in JSON without updating the entire list.

Bit of background - This is for use in MIDI, the actual lists can be quite a bit longer than this, and the JSON can be nested with varying complexity. There also may be more than a single change occurring at once. It's not going to be possible to update the entire JSON or nested lists due to time complexity. I am doing it this way currently but in order to expand I need to be able to identify when a specific change occurs and have some way of representing this. It needs to be doable in Python 2 WITHOUT any external packages as it's being used in a Python installation that's embedded within a DAW (Ableton Live).

Does anyone know of anything that may help with this problem? Any help or reading material would be greatly appreciated.

EDIT:

I've tried looping over both lists and comparing the values but this detects it as a change in all values which is no faster than just resending the whole list, potentially much slower as I've got two nested for loops first THEN still send the entire list out over MIDI.

Solution

how about this, make a class that track its changes, for example

#from collections.abc import MutableSequence #this for python 3.3+
from collections import MutableSequence

class TrackingList(MutableSequence):
    """list that track its changes"""

    def __init__(self,iterable=()):
        self.data = list(iterable)
        self.changes =[]

    def __len__(self):
        return len(self.data)

    def __getitem__(self,index):
        return self.data[index]

    def __setitem__(self,index,value):
        self.data[index]=value
        self.changes.append(("set",index,value))

    def __delitem__(self,index):
        del self.data[index]
        self.changes.append(("del",index))

    def insert(self,index,value):
        self.data.insert(index,value)
        self.changes.append(("insert",index,value))

    def __str__(self):
        return str(self.data)
        

example use

>>> tl=TrackingList([1,2,3,4])
>>> print(tl)
[1, 2, 3, 4]
>>> tl.changes
[]
>>> tl[0],tl[-1] = tl[-1],tl[0]
>>> print(tl)
[4, 2, 3, 1]
>>> tl.changes
[('set', 0, 4), ('set', -1, 1)]
>>> tl.append(32)
>>> tl.changes
[('set', 0, 4), ('set', -1, 1), ('insert', 4, 32)]
>>> print(tl)
[4, 2, 3, 1, 32]
>>> 

the collections.abc make it easy to make container classes and you get for free a bunch of method, in the case MutableSequence those are: append, reverse, extend, pop, remove, __iadd__, __contains__, __iter__, __reversed__, index, and count

Answered By - Copperfield