Ленивая оценка карты

Вы тут сравниваете яблоки с апельсинами. range не просто ленивая итерация. Это конкретный объект, содержимое которого подчиняется определенным законам, что позволяет выполнять множество операций, фактически не создавая в памяти огромную последовательность. Это потому, что n-й элемент range в основном просто start + n*step (по модулю stop, знаки и т. д.)

Однако map предназначен для работы с любой функцией f. В частности, функции могут иметь совместно используемое/глобальное состояние, которое уже исключает любую возможность выполнения map(f, something)[100] без выполнения 100 вызовов функций. В противном случае нарушается правильность результата.

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

for x in map(f, iterable):
    # do something with x

где, если бы map стремился, он бы потреблял вдвое больше памяти, чем iterable, чтобы выполнить цикл, с ленивым map единственное требуемое пространство - это в основном x.

Кроме того, он позволяет вызывать map для бесконечных итераций, таких как count(). Это, очевидно, приводит к тому, что бесконечная программа что-то делает, или в какой-то момент вы можете просто перестать заглядывать в map. Нетерпеливый map не может справиться с этим делом.

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

class PureMap:
    def __init__(self, function, sequence):
        self._f = function
        self._sequence = sequence

    def __iter__(self):
        return map(self._f, self._sequence)
    def __getitem__(self, i):
        return self._f(self._sequence[i])
    # etc.

Однако даже в этом случае у вас есть некоторые проблемы:

1. Если sequence на самом деле является iterable, чтобы получить n-й элемент, вам нужно использовать первые n элементов. После этого вам нужно будет сохранить их как последовательность в вашем классе для будущего использования. Но это уже противоречит цели всего, так как выполнение PureMap(f, sequence)[1000] требует от вас хранить 1000 элементов в памяти в любом случае, хотя при этом избегаются 999 вызовы f.

2. Вы хотите избежать многократного вызова f для одного и того же элемента. Это означает, что вам также придется отслеживать, какой элемент уже вычислен, а какой нет.

Единственная ситуация, в которой вы можете достичь того, чего хотите, заключается в следующем:

• Вызываемая функция чистая
• Итерируемый аргумент — это что-то вроде range, который разрешает произвольный доступ без необходимости создавать другие элементы.
• Функция, которую вы вызываете, работает быстро, так что вы можете пересчитать ее для различных элементов, не слишком беспокоясь о производительности.

Когда все эти предположения соблюдены, вы можете получить объект карты, который «работает как range».

Во-первых, обратите внимание, что range (xrange в Python 2) — это особый случай. Это не простой генератор, и он не просто возвращает список. Он также поддерживает операции in, что не является стандартной функцией итерируемых объектов или итераторов.

Учтите, что map(func, iterable) можно вызывать для бесконечного итерируемого объекта или итерируемого объекта, где процесс выборки следующего значения занимает много времени.

Вам нужно знать, что ваша функция может иметь дело с этими типами значений, и обязательно использовать ленивую функцию, например itertools.imap в противном случае. Поскольку в принципе невозможно определить, что итератор бесконечен, даже во время выполнения, не должна ли встроенная функция вести себя правильно для самого широкого диапазона входных данных?

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

Есть много преимуществ; например, это упрощает написание кода с эффективным использованием памяти.

def take_up_a_lot_of_memory(*args):
    """
    A contrived example of a function that uses a lot of memory
    """
    return sum([i ** 2 for i in range(10 ** 6)])

megasum = sum(map(take_up_a_lot_of_memory, range(1000)))

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