El método __del __ () en la función: Destruir el objeto
Python construye un objeto instanciado de la clase actual llamando al método __init __ (), y el método __del __ () se usa para destruir el objeto instanciado.
De hecho, al escribir un programa, si el objeto de instanciación de clase que creamos antes ya no se usa en el programa posterior, es mejor destruirlo manualmente en una ubicación adecuada para liberar el espacio de memoria que ocupa (todo el proceso se llama recolección de basura (abreviatura: GC)).
En la mayoría de los casos, los desarrolladores de Python no necesitan realizar manualmente la recolección de basura, porque Python tiene un mecanismo automático de recolección de basura que puede destruir objetos de instancia que no necesitan ser usados.
Ejemplo uno
# -*- coding:utf8 -*-class User:
def __init__(self):
print("=== 调用 __init__() 方法构造对象 ===")
def __del__(self):
print("调用__del__() 销毁对象,（对象占用的内存被回收）")
u1 = User()
print('#'*50)
resultado de la operación:
D:\pythonproject\venv\Scripts\python.exe D:/pythonproject/私有属性2.py
=== 调用 __init__() 方法构造对象 ===
##################################################
调用__del__() 销毁对象,（对象占用的内存被回收）
Process finished with exit code 0
Nota: El código anterior no llamará al método __del __ () cuando se ejecute bajo la programación interactiva de Python, y no imprimirá llamando a __del __ () para destruir el objeto (la memoria ocupada por el objeto se recicla), porque el programa no es encima.
Conclusión: Python llamará al método __del __ () antes del final del programa para destruir automáticamente el objeto y luego liberar la memoria ocupada por el objeto. Preste atención a la ubicación de la llamada al método __del __ (), después de la impresión ('#' * 50) declaración.
Ejemplo dos
# -*- coding:utf8 -*-class User:
def __init__(self):
print("=== 调用 __init__() 方法构造对象 ===")
def __del__(self):
print("调用__del__() 销毁对象,（对象占用的内存被回收）")
u1 = User()
del u1
print('#'*50)
resultado de la operación:
D:\pythonproject\venv\Scripts\python.exe D:/pythonproject/私有属性2.py
=== 调用 __init__() 方法构造对象 ===
调用__del__() 销毁对象,（对象占用的内存被回收）
##################################################
Process finished with exit code 0
Conclusión: elimine manualmente el objeto y luego llame al método __del __ () para destruir el objeto de memoria y liberar el espacio de memoria.
Ejemplo tres
# -*- coding:utf8 -*-class User:
def __init__(self):
print("=== 调用 __init__() 方法构造对象 ===")
def __del__(self):
print("调用__del__() 销毁对象,（对象占用的内存被回收）")
u1 = User()
u2 = u1#
del u1 # 从运行结果可以看出来，执行该语句没有调用 __del__()方法，而是在程序即将运行结束的时候，程序自动调用了__del__()方法，销毁了对象
print('#'*50)# print('\n')# del u2# print("*"*50)
resultado de la operación:
D:\pythonproject\venv\Scripts\python.exe D:/pythonproject/销毁对象3.py
=== 调用 __init__() 方法构造对象 ===
##################################################
调用__del__() 销毁对象,（对象占用的内存被回收）
Process finished with exit code 0
Conclusión: Se puede ver en los resultados de ejecución que la ejecución de la instrucción del u1 llama al método __del __ (), pero no se ejecuta inmediatamente, pero cuando el programa está a punto de finalizar, el programa llama automáticamente al método __del __ () , destruyendo el objeto de memoria, Aquí involucra el mecanismo de recolección de basura de Python.
Python utiliza el recuento de referencias automático (denominado: ARC (recuento de referencias automáticas)) para implementar el mecanismo de recolección de basura. La idea central de este método es: cada objeto de Python se configurará con un contador, y el valor del contador del objeto de instancia de Python inicial es 0. Si hay una variable que hace referencia al objeto de instancia, el valor del contador será también aumentar en 1, y así sucesivamente; cuando una variable elimina la referencia al objeto de instancia, el contador disminuirá en 1. Si el valor del contador de un objeto Python es 0, significa que no hay ninguna variable que haga referencia al objeto Python, lo que demuestra que el programa ya no lo necesita, y Python llamará automáticamente al método __del __ () para reciclarlo.
Análisis del tercer ejemplo anterior: De hecho, el proceso de construcción del objeto de instancia u1 se divide en dos pasos. Primero, use User () para llamar al método __init __ () en esta clase para construir un objeto de esta clase (llamamos it U, el contador es 0), e inmediatamente usa la variable u1 como referencia al objeto de instancia creado (el valor del contador de U + 1). Sobre esta base, hay otra variable u2 que hace referencia a u1 (de hecho, es equivalente a hacer referencia a Usuario (), en este momento el contador de U es +1). En este momento, si llama a la sentencia del u1, solo hará que el contador de C disminuya en 1 (el valor cambia es 1), por lo que el valor del contador de C no es 0, por lo que U no se destruirá (el método __del __ () no se ejecutará).
Ejemplo cuatro
# -*- coding:utf8 -*-class User:
def __init__(self):
print("=== 调用 __init__() 方法构造对象 ===")
def __del__(self):
print("调用__del__() 销毁对象,（对象占用的内存被回收）")
u1 = User()
u2 = u1del u1 # 从运行结果可以看出来，执行该语句没有调用 __del__()方法，而是在程序即将运行结束的时候，程序自动调用了__del__()方法，销毁了对象print('#'*50)
# print('\n')# del u2print("*"*50)
resultado de la operación:
D:\pythonproject\venv\Scripts\python.exe D:/pythonproject/私有属性2.py
=== 调用 __init__() 方法构造对象 ===
##################################################
**************************************************
调用__del__() 销毁对象,（对象占用的内存被回收）
Process finished with exit code 0
Ejemplo 5:
# -*- coding:utf8 -*-class User:
def __init__(self):
print("=== 调用 __init__() 方法构造对象 ===")
def __del__(self):
print("调用__del__() 销毁对象,（对象占用的内存被回收）")
u1 = User()
u2 = u1del u1 # 从运行结果可以看出来，执行该语句没有调用 __del__()方法，而是在程序即将运行结束的时候，程序自动调用了__del__()方法，销毁了对象print('#'*50)
print('\n')
del u2print("*"*50)
resultado de la operación:
D:\pythonproject\venv\Scripts\python.exe D:/pythonproject/私有属性2.py
=== 调用 __init__() 方法构造对象 ===
##################################################
调用__del__() 销毁对象,（对象占用的内存被回收）
**************************************************
Process finished with exit code 0
Mediante cuatro ejemplos y cinco ejemplos de comparación de dos instancias, encontramos que: la instancia de un objeto es referenciada n veces, el contador es n, entonces el contador de referencia al que hace referencia esta instancia de un objeto para realizar una eliminación de objetos automáticamente será menos 1 , Cuando el contador del objeto de instancia se reduce a cero, se llamará y ejecutará el método __del __ () en la clase. Si el contador no es cero, el método __del __ () en el objeto de instancia no se ejecutará, y luego el programa terminará pronto. Anteriormente, el intérprete de Python ejecutaba automáticamente el método __del __ () para destruir el objeto.