Python memoryview() Function

Spread the love

The memoryview() function returns a “memory view” object created from a given argument. It allows you to access the internal data of an object that supports the buffer protocol without copying it. Essentially, it’s a way to peek and poke into the object’s data without the overhead of copying it first.


The syntax of memoryview() is straightforward:



obj: This is the object that you want to create a view for. The object must support the buffer protocol, such as bytes, bytearray, or an array.array.

Return Value:

The memoryview() function returns a memory view object, which is itself a context to the buffer of the given object.

Buffer Protocol

Before delving further into memoryview(), it’s essential to understand the buffer protocol. The buffer protocol provides a way for an object to expose its underlying buffer (a sequence of bytes) to other objects. This is what makes it possible for memoryview() to work without copying the actual data.

Using memoryview() with Different Data Types

The memoryview() function is primarily used with objects that support the buffer protocol, such as:

  • bytes
  • bytearray
  • array.array

Example with Bytes

bytes_obj = b'Hello World'
mv = memoryview(bytes_obj)
print(mv[0])  # Output: 72 which is the ASCII for 'H'
print(bytes(mv[:5]))  # Output: b'Hello'

Example with Bytearray

bytearray_obj = bytearray('Hello World', 'utf-8')
mv = memoryview(bytearray_obj)
mv[0] = ord('h')  # Modify the first byte
print(bytearray_obj)  # Output: bytearray(b'hello World')

Example with array.array

import array

arr = array.array('i', [1, 2, 3, 4, 5])
mv = memoryview(arr)
print(mv[1])  # Output: 2
mv[1] = 10
print(arr)  # Output: array('i', [1, 10, 3, 4, 5])

Modifying Data with memoryview()

One of the powerful features of memoryview() is the ability to modify data without copying it. When you create a memory view of a mutable object like a bytearray or an array.array, you can change its contents through the memory view.

Slicing with memoryview()

Memory views support slicing, which means you can create subviews of your data:

bytearray_obj = bytearray('Hello World', 'utf-8')
mv = memoryview(bytearray_obj)
mv_slice = mv[2:6]
print(bytes(mv_slice))  # Output: b'llo '

Slicing a memory view creates a new memory view object starting from the original buffer, so no data is copied with this operation.

Multi-Dimensional memoryview()

memoryview() also supports multi-dimensional slices, which is beneficial for numerical computations on matrices:

import numpy as np

arr_2d = np.arange(12).reshape(3, 4)
mv_2d = memoryview(arr_2d)
print(mv_2d.tolist())  # Convert to list for readability

Real-World Applications

1. Handling Binary Data

memoryview() is especially useful when you need to process binary data, such as images or files, in a byte-by-byte manner.

2. Networking

In networking, when you’re sending and receiving data packets, you often need to read headers or payloads without copying the data to improve performance. memoryview() is perfect for this.

3. Numerical Computations

In scientific computing, manipulating large datasets efficiently is key. memoryview() allows operations on large arrays without the overhead of copying.

Performance Benefits

Using memoryview() can result in significant performance benefits due to:

  • No Copy Overhead: Directly accessing the buffer means no time wasted copying large amounts of data.
  • Memory Savings: Since there’s no need to copy data, you save on memory usage.

Caveats and Considerations

When using memoryview(), there are some points to keep in mind:

  • The object passed to memoryview() must support the buffer protocol.
  • Modifications through a memory view are reflected in the original object, which could lead to unintended side effects if not handled carefully.
  • Not all operations on the object are possible through a memory view.


The memoryview() function is a powerful feature of Python that allows for efficient handling of an object’s memory. It’s an advanced tool that can lead to more performant and memory-efficient applications when used correctly. By creating a view of the data buffer, memoryview() enables the manipulation of data without the cost of copying it. This can be particularly useful in data-intensive applications like image processing, file I/O operations, and scientific computing where performance is critical.

Leave a Reply