Memory Consumption of Strings and Lists in Python
Below are some examples by which we can understand about the memory consumption in strings and lists in Python:
Python Memory Size of Strings
Python strings are immutable, which means that once they are created, their contents cannot be altered. A string’s memory use is determined by both the character sizes and extra overhead. To get the size of an object in bytes, use the sys.getsizeof() function.
Python3
import sys string_example = "Hello, World!" print (f "Size of string: {sys.getsizeof(string_example)} bytes" ) |
Size of string: 62 bytes
Memory of Python List
Python lists are dynamic arrays that may expand or contract as required. A list’s memory needs are determined by several variables, including the quantity and kind of its items as well as the system architecture. More RAM is often needed for larger lists.
Python3
import sys list_example = [ 1 , 2 , 3 , 4 , 5 ] print (f "Size of the list: {sys.getsizeof(list_example)} bytes" ) |
Size of the list: 112 bytes
How Much Memory Will a List with One Million Elements Take Up in Python?
The following example may be used to determine how much memory a list with one million entries would require. In this example, we have created a list consisting one million elements and we are finding the memory size of the list.
Python3
import sys large_list = list ( range ( 1000000 )) print (f "Size of the list with one million elements: {sys.getsizeof(large_list)} bytes" ) |
Size of the list with one million elements: 9000120 bytes
Memory Size of Strings having one million size in Python
As was previously discussed, variables like length and encoding affect how big strings are stored in memory. You may use sys.getsizeof() to measure it.
Python3
import sys string_example = "Hello, World! " * ( 1000000 ) print (string_example) print (f "Size of the string: {sys.getsizeof(string_example)} bytes" ) |
Size of the string: 62 bytes
How Much Memory Does a Python Set Take Up?
In Python, sets contain an underlying data structure that causes a memory cost. Sys.getsizeof() may be used to calculate the size.
Python3
import sys set_example = { 1 , 2 , 3 , 4 , 5 } print (f "Size of the set: {sys.getsizeof(set_example)} bytes" ) |
Size of the set: 744 bytes
How Do I Limit Python Memory Usage?
You may use third-party libraries like resource_limits or tools like resource module to restrict how much memory Python uses. Using system-level tools and configuring environment variables like PYTHONMALLOC may also affect memory use.
Memory Consumption of Simple String vs List
In this example, a list of the characters in the string and a basic string are formed. The sys.getsizeof() method is used to compare the sizes of the list and the string. In Python, strings store characters more efficiently in memory than lists do.
Python3
import sys # Example 1 string_example = "Hello, World!" list_example = list (string_example) string_size = sys.getsizeof(string_example) list_size = sys.getsizeof(list_example) print (f "Size of String: {string_size} bytes" ) print (f "Size of List: {list_size} bytes" ) |
Size of String: 62 bytes Size of List: 232 bytes
Memory Consumption of Large String vs List
In this example, a lengthy string and a list of the string’s characters are produced. To show how the memory usage increases with string size, the sizes are compared. When it comes to character memory use, strings often behave more predictably than lists.
Python3
import sys # Example 2 large_string = "A" * 2000000 list_example = list (large_string) string_size = sys.getsizeof(large_string) list_size = sys.getsizeof(list_example) print (f "Size of Large String: {string_size} bytes" ) print (f "Size of List: {list_size} bytes" ) |
Size of Large String: 2000049 bytes Size of List: 18000120 bytes
Memory Consumption of Concatenation of Strings vs Lists in Python
The memory use of a list of distinct strings and a concatenated string using “”.join() are compared in this example. When working with a large number of strings, the join operation uses less memory than building a list.
Python3
import sys # Example 3 strings = [ "Hello" , "World" , "!" ] joined_string = "".join(strings) list_example = list (strings) joined_string_size = sys.getsizeof(joined_string) list_size = sys.getsizeof(list_example) print (f "Size of Joined String: {joined_string_size} bytes" ) print (f "Size of List: {list_size} bytes" ) |
Size of Joined String: 60 bytes Size of List: 120 bytes
Python Memory Consumption of Modifying String vs List
We change the first character in the list and the string in this example. This illustrates that altering a string by starting from scratch uses more memory than altering a list in-place, which uses less memory.
Python3
import sys # Example 4 string_example = "Hello, World!" list_example = list (string_example) # Modifying the first character string_example_modified = "J" + string_example[ 1 :] list_example[ 0 ] = "J" string_modified_size = sys.getsizeof(string_example_modified) list_modified_size = sys.getsizeof(list_example) print (f "Size of Modified String: {string_modified_size} bytes" ) print (f "Size of Modified List: {list_modified_size} bytes" ) |
Size of Modified String: 62 bytes Size of Modified List: 232 bytes
Python Memory Consumption: Strings vs Lists
Programming memory use is an important consideration, particularly when working with big datasets or resource-intensive programs. Writing effective Python code requires knowing how various data structures affect memory utilization. This article examines how lists and strings use memory differently in Python and explains the basic ideas behind each.