Почему numpy.ndarray.view игнорирует предыдущий вызов numpy.ndarray.newbyteorder?

In [280]: a = np.array([123456789, 234567891, 345678912], dtype=np.uint32)

In [282]: a.tobytes()
Out[282]: b'\x15\xcd[\x07\xd38\xfb\r@\xa4\x9a\x14'

In [284]: a.view('uint8')
Out[284]: 
array([ 21, 205,  91,   7, 211,  56, 251,  13,  64, 164, 154,  20],
      dtype=uint8)

Это то же самое, что и a.view('<u1') и a.view('>u1'), поскольку окончание не имеет значения для отдельных байтов.

In [291]: a.view('<u4')
Out[291]: array([123456789, 234567891, 345678912], dtype=uint32)
In [292]: a.view('>u4')
Out[292]: array([ 365779719, 3543726861, 1084529172], dtype=uint32)

Представление полностью зависит от данных, а не от текущего (последнего) представления:

In [293]: a.view('<u4').view('u1')
Out[293]: 
array([ 21, 205,  91,   7, 211,  56, 251,  13,  64, 164, 154,  20],
      dtype=uint8)
In [294]: a.view('>u4').view('u1')
Out[294]: 
array([ 21, 205,  91,   7, 211,  56, 251,  13,  64, 164, 154,  20],
      dtype=uint8)

Об идее изменения формы и поворота вспять:

In [295]: a.view('u1').reshape(-1,4)
Out[295]: 
array([[ 21, 205,  91,   7],
       [211,  56, 251,  13],
       [ 64, 164, 154,  20]], dtype=uint8)
In [296]: a.view('u1').reshape(-1,4)[:,::-1]
Out[296]: 
array([[  7,  91, 205,  21],
       [ 13, 251,  56, 211],
       [ 20, 154, 164,  64]], dtype=uint8)

Но я не могу изменить представление (на u4) этого массива, потому что он не является непрерывным:

In [297]: a.view('u1').reshape(-1,4)[:,::-1].view('<u4')
....
ValueError: To change to a dtype of a different size, the array must be C-contiguous

Посмотрите еще немного на свойства этого перевернутого массива:

In [298]: a1 = a.view('u1').reshape(-1,4)[:,::-1]
In [299]: a1.flags
Out[299]: 
  C_CONTIGUOUS : False
  F_CONTIGUOUS : False
  ....
In [300]: a1.strides             # reversing is done with strides
Out[300]: (4, -1)

Два массива используют один и тот же буфер данных. a2 просто начинается с другого байта:

In [301]: a.__array_interface__['data']
Out[301]: (32659520, False)
In [302]: a1.__array_interface__['data']
Out[302]: (32659523, False)

Я не могу изменить форму a1 на месте:

In [304]: a1.shape = (12,)
...
AttributeError: incompatible shape for a non-contiguous array

Если я сделаю reshape, я получу копию (как показывает совершенно другой адрес буфера данных):

In [305]: a2 = a1.reshape(-1)
In [306]: a2
Out[306]: 
array([  7,  91, 205,  21,  13, 251,  56, 211,  20, 154, 164,  64],
      dtype=uint8)
In [307]: a2.view('<u4')
Out[307]: array([ 365779719, 3543726861, 1084529172], dtype=uint32)
In [308]: a2.__array_interface__['data']
Out[308]: (37940512, False)

Таким образом, вы можете просматривать один и тот же буфер данных с разной конечностью, но вы не можете просматривать отдельные байты в другом порядке без создания несмежного массива или копирования.

newbyteorder в документах говорится, что это эквивалентно:

arr.view(arr.dtype.newbytorder(new_order))

Итак, a.view('<u4').newbyteorder('>') это то же самое, что a.view('<u4'). Ни одного из этих изменений a.

Новый порядок байтов, применяемый с newbyteorder, является исключительно свойством dtype массива; a.newbyteorder("<") возвращает представление a с прямым порядком байтов dtype. Он не меняет содержимое памяти и не влияет на форму или шаги массива.

ndarray.view не заботится о dtype исходного массива, little-endian или big. Он заботится о форме массива, шагах и фактическом содержимом памяти, ни одно из которых не изменилось.

Просто чтобы добавить в ответ @ user2357112, из документации:

Как вы можете понять из введения, есть два способа повлиять на взаимосвязь между порядком байтов в массиве и базовой памятью, на которую он смотрит:

• Измените информацию о порядке байтов в массиве dtype, чтобы он интерпретировал базовые данные как находящиеся в другом порядке байтов. Это роль arr.newbyteorder()
• Измените порядок байтов базовых данных, оставив интерпретацию dtype без изменений. Это то, что делает arr.byteswap().

Мое ударение в цитате выше.

Другая мысль собрана из комментариев:

Поскольку newbyteorder () похож на view () в том, что он просто изменяет интерпретацию базовых данных без изменения данных, похоже, что представление в представлении является представлением тех же (исходных) данных. Итак, да, вы не можете «связать» представления (ну, вы можете ... но это всегда представление одних и тех же исходных данных).

Как тогда получить uint8 фрагменты в порядке прямого байта без изменения памяти?

Попробуйте np.sum(a.newbyteorder('<')) (как вариант, попробуйте a.newbyteorder('<').tolist()), а также измените знак / порядок следования байтов. Итак, мой ответ на вышеупомянутый вопрос будет заключаться в том, что вы не можете этого сделать: либо память изменяется «на месте» с помощью byteswap(), либо путем копирования данных в новую ячейку памяти при доступе к элементам в представлении.