# numpy.memmap.view

method

memmap.view([dtype][, type])

  New view of array with the same data.

  Note

  Passing None for `dtype` is different from omitting the parameter, since the former invokes `dtype(None)` which is an alias for `dtype('float_')`.

  Parameters:
    dtype data-type or ndarray sub-class, optional

      Data-type descriptor of the returned view, e.g., float32 or int16. Omitting it results in the view having the same data-type as a. This argument can also be specified as an ndarray sub-class, which then specifies the type of the returned object (this is equivalent to setting the `type` parameter).

    type Python type, optional

      Type of the returned view, e.g., ndarray or matrix. Again, omission of the parameter results in type preservation.

  Notes

  `a.view()` is used two different ways:

  `a.view(some_dtype)` or `a.view(dtype=some_dtype)` constructs a view of the array’s memory with a different data-type. This can cause a reinterpretation of the bytes of memory.

  `a.view(ndarray_subclass)` or `a.view(type=ndarray_subclass)` just returns an instance of ndarray_subclass that looks at the same array (same shape, dtype, etc.) This does not cause a reinterpretation of the memory.

  For `a.view(some_dtype)`, if `some_dtype` has a different number of bytes per entry than the previous dtype (for example, converting a regular array to a structured array), then the last axis of `a` must be contiguous. This axis will be resized in the result.

  Changed in version 1.23.0: Only the last axis needs to be contiguous. Previously, the entire array had to be C-contiguous.

  Examples

      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])

  Viewing array data using a different type and dtype:

      >>> y = x.view(dtype=np.int16, type=np.matrix)
      >>> y
      matrix([[513]], dtype=int16)
      >>> print(type(y))
      <class 'numpy.matrix'>

  Creating a view on a structured array so it can be used in calculations

      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
      >>> xv
      array([[1, 2],
             [3, 4]], dtype=int8)
      >>> xv.mean(0)
      array([2.,  3.])

  Making changes to the view changes the underlying array

      >>> xv[0,1] = 20
      >>> x
      array([(1, 20), (3,  4)], dtype=[('a', 'i1'), ('b', 'i1')])

  Using a view to convert an array to a recarray:

      >>> z = x.view(np.recarray)
      >>> z.a
      array([1, 3], dtype=int8)

  Views share data:

      >>> x[0] = (9, 10)
      >>> z[0]
      (9, 10)

  Views that change the dtype size (bytes per entry) should normally be avoided on arrays defined by slices, transposes, fortran-ordering, etc.:

      >>> x = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int16)
      >>> y = x[:, ::2]
      >>> y
      array([[1, 3],
             [4, 6]], dtype=int16)
      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
      Traceback (most recent call last):
          ...
      ValueError: To change to a dtype of a different size, the last axis must be contiguous
      >>> z = y.copy()
      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
      array([[(1, 3)],
             [(4, 6)]], dtype=[('width', '<i2'), ('length', '<i2')])

  However, views that change dtype are totally fine for arrays with a contiguous last axis, even if the rest of the axes are not C-contiguous:

      >>> x = np.arange(2 * 3 * 4, dtype=np.int8).reshape(2, 3, 4)
      >>> x.transpose(1, 0, 2).view(np.int16)
      array([[[ 256,  770],
              [3340, 3854]],

             [[1284, 1798],
              [4368, 4882]],

             [[2312, 2826],
              [5396, 5910]]], dtype=int16)