如何優化Python佔用的內存

概述

若是程序處理的數據比較多、比較複雜，那麼在程序運行的時候，會佔用大量的內存，當內存佔用到達必定的數值，程序就有可能被操做系統終止，特別是在限制程序所使用的內存大小的場景，更容易發生問題。下面我就給出幾個優化Python佔用內存的幾個方法。

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

舉個栗子

咱們舉個簡單的場景，使用Python存儲一個三維座標數據，x,y,z。

Dict

使用Python內置的數據結構Dict來實現上述例子的需求很簡單。

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

查看如下ob這個對象佔用的內存大小：

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

簡單的三個整數，佔用的內存還真很多，想象如下，若是有大量的這樣的數據要存儲，會佔用更大的內存。

數據量	佔用內存大小
1 000 000	240 Mb
10 000 000	2.40 Gb
100 000 000	24 Gb

Class

對於喜歡面向對象編程的程序員來講，更喜歡把數據包在一個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的數據結構和Dict區別就很大了，咱們來看看這種狀況下佔用內存的狀況：

字段	佔用內存
PyGC_Head	24
PyObject_HEAD	16
_weakref_	8
_dict_	8
TOTAL	56

關於 __weakref__（弱引用）能夠查看這個文檔，　對象的__dict__中存儲了一些self.xxx的一些東西。從Python 3.3開始，key使用了共享內存存儲， 減小了RAM中實例跟蹤的大小。

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

數據量	佔用內存
1 000 000	168 Mb
10 000 000	1.68 Gb
100 000 000	16.8 Gb

能夠看到內存佔用量，class比dict少了一些，但這遠遠不夠。

_slots_

從class的內存佔用分佈上，咱們能夠發現，經過消除__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

能夠看到內存佔用顯著的減小了

字段	內存佔用
PyGC_Head	24
PyObject_HEAD	16
x	8
y	8
z	8
TOTAL	64

數據量	佔用內存
1 000 000	64Mb
10 000 000	640Mb
100 000 000	6.4Gb

默認狀況下,Python的新式類和經典類的實例都有一個dict來存儲實例的屬性。這在通常狀況下還不錯，並且很是靈活，乃至在程序中能夠隨意設置新的屬性。可是，對一些在」編譯」前就知道有幾個固定屬性的小class來講，這個dict就有點浪費內存了。

當須要建立大量實例的時候，這個問題變得尤其突出。一種解決方法是在新式類中定義一個__slots__屬性。

__slots__聲明中包含若干實例變量，併爲每一個實例預留剛好足夠的空間來保存每一個變量；這樣Python就不會再使用dict，從而節省空間。

那麼用slot就是非很是那個有必要嗎？使用__slots__也是有反作用的：

1. 每一個繼承的子類都要從新定義一遍__slots__
2. 實例只能包含哪些在__slots__定義的屬性，這對寫程序的靈活性有影響，好比你因爲某個緣由新網給instance設置一個新的屬性，好比instance.a = 1, 可是因爲a不在__slots__裏面就直接報錯了，你得不斷地去修改__slots__或者用其餘方法迂迴的解決
3. 實例不能有弱引用（weakref）目標，不然要記得把__weakref__放進__slots__

最後，namedlist和attrs提供了自動建立帶__slot__的類，感興趣的能夠試試看。

Tuple

Python還有一個內置類型元組，用於表示不可變數據結構。 元組是固定的結構或記錄，但沒有字段名稱。 對於字段訪問，使用字段索引。 在建立元組實例時，元組字段一次性與值對象關聯：

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

元組的示例很簡潔：

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

能夠看只比__slot__多8byte：

字段	佔用內存(bytes)
PyGC_Head	24
PyObject_HEAD	16
ob_size	8
[0]	8
[1]	8
[2]	8
TOTAL	72

Namedtuple

經過namedtuple咱們也能夠實現經過key值來訪問tuple裏的元素：

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

它建立了一個元組的子類，其中定義了用於按名稱訪問字段的描述符。 對於咱們的例子，它看起來像這樣:

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))

此類的全部實例都具備與元組相同的內存佔用。 大量實例會留下稍大的內存佔用：

數據量	內存佔用
1 000 000	72 Mb
10 000 000	720 Mb
100 000 000	7.2 Gb

Recordclass

python的第三方庫recordclassd提供了一個數據結構recordclass.mutabletuple，它幾乎和內置tuple數據結構一致，可是佔用更少的內存。

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

實例化之後，只少了PyGC_Head:

字段	佔用內存
PyObject_HEAD	16
ob_size	8
x	8
y	8
y	8
TOTAL	48

到此，咱們能夠看到，和__slot__比，又進一步縮小了內存佔用：

數據量	內存佔用
1 000 000	48 Mb
10 000 000	480 Mb
100 000 000	4.8 Gb

Dataobject

recordclass提供了另一個解決方法：在內存中使用與__slots__類相同的存儲結構，但不參與循環垃圾收集機制。經過recordclass.make_dataclass能夠建立出這樣的實例：

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

另一個方法是繼承自dataobject

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

以這種方式建立的類將建立不參與循環垃圾收集機制的實例。 內存中實例的結構與__slots__的狀況相同，但沒有PyGC_Head：

字段	內存佔用(bytes)
PyObject_HEAD	16
x	8
y	8
y	8
TOTAL	40

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

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

mappingproxy({'__new__': <staticmethod at 0x7f203c4e6be0>,
              .......................................
              'x': <recordclass.dataobject.dataslotgetset at 0x7f203c55c690>,
              'y': <recordclass.dataobject.dataslotgetset at 0x7f203c55c670>,
              'z': <recordclass.dataobject.dataslotgetset at 0x7f203c55c410>})

數據量	內存佔用
1 000 000	40 Mb
10 000 000	400 Mb
100 000 000	4.0 Gb

Cython

有一種方法基於Cython的使用。 它的優勢是字段能夠採用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

這種狀況下，佔用的內存更小：

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

內存結構分佈以下:

字段	內存佔用(bytes)
PyObject_HEAD	16
x	4
y	4
y	4
пусто	4
TOTAL	32

數據量	內存佔用
1 000 000	32 Mb
10 000 000	320 Mb
100 000 000	3.2 Gb

可是，從Python代碼訪問時，每次都會執行從int到Python對象的轉換，反之亦然。

Numpy

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

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

建立初始值是0的數組：

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

數據量	內存佔用
1 000 000	12 Mb
10 000 000	120 Mb
100 000 000	1.2 Gb

最後

能夠看出，在Python性能優化這方面，仍是有不少事情能夠作的。Python提供了方便的同時，也須要暫用較多的資源。在不通的場景下，我須要選擇不一樣的處理方法，以便帶來更好的性能體驗.

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