GeeksforGeeks App
Open App
Browser
Continue

# Python Memory Consumption: Dictionary VS List of Tuples

In this article, we are going to see memory consumption in dictionaries and a list of tuples.

## Memory Consumption by dict vs list of tuples

Dictionary occupies much more space than a list of tuples. Even an empty dict occupies much space as compared to a list of tuples.

Example 1: As we can clearly see that there is a huge difference between memory consumption of both the datatypes when both are empty.

## Python3

 `import` `sys` `dict` `=` `{}``print``(``dict``)` `# We will get size of empty dict``print``(sys.getsizeof(``dict``))` `t1 ``=` `()``d ``=` `list``(t1)``print``(d)` `# We will get size of empty list of tuples``print``(sys.getsizeof(d))`

Output:

```{}
240
[]
64```

Example 2: In this example, therefore 3-4 elements in dict and list of tuples.

## Python3

 `import` `sys` `# for dict``dict` `=` `{(``1``, ``"G"``), (``2``, ``"F"``), (``3``, ``"G"``)}``print``(``dict``)``print``(sys.getsizeof(``dict``))` `# for list of tuples``list1 ``=` `(``1``, ``2``, ``3``)``list2 ``=` `(``"G"``, ``"F"``, ``"G"``)``LoT ``=` `list``(``zip``(list1, list2))``print``(LoT)``print``(sys.getsizeof(LoT))`

Output:

```{(3, 'G'), (1, 'G'), (2, 'F')}
224
[(1, 'G'), (2, 'F'), (3, 'G')]
112```

Again we can compare the memory consumption is 224 Bytes in dict whereas 112 for list of tuples.

Example 3: Lets consider 1-100 elements in dict and list of tuples and checkout whats the result.

## Python3

 `import` `sys` `# for dict``dict` `=` `{}``for` `i ``in` `range``(``1``, ``101``):``    ``dict``[i] ``=` `i``print``(``dict``)``print``(sys.getsizeof(``dict``))` `# for list of tuples``lst ``=` `list``(``range``(``1``, ``101``))``print``(lst)``print``(sys.getsizeof(lst))`

Output:

{1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9, 10: 10, 11: 11, 12: 12, 13: 13, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, 96: 96, 97: 97, 98: 98, 99: 99, 100: 100}

4704

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]

1008

For a larger number of elements, we can clearly see that there is no comparison in memory consumption. dict is almost 4.7 times of list of tuples for just 100 elements. If we have lakhs of elements to store, just think about memory taken by a dict.

We have determined the changes in the size of both the objects after the addition of elements which are mentioned below.

My Personal Notes arrow_drop_up