Python 內存優化

ljmo5823 7年前發布 | 35K 次閱讀 Python 優化內存 Python開發

實際項目中，pythoner更加關注的是Python的性能問題，之前也寫過一篇文章《 Python性能優化》介紹Python性能優化的一些方法。而本文，關注的是Python的內存優化，一般說來，如果不發生內存泄露，運行在服務端的Python代碼不用太關心內存，但是如果運行在客戶端（比如移動平臺上），那還是有優化的必要。具體而言，本文主要針對的Cpython，而且不涉及C擴展。

我們知道，Python使用引用技術和垃圾回收來管理內存，底層也有各種類型的內存池，那我們怎么得知一段代碼使用的內存情況呢？工欲善其事必先利其器，直接看windows下的任務管理器或者linux下的top肯定是不準的。

Pytracemalloc

對于基本類型，可以通過sys.getsizeof()來查看對象占用的內存大小。以下是在64位Linux下的一些結果：

>>> import sys
 
>>> sys.getsizeof(1)
24
>>> sys.getsizeof([])
72
>>> sys.getsizeof(())
56
>>> sys.getsizeof({})
280
>>> sys.getsizeof(True)
24

可以看到，即使是一個int類型(1)也需要占用24個字節，遠遠高于C語言中int的范圍。因為Python中一切都是對象，int也不例外（事實上是PyIntObject），除了真正存儲的數值，還需要保存引用計數信息、類型信息，更具體的可以參見《Python源碼剖析》。

而對于更復雜的組合類型，復雜的代碼，使用getsizeof來查看就不準確了，因為在Python中變量僅僅指向一個對象，這個時候就需要更高級的工具，比如 guppy ， pysizer ， pytracemalloc， objgraph 。在這里重點介紹pytracemalloc。

在Python3.4中，已經支持了pytracemalloc，如果使用python2.7版本，則需要對源碼打補丁，然后重新編譯。pytracemalloc在 pep454 中提出，主要有以下幾個特點：

Traceback where an object was allocated
Statistics on allocated memory blocks per filename and per line number: total size, number and average size of allocated memory blocks
Compute the differences between two snapshots to detect memory leaks

簡單來說，pytracemalloc hook住了python申請和釋放內存的接口，從而能夠追蹤對象的分配和回收情況。對內存分配的統計數據可以精確到每個文件、每一行代碼，也可以按照調用棧做聚合分析。而且還支持快照（snapshot）功能，比較兩個快照之間的差異可以發現潛在的內存泄露。

下面通過一個例子來簡單介紹pytracemalloc的用法和接口，關于更詳細用法和API，可以參考這份詳盡的文檔或者pytracemalloc的作者在pycon上的演講ppt 。

import tracemalloc
 
NUM_OF_ATTR =  10
NUM_OF_INSTANCE = 100

class Slots(object):
    __slots__ = ['attr%s'%i for i in range(NUM_OF_ATTR)]
    def __init__(self):
        value_lst = (1.0, True, [], {}, ())
        for i in range(NUM_OF_ATTR):
            setattr(self, 'attr%s'%i, value_lst[i % len(value_lst)])
 
 
class NoSlots(object):
    def __init__(self):
        value_lst = (1.0, True, [], {}, ())
        for i in range(NUM_OF_ATTR):
            setattr(self, 'attr%s'%i, value_lst[i % len(value_lst)])
 
 
 
def generate_some_objs():
    lst = []
    for i in range(NUM_OF_INSTANCE):
        o = Slots() if i % 2 else NoSlots()
        lst.append(o)
    return lst
 
 
if __name__ == '__main__':
    tracemalloc.start(3)
 
    t = generate_some_objs() 
 
    snapshot = tracemalloc.take_snapshot()
    top_stats = snapshot.statistics('lineno') # lineno filename traceback
 
    print(tracemalloc.get_traced_memory())
    for stat in top_stats[:10]:
        print(stat)

在上面的代碼中，用到了pytracemalloc幾個核心的API：

start(nframe: int=1)

pytracemalloc的一大好處就是可以隨時啟停，start函數即開始追蹤內存分配，相應的stop會停止追蹤。start函數有一個參數，nframes : 內存分配時記錄的棧的深度，這個值越大，pytracemalloc本身消耗的內存越多，在計算cumulative數據的時候有用。

    get_traced_memory()

返回值是擁有兩個元素的tuple，第一個元素是當前分配的內存，第二個元素是自內存追蹤啟動以來的內存峰值。

take_snapshot()

返回當前內存分配快照，返回值是Snapshot對象，該對象可以按照單個文件、單行、單個調用棧統計內存分配情況

運行環境：windows 64位python3.4

(62280, 62920)
 
test_pytracemalloc_use_py3.4.py:10: size=16.8 KiB, count=144, average=120 B
test_pytracemalloc_use_py3.4.py:17: size=16.7 KiB, count=142, average=120 B
test_pytracemalloc_use_py3.4.py:19: size=9952 B, count=100, average=100 B
test_pytracemalloc_use_py3.4.py:26: size=9792 B, count=102, average=96 B
test_pytracemalloc_use_py3.4.py:27: size=848 B, count=1, average=848 B
test_pytracemalloc_use_py3.4.py:34: size=456 B, count=1, average=456 B
test_pytracemalloc_use_py3.4.py:36: size=448 B, count=1, average=448 B
D:\Python3.4\lib\tracemalloc.py:474: size=64 B, count=1, average=64 B

如果將第36行的“lineno“改成“filename”，那么結果如下

(62136, 62764)
 
test_pytracemalloc_use_py3.4.py:0: size=54.5 KiB, count=491, average=114 B
D:\Python3.4\lib\tracemalloc.py:0: size=64 B, count=1, average=64 B

有了Profile結果之后，可以看出來在哪個文件中有大量的內存分配。與性能優化相同，造成瓶頸的有兩種情況：單個對象占用了大量的內存；同時大量存在的小對象。對于前者，優化的手段并不多，惰性初始化屬性可能有一些幫助；而對于后者，當同樣類型的對象大量存在時，可以使用slots進行優化。

Slots

默認情況下，自定義的對象都使用dict來存儲屬性（通過obj.__dict__查看），而python中的dict大小一般比實際存儲的元素個數要大（以此降低hash沖突概率），因此會浪費一定的空間。在新式類中使用__slots__，就是告訴Python虛擬機，這種類型的對象只會用到這些屬性，因此虛擬機預留足夠的空間就行了，如果聲明了__slots__，那么對象就不會再有__dict__屬性。

使用slots到底能帶來多少內存優化呢，首先看看這篇文章，對于一個只有三個屬性的Image類，使用__slots__之后內存從25.5G下降到16.2G，節省了9G的空間！

Python 內存優化

到底能省多少，取決于類自身有多少屬性、屬性的類型，以及同時存在多少個類的實例。下面通過一段簡單代碼測試一下：

# -*- coding: utf-8 -*-
import sys
import tracemalloc
 
NUM_OF_ATTR =  3 #3 # 10 # 30 #90
NUM_OF_INSTANCE = 10 # 10 # 100

class Slots(object):
    __slots__ = ['attr%s'%i for i in range(NUM_OF_ATTR)]
    def __init__(self):
        value_lst = (1.0, True, [], {}, ())
        for i in range(NUM_OF_ATTR):
            setattr(self, 'attr%s'%i, value_lst[i % len(value_lst)])
 
 
class NoSlots(object):
    def __init__(self):
        value_lst = (1.0, True, [], {}, ())
        for i in range(NUM_OF_ATTR):
            setattr(self, 'attr%s'%i, value_lst[i % len(value_lst)])
 
if __name__ == '__main__':
    clz = Slots if len(sys.argv) > 1 else NoSlots
    tracemalloc.start()
    objs = [clz() for i in range(NUM_OF_INSTANCE)]
    print(tracemalloc.get_traced_memory()[0])

上面的代碼，主要是在每個實例的屬性數目、并發存在的實例數目兩個維度進行測試，并沒有測試不同的屬性類型。結果如下表：

Python 內存優化

百分比為內存優化百分比，計算公式為(b – a) / b，其中b為沒有使用__slots__時分配的內存， a為使用了__slots__時分配的內存。

注意事項

關于__slots__，Python文檔有非常詳盡的介紹，這里只強調幾點注意事項

第一：基類和子類都必須__slots__，即使基類或者子類沒有屬性

>>> class Base(object):
 
...     pass
...
>>> class Derived(Base):
...     __slots__ = ('a', )
...
>>> d.__slots__
('a',)
>>> getattr(d, '__dict__', 'No Dict')
{}

從上面的示例可以看到，子類的對象還是有__dict__屬性，原因就在于基類沒有聲明__slots__。因此，可以通過看子類的實例有沒有__dict__屬性來判斷slots的使用是否正確

第二：子類會繼承基類的__slots__

更準確的說，如果訪問屬性的時候沒有在子類的__slots__找到，會繼續在基類的__slots__查找，因為Python使用descriptor在類這個層級實現__slots__的，具體可以參見《 python屬性查找深入理解》一文

>>> class Base(object):
 
...     __slots__ = ('a',)
...
>>> class Derived(Base):
...     __slots__ = ('b', )
...
>>> d = Derived()
>>> d.__slots__
('b',)
>>> getattr(d, '__dict__', 'No Dict')
'No Dict'
>>> d.a = 1
>>> d.c = 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Derived' object has no attribute 'c'

objgraph

在大型工程中，怎么排查有哪些大量存在的對象呢，畢竟同一個類型存在的對象越多，優化越有效果。除了直接看代碼，最好使的就是使用objgraph.py的show_most_common_types(N)函數，該函數返回Python gc管理的所有對象中，數目前N多的對象，在排除掉python builtin對象之后，剩下的就是可優化的對象。比如在最上面的代碼中：在最后加上這么兩句：

import objgraph
 
objgraph.show_most_common_types(25)

輸出如下：

Python 內存優化

再論Python dict

前面介紹slots的時候，就提到Python自定義的對象中通過dict來管理屬性。這種機制極大的提高了Python的靈活性 — 可以隨時給對象增加屬性，但是其實現機制也帶來了內存上的浪費。不管是python源碼，還是Python程序，都大量使用了dict，因此這部分內存浪費不容小視。

python中的dict使用的是散列表（類似C++中的std::unordered_map），當計算出的hash值沖突的時候，采用開放地址法解決沖突（另一種常見的沖突解決算法是鏈表法）。為了降低沖突概率，當裝填因子（實際存儲的元素與散列表長度的比值）超過2/3的時候就會對散列表進行擴容，因此散列表中一定會存在一些未使用的槽。

下面簡單看看PyDictObject的數據結構（python2.7.3 dictobject.h）

#define PyDict_MINSIZE 8
 
typedef struct {
    /* Cached hash code of me_key.  Note that hash codes are C longs.
     * We have to use Py_ssize_t instead because dict_popitem() abuses
     * me_hash to hold a search finger.
     */
    Py_ssize_t me_hash;
    PyObject *me_key;
    PyObject *me_value;
} PyDictEntry;
 
 
typedef struct _dictobject PyDictObject;
struct _dictobject {
    PyObject_HEAD
    Py_ssize_t ma_fill;  /* # Active + # Dummy */
    Py_ssize_t ma_used;  /* # Active */
 
    /* The table contains ma_mask + 1 slots, and that's a power of 2.
     * We store the mask instead of the size because the mask is more
     * frequently needed.
     */
    Py_ssize_t ma_mask;
 
    /* ma_table points to ma_smalltable for small tables, else to
     * additional malloc'ed memory.  ma_table is never NULL!  This rule
     * saves repeated runtime null-tests in the workhorse getitem and
     * setitem calls.
     */
    PyDictEntry *ma_table;
    PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
    PyDictEntry ma_smalltable[PyDict_MINSIZE];
};

從定義可以看出，除了固定的部分（幾個Py_ssize_t），PyDictObject中主要是PyDictEntry對象，PyDictEntrty包含一個Py_ssize_t（int）和兩個指針。上面源碼中的注釋（第26行）指出，當dict的元素比較少時，ma_table指向ma_smalltable，當元素增多時，ma_table會指向新申請的空間。ma_smalltable的作用在于Python（不管是源碼還是代碼）都大量使用dict，一般來說，存儲的元素也不會太多，因此Python就先開辟好PyDict_MINSIZE(默認為8)個空間。

為什么說PyDictObject存在浪費呢，PyDictEntry在32位下也有12個字節，那么即使在ma_smalltable（ma_table）中大量的位置沒有被使用時，也要占用這么多字節。用這篇文章中的例子：

假設有這么一個dict：

    d = {'timmy': 'red', 'barry': 'green', 'guido': 'blue'}

在Python源碼中的視圖就是這樣的：

    # 下面的entries就是ma_smalltable
 
entries = [['--', '--', '--'],
           [-8522787127447073495, 'barry', 'green'],
           ['--', '--', '--'],
           ['--', '--', '--'],
           ['--', '--', '--'],
           [-9092791511155847987, 'timmy', 'red'],
           ['--', '--', '--'],
           [-6480567542315338377, 'guido', 'blue']]

然而，完全可以這么存儲：

indices = [None, 1, None, None, None, 0, None, 2]
 
entries =  [[-9092791511155847987, 'timmy', 'red'],
                [-8522787127447073495, 'barry', 'green'],
                [-6480567542315338377, 'guido', 'blue']]

indices的作用類似ma_smalltable，但只存儲一個數組的索引值，數組只存儲實際存在的元素（PyDictEntry），當dict中的元素越稀疏，相比上一種存儲方式使用的內存越少。而且，這種實現， dict就是有序的（按插入時間排序）

這就是python3.6中新的dict實現，Compact dict! Stackoverflow上也有相關討論。

總結

本文中介紹了Python內存優化的Profile工具，最有效的優化方法：使用slots，也介紹了在python3.6中新的dict實現。

當然，還有一些良好的編碼習慣。比如盡量使用immutable而不是mutable對象：使用tuple而不是list，使用frozenset而不是set；另外，就是盡量使用迭代器，比如python2.7中，使用xrange而不是range，dict的iterxx版本。

來自： http://python.jobbole.com/88896/

本文由用戶 ljmo5823 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。

轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。

本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！

本文地址：http://www.baiduhome.net/lib/view/open1511234433647.html

Python 優化內存 Python開發

Python 內存優化

Pytracemalloc

Slots

注意事項

objgraph

再論Python dict

總結

相關經驗

相關資訊

相關文檔

目錄