In-depth understanding of python function parameter passing mechanism

The first thing that needs to be stated is that there is no argument for passing parameters by value in Python like in C and C++. Everything in python is an object, which is also its power. It has no basic types.

In python, types belong to objects, and variables have no type. This is the language feature of python and what attracts many pythoners. All variables can be understood as a "reference" to an object in memory, or they can also look like void* in C. Therefore, I hope that when you see a python variable, you can separate the variable from the real memory object.

Types belong to objects, not variables. In this way, many issues will become easier to think about.

Objects in Python can be divided into one or two major categories, mutable and immutable.

Objects belonging to the immutable class mainly include strings, tuples, numbers, lists, dictionaries, etc. Other objects belong to the mutale class.

Since everything in python is an object, the function parameters in python are passed by reference (which can be understood as pointers). I don’t think I need to explain the specific details. I believe everyone is already familiar with the method of passing parameters by reference.

Addition: I just read the above content carefully. Some novices may not understand it based on the following case alone, so I will make two more personal conclusions here.

Since functions are all passed by reference, there is a possibility. If I pass a parameter arg in, but I don’t want the parameter arg to be modified within the function and affect the variable arg outside the function. If I want to Achieving this effect is a bit like copying variables in other languages, right? But there is no such thing as a copy in python, but it gives a type of object (immutable object, personal estimation, this type of object is probably created for this reason, haha). Now we assume that an immutable variable object imvar is passed into the function, and imvar is modified within the function. Since imvar is an immutable object, when modifying it, the compiler will first create a copy object for it. copy_imvar then modifies it, so what is modified in the function is actually not the original object imvar, so its value is still the value before entering the function processing. On the contrary, if a variable type variable is passed, it is modified directly on the reference, so the same object is operated inside and outside the function, so the operation inside the function will directly affect the value of the same variable outside the function. I don’t know if it’s easier to understand now. If you still don’t understand it, you should understand it by looking at the following examples.

A test case is given directly below:

#test
num=10
string='test'
tupleset=(1,2,3)
listset=[9,8,7]
def change(num,string,tupleset,listset):
    num+=1
    string+=' into new words!'
    #tupleset.add(12)   error
    tupleset=(12,3,4,4)
    listset.append(10000)
change(num,string,tupleset,listset)  
print num,string,tupleset,listset
------------------------------------------------
ans:10 test (1, 2, 3) [9, 8, 7, 10000]

After seeing the results, do you have a deeper understanding of objects and references in python?