当程序不再需要一个 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属性，这个属性不会被继承

垃圾回收与弱引用

垃圾回收与弱引用

弱引用

减少内存使用