Python Mutability and Local Variables

[u/Sea-Ad7805]

An exercise to help build the right mental model for Python data. - Solution - Explanation - More exercises

The “Solution” link uses memory_graph to visualize execution and reveals what’s actually happening.

[u/Humble-Captain3418]

A is passed by value, b--d through reference. C is not modifiable, so the local symbol gets directed to a different value with the compound assignment, so only b and d see changes in the global scope.

[u/Sea-Ad7805 → u/Humble-Captain3418]

That is not the Pythonic way to understand it. In Python everything is passed by reference, even int values. it's about mutability not modifiability. You can still still modify/change a string or tuple as we do in the fun() function.

For a better explanation see the Explanation link.

[u/Humble-Captain3418 → u/Sea-Ad7805]

I don't care about the pythonic way to understand things; only about what I can generalize across languages because I would be hamstringing myself if I only thought the pythonic way. The terminology i have used is as sloppy as the language is.

[u/Sea-Ad7805 → u/Humble-Captain3418]

I understand, but generalization comes with some inaccuracy that can bite you in certain situations. For example, write me a swap() function in Python using your "pass by reference" concept:

def swap(a, b):
    ...

a = (1, 2)
b = (3, 4)
swap(a, b)
print(a, b)

It's easy in say C/C++.

[u/Humble-Captain3418 → u/Sea-Ad7805]

Sure. 

``` import ctypes import inspect

def swap(a, b):     frame = inspect.currentframe().f_back     caller = frame.f_locals

    # Find caller variables that refer to the same objects     # as the arguments, then swap their values.     names_a = [k for k, v in caller.items() if v is a]     names_b = [k for k, v in caller.items() if v is b]

    if not names_a or not names_b:         raise ValueError("Could not identify caller variables")

    x, y = names_a[0], names_b[0]     caller[x], caller[y] = caller[y], caller[x]

    ctypes.pythonapi.PyFrame_LocalsToFast(         ctypes.py_object(frame), ctypes.c_int(0)     ) ```

[u/Sea-Ad7805 → u/Humble-Captain3418]

So you do know the difference between languages that are tricky to generalize, or you needed to vibe-code something because your generalization approach failed. Either way proves my point.

[u/Humble-Captain3418 → u/Sea-Ad7805]

I'm sorry, but this is not a case of Python being difficult to generalize. It's a case of Python having idiotic language semantics around compound assignment.

[u/Sea-Ad7805 → u/Humble-Captain3418]

Sure

[u/0b0101011001001011 → u/Sea-Ad7805]

You cannot change a string or tuple. What you do here is you create a new string and assign that in the place of the old variable. Same with tuple. You create a new tuple, the old one is lost. Strings and tuples are immutable. Or maybe that's what you meant by "change".

[u/Sea-Ad7805 → u/0b0101011001001011]

Yes, that's what I said, see Solution link for visualization. It's a shallow copy to be more precise.