摘要：概述如果程序處理的數(shù)據(jù)比較多比較復(fù)雜，那么在程序運行的時候，會占用大量的內(nèi)存，當內(nèi)存占用到達一定的數(shù)值，程序就有可能被操作系統(tǒng)終止，特別是在限制程序所使用的內(nèi)存大小的場景，更容易發(fā)生問題。下面我就給出幾個優(yōu)化占用內(nèi)存的幾個方法。

如果程序處理的數(shù)據(jù)比較多、比較復(fù)雜，那么在程序運行的時候，會占用大量的內(nèi)存，當內(nèi)存占用到達一定的數(shù)值，程序就有可能被操作系統(tǒng)終止，特別是在限制程序所使用的內(nèi)存大小的場景，更容易發(fā)生問題。下面我就給出幾個優(yōu)化Python占用內(nèi)存的幾個方法。

說明：以下代碼運行在Python3。

我們舉個簡單的場景，使用Python存儲一個三維坐標數(shù)據(jù)，x,y,z。

使用Python內(nèi)置的數(shù)據(jù)結(jié)構(gòu)Dict來實現(xiàn)上述例子的需求很簡單。

>>> ob = {"x":1, "y":2, "z":3}
>>> x = ob["x"]
>>> ob["y"] = y

查看以下ob這個對象占用的內(nèi)存大小：

>>> print(sys.getsizeof(ob))
240

簡單的三個整數(shù)，占用的內(nèi)存還真不少，想象以下，如果有大量的這樣的數(shù)據(jù)要存儲，會占用更大的內(nèi)存。

對于喜歡面向?qū)ο缶幊痰某绦騿T來說，更喜歡把數(shù)據(jù)包在一個class里。使用class使用同樣需求：

class Point:
    #
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

>>> ob = Point(1,2,3)

class的數(shù)據(jù)結(jié)構(gòu)和Dict區(qū)別就很大了，我們來看看這種情況下占用內(nèi)存的情況：

關(guān)于 __weakref__（弱引用）可以查看這個文檔，　對象的__dict__中存儲了一些self.xxx的一些東西。從Python 3.3開始，key使用了共享內(nèi)存存儲， 減少了RAM中實例跟蹤的大小。

>>> print(sys.getsizeof(ob), sys.getsizeof(ob.__dict__)) 
56 112

可以看到內(nèi)存占用量，class比dict少了一些，但這遠遠不夠。

從class的內(nèi)存占用分布上，我們可以發(fā)現(xiàn)，通過消除__dict__和_weakref__，可以顯著減少RAM中類實例的大小，我們可以通過使用__slots__來達到這個目的。

class Point:
    __slots__ = "x", "y", "z"

    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

>>> ob = Point(1,2,3)
>>> print(sys.getsizeof(ob))
64

可以看到內(nèi)存占用顯著的減少了

默認情況下,Python的新式類和經(jīng)典類的實例都有一個dict來存儲實例的屬性。這在一般情況下還不錯，而且非常靈活，乃至在程序中可以隨意設(shè)置新的屬性。但是，對一些在”編譯”前就知道有幾個固定屬性的小class來說，這個dict就有點浪費內(nèi)存了。

當需要創(chuàng)建大量實例的時候，這個問題變得尤為突出。一種解決方法是在新式類中定義一個__slots__屬性。

__slots__聲明中包含若干實例變量，并為每個實例預(yù)留恰好足夠的空間來保存每個變量；這樣Python就不會再使用dict，從而節(jié)省空間。

那么用slot就是非非常那個有必要嗎？使用__slots__也是有副作用的：

每個繼承的子類都要重新定義一遍__slots__

實例只能包含哪些在__slots__定義的屬性，這對寫程序的靈活性有影響，比如你由于某個原因新網(wǎng)給instance設(shè)置一個新的屬性，比如instance.a = 1, 但是由于a不在__slots__里面就直接報錯了，你得不斷地去修改__slots__或者用其他方法迂回的解決

實例不能有弱引用（weakref）目標，否則要記得把__weakref__放進__slots__

最后，namedlist和attrs提供了自動創(chuàng)建帶__slot__的類，感興趣的可以試試看。

Python還有一個內(nèi)置類型元組，用于表示不可變數(shù)據(jù)結(jié)構(gòu)。 元組是固定的結(jié)構(gòu)或記錄，但沒有字段名稱。 對于字段訪問，使用字段索引。 在創(chuàng)建元組實例時，元組字段一次性與值對象關(guān)聯(lián)：

>>> ob = (1,2,3)
>>> x = ob[0]
>>> ob[1] = y # ERROR

元組的示例很簡潔：

>>> print(sys.getsizeof(ob))
72

可以看只比__slot__多8byte：

通過namedtuple我們也可以實現(xiàn)通過key值來訪問tuple里的元素：

Point = namedtuple("Point", ("x", "y", "z"))

它創(chuàng)建了一個元組的子類，其中定義了用于按名稱訪問字段的描述符。 對于我們的例子，它看起來像這樣:

class Point(tuple):
     #
     @property
     def _get_x(self):
         return self[0]
     @property
     def _get_y(self):
         return self[1]
     @property
     def _get_y(self):
         return self[2]
     #
     def __new__(cls, x, y, z):
         return tuple.__new__(cls, (x, y, z))

此類的所有實例都具有與元組相同的內(nèi)存占用。 大量實例會留下稍大的內(nèi)存占用：

python的第三方庫recordclassd提供了一個數(shù)據(jù)結(jié)構(gòu)recordclass.mutabletuple，它幾乎和內(nèi)置tuple數(shù)據(jù)結(jié)構(gòu)一致，但是占用更少的內(nèi)存。

 >>> Point = recordclass("Point", ("x", "y", "z"))
 >>> ob = Point(1, 2, 3)

實例化以后，只少了PyGC_Head:

到此，我們可以看到，和__slot__比，又進一步縮小了內(nèi)存占用：

recordclass提供了另外一個解決方法：在內(nèi)存中使用與__slots__類相同的存儲結(jié)構(gòu)，但不參與循環(huán)垃圾收集機制。通過recordclass.make_dataclass可以創(chuàng)建出這樣的實例：

>>> Point = make_dataclass("Point", ("x", "y", "z"))

另外一個方法是繼承自dataobject

class Point(dataobject):
    x:int
    y:int
    z:int

以這種方式創(chuàng)建的類將創(chuàng)建不參與循環(huán)垃圾收集機制的實例。 內(nèi)存中實例的結(jié)構(gòu)與__slots__的情況相同，但沒有PyGC_Head：

>>> ob = Point(1,2,3)
>>> print(sys.getsizeof(ob))
40

要訪問這些字段，還使用特殊描述符通過其從對象開頭的偏移量來訪問字段，這些對象位于類字典中：

mappingproxy({"__new__": ,
              .......................................
              "x": ,
              "y": ,
              "z": })

有一種方法基于Cython的使用。 它的優(yōu)點是字段可以采用C語言原子類型的值。例如：

cdef class Python:
    cdef public int x, y, z

 def __init__(self, x, y, z):
      self.x = x
      self.y = y
      self.z = z

這種情況下，占用的內(nèi)存更小：

>>> ob = Point(1,2,3)
>>> print(sys.getsizeof(ob))
32

內(nèi)存結(jié)構(gòu)分布如下:

但是，從Python代碼訪問時，每次都會執(zhí)行從int到Python對象的轉(zhuǎn)換，反之亦然。

在純Python的環(huán)境中，使用Numpy能帶來更好的效果，例如:

>>> Point = numpy.dtype(("x", numpy.int32), ("y", numpy.int32), ("z", numpy.int32)])

創(chuàng)建初始值是0的數(shù)組：

 >>> points = numpy.zeros(N, dtype=Point)

可以看出，在Python性能優(yōu)化這方面，還是有很多事情可以做的。Python提供了方便的同時，也需要暫用較多的資源。在不通的場景下，我需要選擇不同的處理方法，以便帶來更好的性能體驗.

更多有趣的文章，請點擊我的博客