В чем именно заключается смысл memoryview в Python

Одна из причин, по которой memoryviews полезны, заключается в том, что их можно разрезать без копирования базовых данных, в отличие от _2 _ / _ 3_.

Например, возьмем следующий игрушечный пример.

import time
for n in (100000, 200000, 300000, 400000):
    data = b'x'*n
    start = time.time()
    b = data
    while b:
        b = b[1:]
    print(f'     bytes {n} {time.time() - start:0.3f}')

for n in (100000, 200000, 300000, 400000):
    data = b'x'*n
    start = time.time()
    b = memoryview(data)
    while b:
        b = b[1:]
    print(f'memoryview {n} {time.time() - start:0.3f}')

На моем компьютере я получаю

     bytes 100000 0.211
     bytes 200000 0.826
     bytes 300000 1.953
     bytes 400000 3.514
memoryview 100000 0.021
memoryview 200000 0.052
memoryview 300000 0.043
memoryview 400000 0.077

Вы можете ясно видеть квадратичную сложность повторяющейся нарезки строки. Даже после 400000 итераций это уже неуправляемо. Между тем, версия memoryview имеет линейную сложность и молниеносно.

Изменить: Обратите внимание, что это было сделано в CPython. В Pypy до 4.0.1 была ошибка, вызывающая просмотры памяти чтобы иметь квадратичную производительность.

memoryview объекты отлично подходят, когда вам нужны подмножества двоичных данных, которые должны только поддерживать индексацию. Вместо того, чтобы делать срезы (и создавать новые, потенциально большие) объекты для передачи другому API, вы можете просто взять объект memoryview.

Одним из таких примеров API может быть модуль struct. Вместо того, чтобы передавать фрагмент большого bytes объекта для анализа упакованных значений C, вы передаете memoryview только ту область, из которой необходимо извлечь значения.

memoryview объекты фактически поддерживают struct распаковку; вы можете выбрать область нижележащего объекта bytes с помощью среза, а затем использовать .cast() для «интерпретации» нижележащих байтов как длинных целых чисел, значений с плавающей запятой или n-мерных списков целых чисел. Это обеспечивает очень эффективную интерпретацию формата двоичного файла без необходимости создания дополнительных копий байтов.

Позвольте мне объяснить, в чем заключается проблема понимания.

Спрашивающий, как и я, ожидал, что сможет создать представление памяти, которое выбирает часть существующего массива (например, bytes или bytearray). Поэтому мы ожидали чего-то вроде:

desired_slice_view = memoryview(existing_array, start_index, end_index)

Увы, такого конструктора нет, и вместо этого в документации не указывается, что делать.

Ключевым моментом является то, что вы должны сначала создать представление памяти, которое охватывает весь существующий массив. Из этого представления памяти вы можете создать второе представление памяти, которое покрывает часть существующего массива, например:

whole_view = memoryview(existing_array)
desired_slice_view = whole_view[10:20]

Короче говоря, цель первой строки - просто предоставить объект, реализация среза которого (dunder-getitem) возвращает представление в памяти.

Это может показаться неряшливым, но это можно рационализировать двумя способами:

1. Наш желаемый результат - это представление в памяти, представляющее собой кусок чего-то. Обычно мы получаем срезанный объект из объекта того же типа, используя для него оператор среза [10:20]. Так что есть основания ожидать, что нам нужно получить желаемый_slice_view из memoryview, и, следовательно, первым шагом является получение memoryview всего базового массива.

2. Наивное ожидание конструктора memoryview с аргументами start и end не учитывает, что спецификация среза действительно требует всей выразительности обычного оператора среза (включая такие вещи, как [3 :: 2] или [: -4] и т. Д.). Невозможно просто использовать существующий (и понятный) оператор в этом однострочном конструкторе. Вы не можете присоединить его к аргументу existing_array, так как это сделает часть этого массива вместо того, чтобы сообщать конструктору memoryview некоторые параметры среза. И вы не можете использовать сам оператор в качестве аргумента, потому что это оператор, а не значение или объект.

Возможно, конструктор memoryview мог бы взять объект среза:

desired_slice_view = memoryview(existing_array, slice(1, 5, 2) )

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

Вот код python3.

#!/usr/bin/env python3

import time
for n in (100000, 200000, 300000, 400000):
    data = b'x'*n
    start = time.time()
    b = data
    while b:
        b = b[1:]
    print ('bytes {:d} {:f}'.format(n,time.time()-start))

for n in (100000, 200000, 300000, 400000):
    data = b'x'*n
    start = time.time()
    b = memoryview(data)
    while b:
        b = b[1:]
    print ('memview {:d} {:f}'.format(n,time.time()-start))

Отличный пример от «Сурьмы». Фактически, в Python3 вы можете заменить data = 'x' * n на data = bytes (n) и поместить скобки в операторы печати, как показано ниже:

import time
for n in (100000, 200000, 300000, 400000):
    #data = 'x'*n
    data = bytes(n)
    start = time.time()
    b = data
    while b:
        b = b[1:]
    print('bytes', n, time.time()-start)

for n in (100000, 200000, 300000, 400000):
    #data = 'x'*n
    data = bytes(n)
    start = time.time()
    b = memoryview(data)
    while b:
        b = b[1:]
    print('memoryview', n, time.time()-start)