memoryview

A memoryview is a built-in Python object that exposes the C-level buffer interface of another object. It provides zero-copy access to an object’s internal data, allowing developers to read and modify contiguous memory arrays (such as bytes, bytearray, or array.array) directly without triggering memory reallocation or creating intermediate copies.

Syntax

view = memoryview(obj)

The obj passed to the constructor must support the Python buffer protocol.

Core Mechanics

Zero-Copy Slicing When you slice a standard Python byte string, Python allocates new memory and copies the data. When you slice a memoryview, Python returns a new memoryview instance that points to the specified offset of the original memory buffer.

data = b'abcdefgh'
view = memoryview(data)


# Creates a new view of the same memory; no data is copied
slice_view = view[2:6] 

Mutability A memoryview inherits the mutability of its underlying object. If the target object is immutable (e.g., bytes), the view is read-only. If the target object is mutable (e.g., bytearray), the view allows in-place memory modification.

mutable_data = bytearray(b'hello')
view = memoryview(mutable_data)


# Modifies the underlying bytearray directly
view[0] = 74  # ASCII for 'J'
print(mutable_data)  # Output: bytearray(b'Jello')

Key Attributes

A memoryview exposes several attributes that describe the underlying C array:

• obj: The original object the view is pointing to.
• nbytes: The total number of bytes the view represents.
• readonly: A boolean indicating whether the underlying buffer can be modified.
• format: A string indicating the C-type of the elements, using struct module syntax (e.g., 'B' for unsigned char).
• itemsize: The size in bytes of each element.
• shape: A tuple indicating the length of the array in each dimension.
• strides: A tuple indicating the number of bytes to skip to access the next element in each dimension.

Casting Memory Layouts

The cast() method allows you to reinterpret the underlying memory bytes as a different data type or shape without copying the data. This is strictly a reinterpretation of the C-level bytes.

import array


# Array of 16-bit signed integers ('h')
arr = array.array('h', [1000, 2000, 3000])
view = memoryview(arr)


# Cast the 16-bit integer view to an 8-bit unsigned byte view ('B')
byte_view = view.cast('B')

Buffer Management

Because a memoryview holds a reference to the underlying object’s buffer, it prevents the object from being resized or garbage-collected. The release() method explicitly releases the buffer, invalidating the view and freeing the lock on the underlying object.

view = memoryview(b'data')
view.release()


# Accessing view after release() raises a ValueError

Alternatively, memoryview supports the context manager protocol to handle buffer release automatically:

with memoryview(b'data') as view:
    length = len(view)

# Buffer is automatically released when the block exits

Master Python with Deep Grasping Methodology!

Learn More