What does memoryview.cast require of a view, and when does it raise?

## What a cast is The buffer protocol describes a block of memory with a format code, an item size, a shape and strides. `memoryview.cast(format)` keeps the block and rewrites the description: same pointer, same `nbytes`, different element type. `cast("I")` over an 8-byte buffer yields a view of two native unsigned integers; writing `words[0] = 7` writes four bytes into the underlying `bytearray`. Nothing is copied and no `struct.pack` round trip happens. This is the zero-copy alternative to `struct.unpack` for homogeneous data. Where `struct` reads bytes and builds Python objects, `cast` changes how the same bytes are addressed, and elements are materialized as Python ints only when you index one. ## The two restrictions **C-contiguity.** A cast is only meaningful when the elements sit back to back with no gaps, because reinterpreting the item width is arithmetic on a flat run of bytes. A view with a non-unit stride — `memoryview(bytearray(8))[::2]`, whose `strides` is `(2,)` and whose `c_contiguous` is `False` — cannot be cast, and raises `TypeError: memoryview: casts are restricted to C-contiguous views`. The properties to check first are `memoryview.c_contiguous`, `memoryview.f_contiguous` and `memoryview.contiguous`. **Exact division.** The total byte length must be a whole number of new items. `memoryview(bytearray(7)).cast("I")` raises `TypeError: memoryview: length is not a multiple of itemsize`, because seven bytes is not a whole number of four-byte integers. This is the check that catches a truncated record before it becomes silent garbage, so it is worth letting it fire rather than padding around it. ## Shape, strides and the count that changes `cast` takes an optional `shape`, so one call can both reinterpret and reshape: `memoryview(bytearray(6)).cast("B", shape=(2, 3))` produces a two-dimensional view with `shape` `(2, 3)`, `strides` `(3, 1)` and `ndim` `2`. Indexing it takes a tuple. Flattening back is another `cast` to a one-dimensional format. The trap after any cast is the difference between the two length notions: `memoryview.nbytes` is always the byte count and never changes across a cast, while `len()` and `memoryview.shape` report *items*, so an 8-byte view has `len()` of 8 as `"B"` and 2 as `"I"`. Code that mixes the two — passing `len(view)` where a byte count is wanted — reads or writes a quarter of what it intended. ## Format codes and endianness Cast formats are restricted to native single-element codes: `"B"`, `"b"`, `"h"`, `"H"`, `"i"`, `"I"`, `"l"`, `"L"`, `"q"`, `"Q"`, `"f"`, `"d"`, and so on. That means casts use *native* byte order and native alignment — there is no little-endian or big-endian prefix as there is in `struct`. Reading a wire format with a fixed endianness through `cast` is therefore only correct on a machine whose native order matches; for data crossing machines, `struct.unpack_from` with an explicit `<` or `>` prefix is the right tool, and it also accepts the view directly, so you still avoid the copy. Getting this wrong produces plausible-looking numbers rather than an error, which is why it is worth stating explicitly in any code that casts. ## Read-only and lifetime A cast inherits the read-only flag from the source view, so casting a view of `bytes` gives a read-only integer view — reinterpretation never grants write access that the exporter withheld. `memoryview.toreadonly()` goes the other way, narrowing a writable view before you pass it on. Each cast is a distinct view with its own export, so the exporter stays pinned until every one of them is released, and each should be released or scoped in a `with` block. ## When to reach for it `cast` earns its place when you have a homogeneous block of fixed-width values in native order — samples, counters, fixed-width records — and want to index or mutate them without building intermediate objects. For heterogeneous records, mixed field widths or a specified wire byte order, `struct.unpack_from` over the same view is clearer and correct on every platform. The decision is not about speed alone: a cast that is wrong about endianness or alignment fails silently, whereas `struct` states the layout in one string a reviewer can read.