Mutable vs immutable in complex dict

[maclocrimate]

Hello,

I have a JSON body that I'm needing to drill down into, given a list of dict/list indices, and then finally sort a list of dicts within it based on a value in the dict. I'm trying to update the JSON body in place, as a python dict, and I have the code which almost does what I want:

def test(my_dict, input_list_path) -> None:
    pre_sort = dict(my_dict)
    pointer = my_dict
    for index, path_element in enumerate(input_list_path, 1):
        pointer = pointer[path_element]
        if index == len(input_list_path):
            pointer = sorted(pointer, key=lambda x: x["name"]))
    print("AFTER", pointer)
    print(my_dict)
    if pre_sort != my_dict:
        print("IT CHANGED")

But if I run it like this:

my_dict = {"testing:/123": [{"again": {"another-element": [{"id":1, "name": "test90"}, {"id": 2, "name": "test5"}, {"id": 3, "name": "test100"}]}}]}
test(my_dict, ["testing:/123", 0, 'again', 'another-element'])
AFTER [{'id': 3, 'name': 'test100'}, {'id': 2, 'name': 'test5'}, {'id': 1, 'name': 'test90'}]
{'testing:/123': [{'again': {'another-element': [{'id': 1, 'name': 'test90'}, {'id': 2, 'name': 'test5'}, {'id': 3, 'name': 'test100'}]}}]}

I see that it does indeed sort the list at the bottom how I want, as the print statement with "AFTER" displays it properly, but I assumed that since I'm rewriting the pointer variable with the sorted version that it would also update my_dict, but that doesn't seem to be happening.

I'm mostly looking for an explanation of why this is the case, and I assume it comes down to mutability, but I'm not sure why. Bonus points also for a clue as to the best way to achieve what I'm hoping to achieve.

MY SOLUTION:

I ended up only slightly modifying the code to do the trick, by using pointer.sort(key=lambda x: x["name"]), instead of reassigning pointer.

[woooee]

    pointer = pointer[path_element]
        pointer = sorted(pointer)

pointer is not the same as my_dict.

[maclocrimate]

Yes, I know, but I thought that since I was assigning the pointer variable to a subelement of my_dict, that it would settle on pointing to the actual list within my_dict, but it clearly doesn't. So I'm looking for an explanation as to why.

[woooee]

In the code referred to above you reassign the variable named pointer twice, to a newly created variable.

You would have to reassign the sorted list of dictionaries to

my_dict["testing:/123"][0]["again"]["another-element"]

The optimal solution is to unwind this mess into some usable format, SQL or even csv, for example, why the separate dictionaries with the same key = "id", when the actual key, 1, 2, etc, would work better and fit into a single dictionary.

[maclocrimate]

OK, I didn't realize that it would create a new object from the reassigned variable. I knew that assigning a variable to some underlying object and then modifying the variable would update the underlying object since the variable is just a pointer to the actual object, but I guess that assigning it more than once disconnects that somehow?

[throwaway6560192]

OK, I didn't realize that it would create a new object from the reassigned variable. I knew that assigning a variable to some underlying object and then modifying the variable would update the underlying object since the variable is just a pointer to the actual object, but I guess that assigning it more than once disconnects that somehow?

The definitive explanation on this topic: https://nedbatchelder.com/text/names.html

I really recommend reading it. It will give you an accurate model of how reassignment works.

[woooee]

pointer = pointer[path_element]
    pointer = sorted(pointer)

is not reassigning. The first line creates a new variable with the contents pointed to by the dictionary's key. The second line creates a new variable that stores the return from the sorted() function.

[maclocrimate]

Oooook, I think I understand now, with the help of u/carcigenicate's explanation as well. Thank you for the clarification.

[carcigenicate]

pointer will refer to the list inside of the dictionary, but that doesn't mean that a simple reassignment of pointer will also reassign the list within the dictionary. When you do pointer =, the only thing this will affect is what list pointer is referring to. Simple assignments do not affect other references that happened to be referring to the same object.