O método __del __ () na função: Destrua o objeto
Python constrói um objeto instanciado da classe atual chamando o método __init __ (), e o método __del __ () é usado para destruir o objeto instanciado.
Na verdade, ao escrever um programa, se o objeto de instanciação de classe que criamos antes não for mais usado no programa subsequente, é melhor destruí-lo manualmente em um local adequado para liberar o espaço de memória que ocupa (todo o processo é chamado coleta de lixo (abreviatura: GC)).
Na maioria dos casos, os desenvolvedores Python não precisam executar a coleta de lixo manualmente, porque o Python tem um mecanismo automático de coleta de lixo que pode destruir objetos de instância que não precisam ser usados.
Exemplo um
# -*- coding:utf8 -*-class User:
def __init__(self):
print("=== 调用 __init__() 方法构造对象 ===")
def __del__(self):
print("调用__del__() 销毁对象,（对象占用的内存被回收）")
u1 = User()
print('#'*50)
resultado da operação:
D:\pythonproject\venv\Scripts\python.exe D:/pythonproject/私有属性2.py
=== 调用 __init__() 方法构造对象 ===
##################################################
调用__del__() 销毁对象,（对象占用的内存被回收）
Process finished with exit code 0
Nota: O código acima não chamará o método __del __ () quando executado sob programação Python interativa e não imprimirá chamando __del __ () para destruir o objeto (a memória ocupada pelo objeto é reciclada), porque o programa não é sobre.
Conclusão: Python irá chamar o método __del __ () antes do final do programa para destruir automaticamente o objeto para nós e, em seguida, liberar a memória ocupada pelo objeto. Preste atenção na localização da chamada do método __del __ (), após a impressão ('#' * 50) declaração.
Exemplo dois
# -*- coding:utf8 -*-class User:
def __init__(self):
print("=== 调用 __init__() 方法构造对象 ===")
def __del__(self):
print("调用__del__() 销毁对象,（对象占用的内存被回收）")
u1 = User()
del u1
print('#'*50)
resultado da operação:
D:\pythonproject\venv\Scripts\python.exe D:/pythonproject/私有属性2.py
=== 调用 __init__() 方法构造对象 ===
调用__del__() 销毁对象,（对象占用的内存被回收）
##################################################
Process finished with exit code 0
Conclusão: Exclua manualmente o objeto e chame o método __del __ () para destruir o objeto de memória e liberar o espaço de memória.
Exemplo três
# -*- 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 da operação:
D:\pythonproject\venv\Scripts\python.exe D:/pythonproject/销毁对象3.py
=== 调用 __init__() 方法构造对象 ===
##################################################
调用__del__() 销毁对象,（对象占用的内存被回收）
Process finished with exit code 0
Conclusão: pode ser visto a partir dos resultados da execução que a execução da instrução del u1 chama o método __del __ (), mas não é executada imediatamente, mas quando o programa está prestes a terminar, o programa automaticamente chama o método __del __ () , destruindo o objeto de memória, aqui envolve o mecanismo de coleta de lixo do Python.
Python usa contagem automática de referência (referida como: ARC (auto-refrence-count)) para implementar o mecanismo de coleta de lixo. A ideia central deste método é: cada objeto Python será configurado com um contador, e o valor do contador da instância inicial do objeto Python é 0. Se houver uma variável que faz referência ao objeto instância, o valor do contador será também aumenta em 1 e assim por diante; Quando uma variável desreferencia o objeto de instância, o contador diminui em 1. Se o valor do contador de um objeto Python for 0, significa que não há nenhuma variável referenciando o objeto Python, o que prova que o programa não precisa mais dele, e Python chamará automaticamente o método __del __ () para reciclá-lo.
Análise do terceiro exemplo acima: Na verdade, o processo de construção do objeto de instância u1 é dividido em duas etapas. Primeiro, use User () para chamar o método __init __ () nesta classe para construir um objeto desta classe (chamamos it U, o contador é 0), e imediatamente usa a variável u1 como uma referência para o objeto de instância criado (o valor do contador de U + 1). Nesta base, existe outra variável u2 que faz referência a u1 (na verdade, é equivalente a fazer referência a User (), neste momento o contador de U é +1). Neste momento, se você chamar a instrução del u1, apenas fará com que o contador de C diminua em 1 (o valor muda É 1), então o valor do contador de C não é 0, então U não será destruído (o método __del __ () não será executado).
Exemplo quatro
# -*- 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 da operação:
D:\pythonproject\venv\Scripts\python.exe D:/pythonproject/私有属性2.py
=== 调用 __init__() 方法构造对象 ===
##################################################
**************************************************
调用__del__() 销毁对象,（对象占用的内存被回收）
Process finished with exit code 0
Exemplo 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 da operação:
D:\pythonproject\venv\Scripts\python.exe D:/pythonproject/私有属性2.py
=== 调用 __init__() 方法构造对象 ===
##################################################
调用__del__() 销毁对象,（对象占用的内存被回收）
**************************************************
Process finished with exit code 0
Por quatro exemplos e cinco exemplos de comparação de duas instâncias, descobrimos que: a instância de um objeto é referenciada n vezes, o contador é n, então o contador de referência referenciado por esta instância de um objeto para realizar um del objetos será automaticamente menos 1 , Quando o contador do objeto de instância é reduzido a zero, o método __del __ () na classe será chamado e executado. Se o contador não for zero, o método __del __ () no objeto de instância não será executado, e então o programa terminará em breve. Anteriormente, o interpretador python executava automaticamente o método __del __ () para destruir o objeto.