当程序不再需要一个 Python 对象时，系统必须把该对象所占用的内存空间释放出来，这个过程被称为垃圾回收（GC，Garbage Collector），Python 会自动回收所有对象所占用的内存空间，因此开发者无须关心对象垃圾回收的过程。
class T:
def __del__(self):
print("del...")
t = T()
结束后会输出
del...
说明系统调用del方法删除了对象t。
下面介绍系统无法调用del的情况。
创建两个类，采用观察者模式
class Acount:
def __init__(self, name, balance):
self.name = name
self.balance = balance
self.observers = set()
def register(self, observer):
self.observers.add(observer)
def unregister(self, observer):
self.observers.remove(observer)
def noitfy(self):
for ob in self.observers:
ob.update()
def withdraw(self, amt):
self.balance -= amt
self.noitfy()
def __del__(self):
print("系统关闭")
for ob in self.observers:
ob.close()
class AccountObserver:
def __init__(self, name, account):
self.name = name
self.account = account
self.account.register(self)
def update(self):
print("{},Balace is {}".format(self.name, self.account.balance))
def close(self):
print("关闭账户")
def __del__(self):
print("close")
self.account.unregister(self)
del self.account
a = Acount("zs", 1000)
a_ob = AccountObserver("aob", a)
b_ob = AccountObserver("bob", a)
c_ob = AccountObserver("cob", a)
a.withdraw(100)
效果如下
cob,Balace is 900
bob,Balace is 900
aob,Balace is 900
系统关闭
关闭账户
关闭账户
关闭账户
close
close
close
可见，在程序结束后系统先释放对象a，然后是a_ob、b_ob和c_ob。
如果在程序末尾加上
a = Acount('zhang', 1000)
再次运行
aob,Balace is 900
cob,Balace is 900
bob,Balace is 900
系统关闭
close
close
close
系统关闭
在原程序上加上
b = Acount('zhang', 1000)
再次运行
aob,Balace is 900
cob,Balace is 900
bob,Balace is 900
系统关闭
关闭账户
关闭账户
关闭账户
close
close
close
系统关闭
这些不同是由于循环引用，使各自对象的引用计数器程序结束后无法为零所致，只有当对象的引用数为零时，系统才会删除对象。下面来查看a的引用次数
在程序开头加上
from sys import getrefcount
在原程序末尾加上
print(getrefcount(Acount("zs", 1000)))
print(getrefcount(a))
运行后它们对应的输出分别为1、5。
说明Acount("zs", 1000)的引用计数为1，由于getrefcount传参时相当于引用一次，所以输出1。
而a被引用5次，除了三个观察者对它的引用，剩余两次分别为Acount类的'self'参数对a的引用和getrefcount调用时传参时对a的引用。
因为程序结束后，对象引用计数不为零，导致无法释放内存，为了解决这种情况，可以采用弱引用。
弱引用
class A:
def __init__(self):
pass
def p(self):
print("pppppp")
a = A()
b = a
print(getrefcount(a))
import weakref
# 创建c，a的引用次数不增加
c = weakref.ref(a)
print(getrefcount(a))
d = c()
d.p()
print(getrefcount(a))
效果如下
3
3
pppppp
4
垃圾回收时，Python不能进行其它的任务。频繁的垃圾回收将大大降低Python的工作效率。如果内存中的对象不多，就没有必要总启动垃圾回收。所以，Python只会在特定条件下，自动启动垃圾回收。当Python运行时，会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。
我们可以通过gc模块的get_threshold()方法，查看该阈值:
import gc
print(gc.get_threshold())
输出结果
(700, 10, 10)
减少内存使用
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
s = Student("zhangsan", 20)
print(s.__dict__)
一般的类创建对象后，属性存在字典中，查找速度比序列快，原因是字典采用hash算法
输出效果如下
{'name': 'zhangsan', 'age': 20}
hash算法的要点：
- 内容相同，hash计算的结果必须相同.
- 内容不同，hash值有可能相同.
hash算法速度虽然快，但是费内存，一般占用三倍的内存
为了减少内存的消耗，可以用slots将属性存入元组
下面用slots改写Student类
class Student:
__slots__ = ("name", "age")
def __init__(self, name, age):
self.name = name
self.age = age
s = Student("zhangsan", 20)
print(s.name)
print(s.age)
改写后可以正常访问
zhangsan
20
但访问对象的dict时，会报错'Student' object has no attribute '__dict__'，说明类的属性不以字典的方式存储。
注：
- 使用slots后，不能再动态地添加属性了
- 使用slots后，每个子类都需要定义slots属性，这个属性不会被继承
