Determining the Size of an Object in Python


When writing code, you may need to determine how much memory a particular object is consuming. There are a number of reasons you may need to know this, with the most obvious reason being storage capacity constraints. This Byte will show you how to determine the size of an object in Python. We'll do this primarily with Python's built-in sys.getsizeof() function.

Why Determine the Size of an Object?

Figuring out the size of an object in Python can be quite useful, especially when dealing with large data sets or complex objects. Knowing the size of an object can help optimize your code to reduce memory usage, which can lead to better performance. Plus, it can help you troubleshoot issues related to memory consumption.

For example, if your application is running out of memory and crashing, determining the size of objects can help you pinpoint the objects using up the most memory. This can be a lifesaver when you're dealing with memory-intensive tasks.

Using sys.getsizeof() to Determine the Size

Python provides a built-in function, sys.getsizeof(), which can be used to determine the size of an object. This function returns the size in bytes.

Here's a simple example:

import sys

# Create a list
my_list = [1, 2, 3, 4, 5]

# Determine the size of the list
size = sys.getsizeof(my_list)

print(f"The size of the list is {size} bytes.")

When you run this code, you'll see an output like this:

$ python3
The size of the list is 104 bytes.

In this example, sys.getsizeof() returns the size of the list object my_list in bytes.

Variations of sys.getsizeof()

While sys.getsizeof() can be very useful, you should understand that it does not always provide the complete picture when it comes to the size of an object.

Note: sys.getsizeof() only returns the immediate memory consumption of an object, but it does not include the memory consumed by other objects it refers to.

For example, if you have a list of lists, sys.getsizeof() will only return the size of the outer list, not the total size including the inner lists.

import sys

# Create a list of lists
my_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

# Determine the size of the list
size = sys.getsizeof(my_list)

print(f"The size of the list is {size} bytes.")

When you run this code, you'll see an output like this:

$ python3
The size of the list is 80 bytes.

As you can see, sys.getsizeof() returns the size of the outer list, but not the size of the inner lists. This is something to keep in mind when using sys.getsizeof() to determine the size of complex objects in Python.

Get free courses, guided projects, and more

No spam ever. Unsubscribe anytime. Read our Privacy Policy.

In this case, you'll need to get the size of the outer list and each inner list. A recursive approach would help you get a more accurate number.

Using pympler.asizeof() for More Accurate Object Sizes

While sys.getsizeof() is a built-in method in Python, it doesn't always provide the most accurate results, particularly for complex objects. To get a more precise measure, we can use the asizeof() function from the Pympler library.

Pympler is a development tool for measuring, monitoring, and analyzing the memory behavior of Python objects in a running Python application.

To use asizeof(), you'll need to first install Pympler using pip:

$ pip3 install pympler

Once installed, you can use asizeof() like this:

from pympler import asizeof

my_list = list(range(1000))

In this example, asizeof() will return the total size of my_list, including all of its elements.

Unlike sys.getsizeof(), asizeof() includes the sizes of nested objects in its calculations, making it a more accurate tool for determining the size of complex objects.

Comparing sys.getsizeof() and pympler.asizeof()

Let's compare the results of sys.getsizeof() and asizeof() for a complex object, like a dictionary with several key-value pairs.

import sys
from pympler import asizeof

my_dict = {i: str(i) for i in range(1000)}

print('sys.getsizeof():', sys.getsizeof(my_dict))
print('asizeof():', asizeof.asizeof(my_dict))
$ python3
sys.getsizeof(): 36960
asizeof(): 124952

As you can see, asizeof() returns a value that is over 3.3 times larger than what is returned by sys.getsizeof(). This is because sys.getsizeof() only measures the memory consumed by the dictionary itself, not all of the contents it contains. On the other hand, asizeof() measures the total size, including the dictionary and all its contents.

Dealing with Memory Management in Python

Python's memory management can sometimes be a bit opaque, particularly for new developers. The language does much of the heavy lifting automatically, such as allocating and deallocating memory (which is also why so many people prefer to use it). However, understanding how Python uses memory can help you write more efficient code.

One important thing to note is that Python uses a system of reference counting for memory management. This means that Python automatically keeps track of the number of references to an object in memory. When an object's reference count drops to zero, Python knows it can safely deallocate that memory.

Side Note: Python's garbage collector comes into play when there are circular references - that is, when a group of objects reference each other, but are not referenced anywhere else. In a case like this, even though their reference count is not technically zero, they can still be safely removed from memory.


Understanding how to measure the size of objects in Python can be a useful tool in optimizing or even debugging your code, particularly for applications that handle large amounts of data. While Python's built-in sys.getsizeof() function can be useful, the asizeof() function from the Pympler library offers a more accurate measure for complex objects.

Last Updated: September 8th, 2023
Was this helpful?

Ā© 2013-2024 Stack Abuse. All rights reserved.