:func:`setrecursionlimit`.
+.. function:: getsizeof(object)
+
+ Return the size of an object in bytes. The object can be any type of
+ object. All built-in objects will return correct results, but this
+ does not have to hold true for third-party extensions as it is implementation
+ specific.
+
+ .. versionadded:: 2.6
+
+
.. function:: _getframe([depth])
Return a frame object from the call stack. If optional integer *depth* is
# -*- coding: iso-8859-1 -*-
import unittest, test.test_support
-import sys, cStringIO
+import sys, cStringIO, os
class SysModuleTest(unittest.TestCase):
self.assertEqual(out, '?')
+class SizeofTest(unittest.TestCase):
+
+ def setUp(self):
+ import struct
+ self.i = len(struct.pack('i', 0))
+ self.l = len(struct.pack('l', 0))
+ self.p = len(struct.pack('P', 0))
+ self.headersize = self.l + self.p
+ if hasattr(sys, "gettotalrefcount"):
+ self.headersize += 2 * self.p
+ self.file = open(test.test_support.TESTFN, 'wb')
+
+ def tearDown(self):
+ self.file.close()
+ os.remove(test.test_support.TESTFN)
+
+ def check_sizeof(self, o, size):
+ result = sys.getsizeof(o)
+ msg = 'wrong size for %s: got %d, expected %d' \
+ % (type(o), result, size)
+ self.assertEqual(result, size, msg)
+
+ def align(self, value):
+ mod = value % self.p
+ if mod != 0:
+ return value - mod + self.p
+ else:
+ return value
+
+ def test_align(self):
+ self.assertTrue( (self.align(0) % self.p) == 0 )
+ self.assertTrue( (self.align(1) % self.p) == 0 )
+ self.assertTrue( (self.align(3) % self.p) == 0 )
+ self.assertTrue( (self.align(4) % self.p) == 0 )
+ self.assertTrue( (self.align(7) % self.p) == 0 )
+ self.assertTrue( (self.align(8) % self.p) == 0 )
+ self.assertTrue( (self.align(9) % self.p) == 0 )
+
+ def test_standardtypes(self):
+ i = self.i
+ l = self.l
+ p = self.p
+ h = self.headersize
+ # bool
+ self.check_sizeof(True, h + l)
+ # buffer
+ self.check_sizeof(buffer(''), h + 2*p + 2*l + self.align(i) +l)
+ # bytearray
+ self.check_sizeof(bytes(), h + self.align(i) + l + p)
+ # cell
+ def get_cell():
+ x = 42
+ def inner():
+ return x
+ return inner
+ self.check_sizeof(get_cell().func_closure[0], h + p)
+ # old-style class
+ class class_oldstyle():
+ def method():
+ pass
+ self.check_sizeof(class_oldstyle, h + 6*p)
+ # instance
+ self.check_sizeof(class_oldstyle(), h + 3*p)
+ # method
+ self.check_sizeof(class_oldstyle().method, h + 4*p)
+ # code
+ self.check_sizeof(get_cell().func_code, h + self.align(4*i) + 8*p +\
+ self.align(i) + 2*p)
+ # complex
+ self.check_sizeof(complex(0,1), h + 2*8)
+ # enumerate
+ self.check_sizeof(enumerate([]), h + l + 3*p)
+ # reverse
+ self.check_sizeof(reversed(''), h + l + p )
+ # file
+ self.check_sizeof(self.file, h + 4*p + self.align(2*i) + 4*p +\
+ self.align(3*i) + 3*p + self.align(i))
+ # float
+ self.check_sizeof(float(0), h + 8)
+ # function
+ def func(): pass
+ self.check_sizeof(func, h + 9 * l)
+ class c():
+ @staticmethod
+ def foo():
+ pass
+ @classmethod
+ def bar(cls):
+ pass
+ # staticmethod
+ self.check_sizeof(foo, h + l)
+ # classmethod
+ self.check_sizeof(bar, h + l)
+ # generator
+ def get_gen(): yield 1
+ self.check_sizeof(get_gen(), h + p + self.align(i) + 2*p)
+ # integer
+ self.check_sizeof(1, h + l)
+ # builtin_function_or_method
+ self.check_sizeof(abs, h + 3*p)
+ # module
+ self.check_sizeof(unittest, h + p)
+ # xange
+ self.check_sizeof(xrange(1), h + 3*p)
+ # slice
+ self.check_sizeof(slice(0), h + 3*p)
+
+ h += l
+ # new-style class
+ class class_newstyle(object):
+ def method():
+ pass
+ # type (PyTypeObject + PyNumberMethods + PyMappingMethods +
+ # PySequenceMethods + PyBufferProcs)
+ len_typeobject = p + 2*l + 15*p + l + 4*p + l + 9*p + l + 11*p
+ self.check_sizeof(class_newstyle, h + \
+ len_typeobject + 42*p + 10*p + 3*p + 6*p)
+
+
+ def test_specialtypes(self):
+ i = self.i
+ l = self.l
+ p = self.p
+ h = self.headersize
+ # dict
+ self.check_sizeof({}, h + 3*l + 3*p + 8*(l + 2*p))
+ longdict = {1:1, 2:2, 3:3, 4:4, 5:5, 6:6, 7:7, 8:8}
+ self.check_sizeof(longdict, h + 3*l + 3*p + 8*(l + 2*p) + 16*(l + 2*p))
+ # list
+ self.check_sizeof([], h + l + p + l)
+ self.check_sizeof([1, 2, 3], h + l + p + l + 3*l)
+
+ h += l
+ # long
+ self.check_sizeof(0L, h + self.align(2))
+ self.check_sizeof(1L, h + self.align(2))
+ self.check_sizeof(-1L, h + self.align(2))
+ self.check_sizeof(32768L, h + self.align(2) + 2)
+ self.check_sizeof(32768L*32768L-1, h + self.align(2) + 2)
+ self.check_sizeof(32768L*32768L, h + self.align(2) + 4)
+ # string
+ self.check_sizeof('', h + l + self.align(i + 1))
+ self.check_sizeof('abc', h + l + self.align(i + 1) + 3)
+
+
def test_main():
- test.test_support.run_unittest(SysModuleTest)
+ test_classes = (SysModuleTest, SizeofTest)
+
+ test.test_support.run_unittest(*test_classes)
if __name__ == "__main__":
test_main()
Core and Builtins
-----------------
+- Issue #2898: Added sys.getsizeof() to retrieve size of objects in bytes.
+
- New environment variable PYTHONIOENCODING.
- Patch #2488: Add sys.maxsize.
return NULL;
}
+PyDoc_STRVAR(sizeof__doc__,
+"S.__sizeof__() -> size of S in bytes");
+
+static PyObject *
+string_sizeof(PyBytesObject *v)
+{
+ Py_ssize_t res;
+ res = sizeof(PyBytesObject) + v->ob_size * v->ob_type->tp_itemsize;
+ return PyInt_FromSsize_t(res);
+}
+
#undef SPLIT_APPEND
#undef SPLIT_ADD
#undef MAX_PREALLOC
expandtabs__doc__},
{"splitlines", (PyCFunction)string_splitlines, METH_VARARGS,
splitlines__doc__},
+ {"__sizeof__", (PyCFunction)string_sizeof, METH_NOARGS,
+ sizeof__doc__},
{"__getnewargs__", (PyCFunction)string_getnewargs, METH_NOARGS},
{NULL, NULL} /* sentinel */
};
return dictiter_new(dict, &PyDictIterItem_Type);
}
+static PyObject *
+dict_sizeof(PyDictObject *mp)
+{
+ Py_ssize_t res;
+
+ res = sizeof(PyDictObject) + sizeof(mp->ma_table);
+ if (mp->ma_table != mp->ma_smalltable)
+ res = res + (mp->ma_mask + 1) * sizeof(PyDictEntry);
+ return PyInt_FromSsize_t(res);
+}
PyDoc_STRVAR(has_key__doc__,
"D.has_key(k) -> True if D has a key k, else False");
PyDoc_STRVAR(getitem__doc__, "x.__getitem__(y) <==> x[y]");
+PyDoc_STRVAR(sizeof__doc__,
+"D.__sizeof__() -> size of D in bytes");
+
PyDoc_STRVAR(get__doc__,
"D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.");
contains__doc__},
{"__getitem__", (PyCFunction)dict_subscript, METH_O | METH_COEXIST,
getitem__doc__},
+ {"__sizeof__", (PyCFunction)dict_sizeof, METH_NOARGS,
+ sizeof__doc__},
{"has_key", (PyCFunction)dict_has_key, METH_O,
has_key__doc__},
{"get", (PyCFunction)dict_get, METH_VARARGS,
return 0;
}
+static PyObject *
+list_sizeof(PyListObject *self)
+{
+ Py_ssize_t res;
+
+ res = sizeof(PyListObject) + self->allocated * sizeof(void*);
+ return PyInt_FromSsize_t(res);
+}
+
static PyObject *list_iter(PyObject *seq);
static PyObject *list_reversed(PyListObject* seq, PyObject* unused);
"x.__getitem__(y) <==> x[y]");
PyDoc_STRVAR(reversed_doc,
"L.__reversed__() -- return a reverse iterator over the list");
+PyDoc_STRVAR(sizeof_doc,
+"L.__sizeof__() -- size of L in bytes");
PyDoc_STRVAR(append_doc,
"L.append(object) -- append object to end");
PyDoc_STRVAR(extend_doc,
static PyMethodDef list_methods[] = {
{"__getitem__", (PyCFunction)list_subscript, METH_O|METH_COEXIST, getitem_doc},
{"__reversed__",(PyCFunction)list_reversed, METH_NOARGS, reversed_doc},
+ {"__sizeof__", (PyCFunction)list_sizeof, METH_NOARGS, sizeof_doc},
{"append", (PyCFunction)listappend, METH_O, append_doc},
{"insert", (PyCFunction)listinsert, METH_VARARGS, insert_doc},
{"extend", (PyCFunction)listextend, METH_O, extend_doc},
return NULL;
}
+static PyObject *
+long_sizeof(PyLongObject *v)
+{
+ Py_ssize_t res;
+
+ res = sizeof(PyLongObject) + abs(v->ob_size) * sizeof(digit);
+ if (v->ob_size != 0)
+ res -= sizeof(digit);
+ return PyInt_FromSsize_t(res);
+}
+
#if 0
static PyObject *
long_is_finite(PyObject *v)
"Truncating an Integral returns itself."},
{"__getnewargs__", (PyCFunction)long_getnewargs, METH_NOARGS},
{"__format__", (PyCFunction)long__format__, METH_VARARGS},
+ {"__sizeof__", (PyCFunction)long_sizeof, METH_NOARGS,
+ "Returns size in bytes"},
{NULL, NULL} /* sentinel */
};
return result;
}
+static PyObject *
+object_sizeof(PyObject *self, PyObject *args)
+{
+ Py_ssize_t res, isize;
+
+ res = 0;
+ isize = self->ob_type->tp_itemsize;
+ if (isize > 0)
+ res = self->ob_type->ob_size * isize;
+ res += self->ob_type->tp_basicsize;
+
+ return PyInt_FromSsize_t(res);
+}
+
static PyMethodDef object_methods[] = {
{"__reduce_ex__", object_reduce_ex, METH_VARARGS,
PyDoc_STR("helper for pickle")},
object_subclasshook_doc},
{"__format__", object_format, METH_VARARGS,
PyDoc_STR("default object formatter")},
+ {"__sizeof__", object_sizeof, METH_NOARGS,
+ PyDoc_STR("__sizeof__() -> size of object in bytes")},
{0}
};
}
#endif /* USE_MALLOPT */
+static PyObject *
+sys_getsizeof(PyObject *self, PyObject *args)
+{
+ static PyObject * str__sizeof__ = NULL;
+
+ /* Initialize static variable needed by _PyType_Lookup */
+ if (str__sizeof__ == NULL) {
+ str__sizeof__ = PyString_InternFromString("__sizeof__");
+ if (str__sizeof__ == NULL)
+ return NULL;
+ }
+
+ /* Type objects */
+ if (PyType_Check(args)){
+ PyObject *method = _PyType_Lookup(Py_TYPE(args),
+ str__sizeof__);
+ if (method == NULL) {
+ PyErr_Format(PyExc_TypeError,
+ "Type %.100s doesn't define __sizeof__",
+ Py_TYPE(args)->tp_name);
+ return NULL;
+ }
+ return PyObject_CallFunctionObjArgs(method, args, NULL);
+ }
+ /* Instance of old-style classes */
+ else if(PyInstance_Check(args))
+ return PyInt_FromSsize_t(PyInstance_Type.tp_basicsize);
+ /* Old-style class */
+ else if (PyClass_Check(args))
+ return PyInt_FromSsize_t(PyClass_Type.tp_basicsize);
+ else
+ return PyObject_CallMethod(args, "__sizeof__", NULL);
+}
+
+PyDoc_STRVAR(getsizeof_doc,
+"getsizeof(object) -> int\n\
+\n\
+Return the size of object in bytes.");
+
static PyObject *
sys_getrefcount(PyObject *self, PyObject *arg)
{
{"getrefcount", (PyCFunction)sys_getrefcount, METH_O, getrefcount_doc},
{"getrecursionlimit", (PyCFunction)sys_getrecursionlimit, METH_NOARGS,
getrecursionlimit_doc},
+ {"getsizeof", sys_getsizeof, METH_O, getsizeof_doc},
{"_getframe", sys_getframe, METH_VARARGS, getframe_doc},
#ifdef MS_WINDOWS
{"getwindowsversion", (PyCFunction)sys_getwindowsversion, METH_NOARGS,
getprofile() -- get the global profiling function\n\
getrefcount() -- return the reference count for an object (plus one :-)\n\
getrecursionlimit() -- return the max recursion depth for the interpreter\n\
+getsizeof() -- return the size of an object in bytes\n\
gettrace() -- get the global debug tracing function\n\
setcheckinterval() -- control how often the interpreter checks for events\n\
setdlopenflags() -- set the flags to be used for dlopen() calls\n\
projects / python / commitdiff