Python内存分配

python中对象内存分配的秘密:
http://note.youdao.com/noteshare?id=4f2a12ca09e6ec21d3ea03d05e2744e9

sys模块是Python比较基础且十分重要的模块
功能: 提供程解释器使用(或者由他维护)的变量,以及和解释器交互的函数

sys模块中的getsizeof()函数用户获取对象所占直接内存字节大小(byte),不计算对象内部引用对象占用内存大小
1.首先咱们验证一下上面这句话;

In [2]: import sys                                                                                                                                                        
In [3]: a = [1,2]                                                                                                                                                         
In [4]: b = [a,a]                                                                                                                                                         
In [5]: sys.getsizeof(a)                                                                                                                                                  
Out[5]: 80
In [6]: sys.getsizeof(b)                                                                                                                                                  
Out[6]: 80
In [7]: a                                                                                                                                                                 
Out[7]: [1, 2]
In [8]: b                                                                                                                                                                 
Out[8]: [[1, 2], [1, 2]]
能够看到上面数组,a,b两个列表内部只有两个元素,虽然b列表引用了列表a,可是它所占字节大小a同样,这样就说明了getsizeof()方法是计算当前对象直接所占内存字节大小,不会计算其内部引用.

2,python中空对象所占内存字节

In [4]: sys.getsizeof('')   # 空字符                                                                                                                                                
Out[4]: 49
In [5]: sys.getsizeof([])   # 空列表                                                                                                                                              
Out[5]: 64
In [6]: sys.getsizeof({})   # 空字典                                                                                                                                              
Out[6]: 240
In [7]: sys.getsizeof(())   # 空元组                                                                                                                                             
Out[7]: 48
In [8]: sys.getsizeof(set())# 空集合                                                                                                                                            
Out[8]: 224

占用内存字节对象排序: 基础数字 < 空元祖 < 空字符串 < 空列表 < 空集合 < 空字典
为何空对象也会占用内存?
解释: 咱们能够理解为上述对象都是容器,python在建立的时候分配一部分内存用于对象自己信息的记录,好比(容器结构,引用计数,使用信息等),另外一部分用于预分配内存

3.Boolen值占用内存字节数

In [15]: sys.getsizeof(0)                                                                                                                                                 
Out[15]: 24
In [16]: sys.getsizeof(False)                                                                                                                                             
Out[16]: 24
In [17]: sys.getsizeof(1)                                                                                                                                                 
Out[17]: 28
In [18]: sys.getsizeof(True)                                                                                                                                              
Out[18]: 28
经过上面样例咱们能够看到,布尔值对象的内存所占字节大小和数字0,1是同样的,应为在Boolen中True和1,False和0,表明的含义是同样的,只是表现形式不同

4.python的内存分配机制:
(1).超额分配机制:对象在申请内存时候,会多分配一部分内存,当有新的元素加入到对象中,就不会再去请求内存分配,直接使用以前超额分配的内存,这样的话就保证了对象老是会有多余的内存容纳新加入的元素,而不用在加入对象时候再去申请内存操做,提升对象的内存分配性能.
(2).非均匀分配机制; 在分配内存的时候每次分配的内存大小是不同的,保证了不一样元素加入时候,对象中超额的内存老是可以容纳新的元素,不用再加入的时候去申请内存.