# How to Get the Size of a Python Object (Examples & Theory)

To get the size of a Python object, you can use the `getsizeof()` function from the `sys` module. This function returns the size of an object in bytes.

For example, let’s print the size of a list and the size of an integer:

```import sys

l = [1, 2, 3, 4, 5]

# Get the size of the object in bytes
object_size = sys.getsizeof(l)

print(object_size)
print(12)```

Output:

```96
12```

⚠️ Keep in mind that `sys.getsizeof()` function only returns the size of the object itself. It does NOT take into account the size of inner objects. For instance, measuring the size of a list of lists with `getsizeof()` method will only return the size of the outer list and not take into account the sizes of the inner lists.

## The Big Issue with sys.getsizeof() Function

To illustrate the problem that arises when measuring object sizes with `sys.getsizeof()` function:

• Let’s measure the size of a list of numbers.
• Let’s compare the size to a list that consists of 5 lists of numbers.

Here’s the code:

```import sys

nums = [1, 2, 3, 4, 5]
print(sys.getsizeof(nums))

more_nums = [
[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5]
]
print(sys.getsizeof(more_nums))```

By looking at the above, you would expect `more_nums` to be bigger in size than `nums`. This is because `more_nums` is a list that has 5 similar lists to the `nums` list.

But here’s what the output says:

```96
96```

What?! The sizes of the lists are the same even though they’re clearly different sizes.

As a matter of fact, the list length will always be the same as long as the number of objects is the same.

For example, let’s measure the size of a list of 5 characters:

```import sys

nums = ['t', 'e', 's', 't', 's']
print(sys.getsizeof(nums))```

Output:

`96`

The `sys.getsizeof()` function only works when measuring the size of a built-in object. But if you’re interested in the true size of the object among its contents objects, you need to pick a different approach.

## How to Measure the True Size of a Python Object?

Because of the limitations in `sys.getsizeof()` function, you won’t be able to determine the size of a nested object in Python. For example, you won’t be able to measure the size of a list of lists or a list of strings reliably.

A better way to calculate the size of a Python object is to use a recursive function that iterates the objects of the objects to check their size to accumulate the total size of the object.

To keep it in scope, we’re not going to write such a recursive function.

Instead, you can use an existing solution called Pympler, which is a free Python package you can install with pip.

`\$ pip install pympler`

With `pympler` installed, you can start estimating the size of your Python objects by using the `pympler.asizeof.asizeof()` function.

For example:

```from pympler import asizeof

nums = [1, 2, 3, 4, 5]
print(asizeof.asizeof(nums))

more_nums = [
[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5],
[1, 2, 3, 4, 5]
]
print(asizeof.asizeof(more_nums))```

Output:

```256
736```

Looks better! The `asizeof()` function not only calculates the space an object takes but also combines it with what the nested elements eat up. Now the list of lists is bigger than a single list of numbers which makes sense.

And if you expected the list of lists to take 5 x more space than the list, you were wrong.

Intuitively, that would be the case. But behind the scenes, a “lot of” memory is spent building the list, the list inside a list before adding a single integer. This initial cost of building the objects might change the size expectations of the objects you’re measuring.

For example, to build an empty list with an empty list inside, you already need 120 bytes of memory.

```from pympler import asizeof

print(asizeof.asizeof([[]])) # Output: 120```

Then the rest of the memory consumption is based on what values you add to the inner lists and how many inner lists you’ll have.

## Summary

Today you learned how to measure the size of a Python object.

To take home, the out-of-box method `sys.getsizeof()` is limited and doesn’t care what’s inside the objects. In other words, most of the time it doesn’t return the size you want.

A better and more intuitive way to measure the true size of an object is by measuring the inner object’s size too. You can do this with the Pympler package `asizeof` class’s `asizeof()` function.