memory deallocation/clearing

variables alone can be altered. The only static immutable type of memory would be to store it in a Tuple.

Use (a, b, n...) to make a tuple. It's static memory that's easily indexed.

can you explain a little more. I'm not exactly sure what your asking.

Yes, your question is very confusing. Can you give an example of what you mean with code in it so there is no ambiguity?

I think you're talking about Python's variable/value metaphor being "binding names", rather than "allocating variables".

>>> # create a list of three variables, and bind it to the name 'a'
>>> a = [1,2,3]
>>> # bind the variable b to the value of a
>>> b = a
>>> # add the value 4 to b
>>> b.append(4)
>>> # print a
>>> a
[1, 2, 3, 4]
>>> # create a list of three variables and bind it to b
>>> b = ['a', 'b', 'c']
>>> # print b
>>> b
['a', 'b', 'c']
>>> # a is unchanged
>>> a
[1, 2, 3, 4]

Contrast this with C++:

int main() {
    std::vector< int > a = std::vector< int >();
    a.push_back( 1 );
    a.push_back( 2 );
    a.push_back( 3 );

    std::vector< int >& b = a;
    b.push_back( 4 );
    
    // This doesn't work, but if it did, it would print something like:
    // [ 1, 2, 3, 4 ]
    // std::cout << a << std::endl;
    
    b = std::vector< int >();
    b.push_back( -1 );
    b.push_back( -2 );
    b.push_back( -3 );
    
    // Would print something like:
    // [ -1, -2, -3 ]
    // std::cout << b << std::endl;

    // Would print something like:
    // [ -1, -2, -3 ]
    // std::cout << a << std::endl;
}

in this case, the important change happens when you rebind b (use it on the left side of an equal sign). you're changing it from both b and a referring to the same object (a list) to b referring to an entirely different list.

In addition to what hythloday said, it's important to bear in mind that function arguments are passed as a copy of the value of the reference. This means that when you pass in a class instance or other mutable object (eg. list, dictionary), it's effectively by reference, but if you pass in an immutable object (eg. integer, string), you're just rebinding the local copy to a new value, which is effectively equivalent to having passed by value.

Without knowing this, it's easy to think that some things are getting arbitrarily altered and other things are not. Once you get into the habit of noting this and that assignment is, as the name implies, assigning a value to a name, and not copying (as it is in C++, for example), things begin to fall into place.

ignore memory addresses entirely.

python variable names are like those yellow post-it notes. you can pick it up and stick it to your chair or to your forehead. you can do certain operations with your chair that you can't do with your head.

if you rebind a variable(put the sticky note on another object), then the old object gets garbage collected eventually and automatically (if it doesn't have any other sticky notes on it).

if you've got something like:

myvariable = 23

you can re-bind myvariable to any other object, for example:
myvariable = (1, 2, 3)
myvariable = 'cat'

you're not creating a copy of myvariable in these cases, nor are you doing anything to the memory addresses, as such, you're re-binding the variable name to an entirely new object.

Does this help at all?

To add one thing to what has already been said, when you are looking to make a copy of a simple object, such as non-nested lists and dictionaries you can use the copy.copy() method. If your object is deeply nested, such as a dictionary of lists, you need to use the copy.deepcopy() method.

And if all else fails, you can adjust the garbage collector's behavior using the gc module.