memoryview() in Python

Last Updated : 22 Feb, 2025

The memoryview() function in Python is used to create a memory view object that allows us to access and manipulate the internal data of an object without copying it. This is particularly useful for handling large datasets efficiently because it avoids the overhead of copying data. A memory view object exposes the buffer interface of the underlying object, such as bytes, bytearray or array, enabling direct access to the memory.

Example:

Python

# Creating a memory view of a bytearray data = bytearray("Hello", "utf-8")    mv = memoryview(data)                  print(mv[0])            mv[1] = 105            print(data)

Output

72 bytearray(b'Hillo')

Explanation:

A bytearray is created from the string "Hello" encoded as UTF-8.
memoryview() creates a view of the bytearray, allowing direct access to its memory.
Using indexing, the first byte is printed as an integer (ASCII value), and the second byte is modified, affecting the original bytearray.

Table of Content

Syntax of memoryview()

memoryview(object)

object: This must be an object that supports the buffer protocol, such as bytes, bytearray, or array.

Different methods of using memoryview()

1. Accessing bytes using indexing

Memory views can be accessed using indexing and slicing, similar to sequences like lists or strings. Indexing returns the byte value at the specified position as an integer, while slicing returns a new memory view representing the specified range of bytes. This approach is particularly useful for reading specific sections of large datasets without copying the entire data into memory, which improves efficiency.

Python

# Creating a memory view from bytes data = b'Python'          mv = memoryview(data)      # Accessing individual byte using indexing print(mv[0])               # Accessing a range of bytes using slicing print(mv[1:4].tobytes())

Output

80 b'yth'

Explanation:

The b'Python' is a bytes object, which is immutable and supports the buffer protocol.
memoryview(data) creates a view of this bytes object without copying the data.
mv[0] accesses the first byte, which is P with an ASCII value of 80.
mv[1:4] slices the memory view from index 1 to 3, resulting in b'yth', and .tobytes() converts this slice into an immutable bytes object.

2. Modifying data using bytearray

When using a mutable object like bytearray, memoryview() allows direct modification of the underlying data. Indexing can be used to update specific bytes by assigning new values (as integers representing ASCII codes). Any modifications made through the memory view immediately affect the original object. This capability is valuable for performance-critical applications where data needs to be modified without creating copies, such as image manipulation or real-time data processing.

Example:

Python

# Creating a bytearray for mutable data arr = bytearray(b'abcde')   mv = memoryview(arr)         # Modifying a byte using indexing mv[0] = 65                   print(arr)

Output

bytearray(b'Abcde')

Explanation:

The bytearray(b'abcde') is mutable, meaning its contents can be changed.
memoryview(arr) creates a view that references the bytearray directly.
Using mv[0] = 65 updates the first byte of the memory view to 65, which corresponds to the ASCII value of 'A'.
This modification reflects immediately in the original bytearray, as shown by print(arr) displaying bytearray(b'Abcde').

3. Converting memory view to bytes

The .tobytes() method converts the memory view into an immutable bytes object, which is a copy of the original data. This is useful when you need to create a read-only snapshot of the data that won’t be affected by future changes to the original buffer. The resulting bytes object can be safely shared between functions or stored for later use, ensuring data integrity. This method is commonly used in networking, data serialization, and cryptography.

Example:

Python

# Creating a mutable bytearray arr = bytearray(b'12345')   mv=memoryview(arr)  # Converting the memory view to immutable bytes result = mv.tobytes()         print(result)                 print(type(result))

Output

b'12345' <class 'bytes'>

Explanation:

The bytearray(b'12345') is a mutable sequence of bytes, each representing a character's ASCII value.
memoryview(arr) creates a view of this data without copying it.
The .tobytes() method creates an immutable copy of the entire memory view as a bytes object.
Even if the original bytearray is modified afterward, the bytes object returned by .tobytes() remains unchanged, ensuring data consistency.

4. Using `.cast()` Method to Change Data Interpretation

The .cast() method allows you to reinterpret the underlying memory as a different data type without altering the actual data. This method is particularly useful for working with binary data or structured data formats, where the same bytes can represent different types depending on their interpretation. By specifying a format code (like 'B' for unsigned bytes or 'i' for integers), you can access the memory as a sequence of different-sized elements, which is essential for tasks like parsing binary files, network protocols, and image processing.

Python

import array  # Creating an array of integers arr = array.array('i', [1, 2, 3, 4])    mv=memoryview(arr)  # Reinterpreting the data as unsigned bytes mv_cast = mv.cast('B')                 print(mv_cast.tolist())

Output

[1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0]

Explanation:

The array.array('i', [1, 2, 3, 4]) creates an array of integers, where each integer typically occupies 4 bytes.
memoryview(arr) creates a view of this array, allowing access to its underlying memory.
.cast('B') reinterprets the same memory as a sequence of unsigned bytes (B), effectively splitting each integer into 4 separate bytes.
The .tolist() method then returns these bytes as a list of integers, providing a human readable representation of the raw memory contents.

memoryview() in Python

Shivani Ghughtyal

Improve

Article Tags :

Practice Tags :

python

memoryview() in Python

Syntax of memoryview()

Different methods of using memoryview()

1. Accessing bytes using indexing

2. Modifying data using bytearray

3. Converting memory view to bytes

4. Using .cast() Method to Change Data Interpretation

Similar Reads

4. Using `.cast()` Method to Change Data Interpretation