python类对象内存分析_python 对象内存分析

python对象内存分析

一、python内建对象

python内建对象占用内存的情况又分为定长对象与非定长对象(变长)

1.1 定长对象,对象在内存中所占大小不会变化的对象

包括int，float，long，bool，complex和dict

测试程序如下：

#!/usr/bin/env python

#-*- coding:utf-8 -*-

import sys

print "value\t\ttype\t\tmemsize"

#int test

alist=[0,1,10,-1,-444,12313]

for i in alist:

print "%d\t\t%s\t\t%s"%(i,type(i),sys.getsizeof(i))

#float test

blist=[0.0,1.0,111.1,2323.22,-1.1]

for i in blist:

print "%f\t\t%s\t\t%s"%(i,type(i),sys.getsizeof(i))

#long test

clist=[0l,1l,2l,-1111l,45445l]

for i in clist:

print "%d\t\t%s\t\t%s"%(i,type(i),sys.getsizeof(i))

#bool test

dlist=[True,False]

for i in dlist:

print "%s\t\t%s\t\t%s"%(i,type(i),sys.getsizeof(i))

#complex test

elist=[0j,1+0j,1+1j,1000-23j,-100+5j]

for i in elist:

print i,"\t\t%s\t\t%s"%(type(i),sys.getsizeof(i))

#dict test

flist=[{},{'a':'b'},{'a':'b','c':1},{'a':'b','c':1,'d':'你好'}]

for i in flist:

print i,"\t\t%s\t\t%s"%(type(i),sys.getsizeof(i))

运行结果如下：

valuetypememsize

024

124

1024

-124

-44424

1231324

0.00000024

1.00000024

111.10000024

2323.22000024

-1.10000024

024

128

228

-111128

4544528

True24

False24

0j 32

(1+0j) 32

(1+1j) 32

(1000-23j) 32

(-100+5j) 32

{} 280

{'a': 'b'} 280

{'a': 'b', 'c': 1} 280

{'a': 'b', 'c': 1, 'd': '\xe4\xbd\xa0\xe5\xa5\xbd'} 280

有运行结果可以看出各个定长对象所占的内存：

int和float：24

long：这个有点特殊，对于0l，python识别为long type，但是所占内存是24,除了0l所占内存为24以外，其他的都为28

complex(复数):32

dict(字典):280

1.2 变成对象，会随着对象变化所占用的内存会变化

包括：list，tuple，str

测试代码：

#/usr/bin/env python

#-*- coding: utf-8 -*-

import sys

#str test

print "str-length\ttype\tmemsize"

ua='你好'

ga=ua.decode('utf-8').encode('gbk')

ba=ua.decode('utf-8').encode('big5')

ga1=ua.decode('utf-8').encode('gb2312')

alist=['','a','ab',ua,ga,ba,ga1]

for s in alist:

print "%d\t%s\t%s"%(len(s),type(s),sys.getsizeof(s))

print "list-length\ttype\tmemsize"

#list test

alist=[[],['a','b'],['abc','你好'],[11,12,'eee']]

for li in alist:

print "%d\t%s\t%s"%(len(li),type(li),sys.getsizeof(li))

print "%d\t%s\t%s"%(len(alist),type(alist),sys.getsizeof(alist))

#tuple test

print "tuple-len\ttype\tmemsize"

alist=((),('a',),('abc','你好'),(11,12,'eeee'))

for tp in alist:

print "%d\t%s\t%s"%(len(tp),type(tp),sys.getsizeof(tp))

print "%d\t%s\t%s"%(len(alist),type(alist),sys.getsizeof(alist))

结果：

str-lengthtypememsize

037

138

239

643

441

441

441

list-lengthtypememsize

072

288

288

396

4104

tuple-lentypememsize

056

164

272

380

488

分析结果可知：

str：空str所占内存为37,若str长度每加1,则内存所占大小相应加1

list：空列表所占内存为72,长度每增加1,则所占内存加8

tuple：空元组所占内存为56,长度每加1,所占了内存加8

空字符串为什么是37,而不是36或38,因为这里介绍所有的对像内存都为偶数，python内部维护字符串的机制和C中维护字符串的机制是一样的，即在末尾加'\0',这个占了1个字节，所以内存大小表现为36+1=37

补充：

python中还有一个比较特殊的对象，就是类型对像

>>> tlist=(int,float,long,str,complex,dict,list,tuple,bool,type)

>>> for i in tlist:

... print sys.getsizeof(i)

...

872

872

872

872

872

872

872

872

872

872

类型对象也是定长的为872

基类对象object所占内存也为872

二、自建对象

测试程序：

#!/usr/bin/env python

import sys

class A:

def __init__(self):

self.value=2

def test(self):

print self.value

class B(object):

def test(self):

print "test"

class C(float):

def __init__(self):

self.value=1

def test(self):

print self.value

class D(object):

pass

class E(A):

pass

print "A :%s\t%s"%(type(A),sys.getsizeof(A))

print "A():%s\t%s"%(type(A()),sys.getsizeof(A()))

print "B :%s\t%s"%(type(B),sys.getsizeof(B))

print "B():%s\t%s"%(type(B()),sys.getsizeof(B()))

print "C :%s\t%s"%(type(C),sys.getsizeof(C))

print "C():%s\t%s"%(type(C()),sys.getsizeof(C()))

print "D :%s\t%s"%(type(D),sys.getsizeof(D))

print "D():%s\t%s"%(type(D()),sys.getsizeof(D()))

print "E :%s\t%s"%(type(E),sys.getsizeof(E))

print "E():%s\t%s"%(type(E()),sys.getsizeof(E()))

结果：

A :104

A():72

B :904

B():64

C :904

C():72

D :904

D():64

E :104

E():72

有结果可以看出：

A和E对象没有继承类型对象，未申明基类的情况下,类型python解释为’classobj',所占内存为104,实例化后类型为instance 内存为72

BD对象都是继承自基类object，类型为type，所占内存为904,实例化后类型为class，所占内存为64

C对象继承自类型对象 float，类型为type，所占内存为904，实例化后类型为class，所占内存为72

PS：object是所有对象的基类，python中所有对象都继承自object