Фильтрация понятий списка - "ловушка set()"

Ответ 1

Чтобы оптимизировать set(list_2), интерпретатор должен доказать, что list_2 (и все его элементы) не изменяется между итерациями. Это сложная проблема в общем случае, и меня не удивит, если интерпретатор даже не попытается ее решить.

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

Ответ 2

От Что нового в Python 3.2:

Оптимизатор Pythons peephole теперь распознает шаблоны, такие как x in {1, 2, 3} как тест для членства в наборе констант. Оптимизатор переустанавливает набор как фризонсет и сохраняет заранее созданную константу.

Ответ 3

Итак, теперь мне интересно - почему python 3.x может оптимизировать настройку literal только для сборки один раз, но не установлен (list_2)?

Никто еще не упоминал эту проблему: как вы знаете, что set([1,2,3]) и {1, 2, 3} - это одно и то же?

>>> import random
>>> def set(arg):
...     return [random.choice(range(5))]
... 
>>> list1 = list(range(5))
>>> [x for x in list1 if x in set(list1)]
[0, 4]
>>> [x for x in list1 if x in set(list1)]
[0]

Вы не можете затенять литерал; вы можете затенять set. Поэтому, прежде чем вы сможете рассмотреть подъем, вам нужно знать не только то, что list1 не влияет, вы должны быть уверены, что set - это то, что вы думаете. Иногда вы можете это сделать, либо в ограниченных условиях во время компиляции, либо более удобно во время выполнения, но это определенно нетривиально.

Это смешно: часто, когда появляется предложение сделать такие оптимизации, один pushback - это так же хорошо, как и они, это затрудняет рассуждение о том, как будет выглядеть производительность Python, даже алгоритмически. Ваш вопрос дает некоторые доказательства для этого возражения.

Ответ 4

Слишком долго для комментария

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

class context_set(set):
    def __enter__(self):
        return self
    def __exit__(self, *args):
        pass

def context_version():
    with context_set(list_2) as s:
        return [x for x in list_1 if x in s]

Используя это, я вижу:

In [180]: %timeit context_version()
100 loops, best of 3: 17.8 ms per loop

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

Более общую версию можно сделать с помощью contextlib.contextmanager. Вот быстрая и грязная версия того, что я имею в виду.

def context(some_type):
    from contextlib import contextmanager
    generator_apply_type = lambda x: (some_type(y) for y in (x,))
    return contextmanager(generator_apply_type)

Тогда можно сделать:

with context(set)(list_2) as s:
    # ...

или так же легко

with context(tuple)(list_2) as t:
    # ...

Ответ 5

Основная причина заключается в том, что литерал действительно не может измениться, тогда как если это выражение типа set(list_2), возможно, что оценка целевого выражения или итерабельности понимания может изменить значение set(list_2). Например, если у вас есть

[f(x) for x in list_1 if x in set(list_2)]

Возможно, что f изменяет list_2.

Даже для простого выражения [x for x in blah ...] теоретически возможно, что метод __iter__ blah может изменить list_2.

Я бы предположил, что есть некоторые возможности для оптимизации, но текущее поведение упрощает работу. Если вы начнете добавлять оптимизацию для таких вещей, как "она оценивается только один раз, если целевое выражение является единственным голосом, а итерируемый - встроенным списком или dict...", вы значительно усложняете, чтобы выяснить, что произойдет в любом данной ситуации.