Paso de parámetros en la función Python

Al aprender Python, tengo dudas sobre el parámetro que pasa en Python. Quiero saber si es una copia o una dirección de referencia, así que tengo una prueba.
Comprensión personal, indique cualquier error.

prueba

print("==========列表==========")
def listChanged(a): # 列表：同一引用
    a[0] = 2
    print(id(a))

a = [1]
print("调用函数前：" + str(a))
listChanged(a)
print(id(a))
print("调用函数后：" + str(a))

print("==========集合==========")
def setChanged(a): # 集合：同一引用
    a.add(2)
    print(id(a))

a = {
    
    1}
print("调用函数前：" + str(a))
setChanged(a)
print(id(a))
print("调用函数后：" + str(a))

print("==========字典==========")
def dictChanged(a): # 字典：同一引用
    a[1] = "2"
    print(id(a))

a = {
    
    1:"1"}
print("调用函数前：" + str(a))
dictChanged(a)
print(id(a))
print("调用函数后：" + str(a))

print("==========数值==========")
def numberChanged(a): # 数值：结果变成不同引用
    print("调用函数时：", id(a))
    a += 1
    print("重新赋值：", id(a))

a = 1
print("调用函数前：" + str(a))
numberChanged(a)
print(id(a))
print("调用函数后：" + str(a))

print("==========字符串==========")
def stringChanged(a): # 字符串：结果变成不同引用
    print("调用函数时：", id(a))
    a += "a[:]" # 假装拷贝
    print("重新赋值：", id(a))

a = "1"
print("调用函数前：" + str(a))
stringChanged(a)
print(id(a))
print("调用函数后：" + str(a))

print("==========元组==========")
def tupleChanged(a): # 元组：同一引用
    print("调用函数时：", id(a))
    a += ("合并两元组",)
    print("重新赋值：", id(a))

a = ("1", "2")
print("调用函数前：" + str(a))
tupleChanged(a)
print(id(a))
print("调用函数后：" + str(a))

print("==========带可变子元素的元组==========")
def tuple2Changed(a): # 带可变子元素的元组：同一引用
    a[1][0] = "22"
    print(id(a))

a = ("1", ["2"])
print("调用函数前：" + str(a))
tuple2Changed(a)
print(id(a))
print("调用函数后：" + str(a))

obtener:

==========列表==========
调用函数前：[1]
2268560182080
2268560182080
调用函数后：[2]
==========集合==========  
调用函数前：{
    
    1}
2268560447296
2268560447296
调用函数后：{
    
    1, 2}        
==========字典==========  
调用函数前：{
    
    1: '1'}      
2268560123776
2268560123776
调用函数后：{
    
    1: '2'}      
==========数值==========  
调用函数前：1
调用函数时： 2268558420272
重新赋值： 2268558420304
2268558420272
调用函数后：1
==========字符串==========
调用函数前：1
调用函数时： 2268560076912
重新赋值： 2268560559408
2268560076912
调用函数后：1
==========元组==========
调用函数前：('1', '2')
调用函数时： 2268560166464
重新赋值： 2268560558592
2268560166464
调用函数后：('1', '2')
==========带可变子元素的元组==========
调用函数前：('1', ['2'])
2268560559232
2268560559232
调用函数后：('1', ['22'])

para resumir

• Cuando se pasa como parámetro, es la dirección de memoria pasada.
• Pero debido a que el tipo inmutable no se puede cambiar, si lo modifica, creará un nuevo objeto y abrirá un nuevo espacio en la memoria, y la modificación en la función no afecta las variables externas originales .
• Para la transferencia de tipos de variables, debido a que no se crea ningún objeto, el mismo objeto siempre se opera dentro y fuera de la función.
• La tupla del tipo inmutable contiene [subelemento del tipo de variable], y su modificación del elemento de variable todavía sigue la lógica del tipo de variable. Eso es para modificar su subobjeto mutable, no se volverá a crear, entonces esta tupla no ha cambiado (refiriéndose a su dirección de memoria y la dirección de memoria del elemento almacenado no ha cambiado, o el objeto de tupla sin cambios, pero el contenido modificado) .

• Datos inmutables : Número (número), Cadena (cadena), Tupla (tupla);
• Datos variables : Lista (lista), Diccionario (diccionario), Conjunto (colección).