這篇文章主要給大家介紹了關於Python佔用的內存優化教程，文中通過示例代碼介紹的非常詳細，對大家學習或者使用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也是有副作用的：
- 每個繼承的子類都要重新定義一遍slots
- 實例只能包含哪些在slots定義的屬性，這對寫程序的靈活性有影響，比如你由於某個原因新網給instance設置一個新的屬性，比如instance.a = 1, 但是由於a不在slots裏面就直接報錯了，你得不斷地去修改slots或者用其他方法迂迴的解決
- 實例不能有弱引用（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提供了方便的同時，也需要暫用較多的資源。在不通的場景下，我需要選擇不同的處理方法，以便帶來更好的性能體驗。
好了，以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，謝謝大家對神馬文庫的支持。