Выполняется ли простое задание в Python дважды?
На этой странице официального справочника Python есть следующее предложение:
Оператор расширенного присваивания, например
x += 1, можно переписать какx = x + 1, чтобы добиться аналогичного, но не совсем равного эффекта. В расширенная версия,xоценивается только один раз.
Кажется, это предполагает, что простое задание будет оцениваться x дважды. Я хотел проверить это, поэтому создал следующий пример кода:
X = [print("\t\tHello X"), 0 ]
X = X + [1]
Фактически это печатает «Hello X» только один раз, при первом задании. Я попробовал создать X[0] функцию, которая вместо этого что-то печатает, но она не работает.
Вот небольшой пример с сеттерами и геттерами:
class X:
def __init__(self, value:int = 0):
self._value = value
@property
def value(self):
print("HEllo X!")
return self._value
@value.setter
def value(self, value):
self._value = value
Теперь я экспериментирую с кодом ниже:
x = X(1)
x.value = x.value +1
x.value
Это напечатает «Hello X!» дважды. Я ожидал, что это будет трижды.
x = X(1)
x.value +=1
x.value
Это напечатает «Hello X!» дважды, столько же раз, сколько и при простом задании.
Есть ли способ проверить, действительно ли Python вычисляет x дважды с помощью простого присваивания?
Вы никогда не сможете наблюдать количество вычислений, когда выполняете простое присвоение переменных — вам нужно что-то с побочными эффектами. Рассмотрим X[foo()] += 1 против X[foo()] = X[foo()] + 1 — foo() вызывается один или два раза.
Что вы подразумеваете под «простым заданием»?
Что-то вроде X[0] += 1 эквивалентно t = X[0]; X.__setattr__(0, t.__iadd__(1)). Недополненные задания сами по себе не «оценивают» цель, но семантика задания определяется формой цели. (x.y = ... вызывает setattr(x, y, ...), x[y] = ... вызывает x.__setitem__(y, ...) и т. д.).
@jonrsharpe спасибо за ваш комментарий. Я добавил пример с сеттерами и геттерами, но все равно получаю те же результаты...
@jasonharper спасибо за ваш комментарий, я добавил более сложный пример с побочными эффектами... кажется, я все еще получаю те же результаты.
«При этом «Hello X!» выводится дважды. Я ожидал, что это будет трижды». почему ты ожидал, что это произойдет три раза? Вы получаете значение атрибута только дважды. Один раз в правой части оператора присваивания x.value + 1 и еще раз в последней строке x.value
Ответы 5
# List example
x = [1, 2, 3]
y = x
x += [4] # This modifies the original list `x` in-place.
print(x) # Output: [1, 2, 3, 4]
print(y) # Output: [1, 2, 3, 4] — `y` is still pointing to the same list.
# Reset for comparison
x = [1, 2, 3]
y = x
x = x + [4] # This creates a new list and assigns it to `x`.
print(x) # Output: [1, 2, 3, 4]
print(y) # Output: [1, 2, 3] — `y` is still pointing to the old list.
Именно так реализованы списки, а не то, что спрашивает ОП.
Может быть, во время разбора?
Похоже, это один и тот же байт-код:
>>> import dis
>>> def foo():
... x = 0
... x += 1
...
>>> def bar():
... x = 0
... x = x + 1
...
>>> dis.dis(foo)
1 0 RESUME 0
2 2 LOAD_CONST 1 (0)
4 STORE_FAST 0 (x)
3 6 LOAD_FAST 0 (x)
8 LOAD_CONST 2 (1)
10 BINARY_OP 13 (+=)
14 STORE_FAST 0 (x)
16 RETURN_CONST 0 (None)
>>> dis.dis(bar)
1 0 RESUME 0
2 2 LOAD_CONST 1 (0)
4 STORE_FAST 0 (x)
3 6 LOAD_FAST 0 (x)
8 LOAD_CONST 2 (1)
10 BINARY_OP 0 (+)
14 STORE_FAST 0 (x)
16 RETURN_CONST 0 (None)
Единственная разница в том,
10 BINARY_OP 13 (+=)
и
10 BINARY_OP 0 (+)
Я думаю, вам нужно посмотреть, как они реализованы.
Вы, кажется, неправильно поняли, что они имеют в виду под
xоценивается только один раз
в этом предложении x предполагается как выражение (которое можно вычислить)
В примере, который вы написали, выражение, которое вычисляется дважды, — это просто X, поэтому единственное, что «происходит дважды», — это разрешение имени.
Обратите внимание, что это все еще не эквивалентно, поскольку X = X + [1] вызывает функцию list.__add__, которая создает совершенно новый список, а затем устанавливает X в этот новый список,
тогда как X += [1] вызывает метод list.__iadd__, который изменяет X на месте (и, следовательно, во многих случаях он должен быть намного быстрее)
Спасибо за ваш ответ. Это скорее комментарий, чем ответ. В любом случае, спасибо за отзыв. Я добавил пример с сеттерами и геттерами, так как вы правы, а первоначальный пример был совсем не хорош;)
В документации также дается хорошее объяснение:
Оператор расширенного присваивания, например x += 1, можно переписать как x = x + 1, чтобы добиться аналогичного, но не совсем равного эффекта. В расширенной версии x оценивается только один раз. Кроме того, когда это возможно, фактическая операция выполняется на месте, а это означает, что вместо создания нового объекта и назначения его целевому объекту вместо этого модифицируется старый объект.
В отличие от обычных заданий, расширенные задания оценивают левую часть перед оценкой правой части. Например, a[i] += f(x) сначала ищет a[i], затем оценивает f(x) и выполняет сложение, и, наконец, записывает результат обратно в a[i].
r2d2, спасибо за ответ. Однако это больше уместно в качестве комментария. Кроме того, эти дополнительные предложения на самом деле не отвечают на мой вопрос.
Пример, где вы можете увидеть разницу:
d = {None: 0}
d[print('hello')] += 1
d = {None: 0}
d[print('world')] = d[print('world')] + 1
Результат (Попробуйте это онлайн!):
hello
world
world
Очень хорошо!!! Этот пример прост и удивителен! Большое спасибо! (+1)
Для дальнейшего использования этот ответ соответствует комментарию Джейсона Харпера.
@Anoldmaninthesea. У меня было достаточно времени, чтобы упростить его, пока ждали разъяснений о том, что вы имеете в виду под «простым назначением» :-). Было неясно, включает ли это назначение чему-то вроде d[print('hello')], пока вы не отредактировали, в котором использовалось x.value.
@Anoldmaninthesea. Эта «ссылка на будущее» больше не будет иметь особого смысла, как только их комментарий будет удален...
@Anoldmaninthesea. Итак, важно понимать, что с левой стороны оценивается только print('world'), а не d[print('world')], как отмечено в комментарии @chepner выше: «Недополненные задания сами по себе не «оценивают» цель, но семантика присваивания определяется формой цели.», в этом случае форма подразумевает вызов __setitem__ или, в терминах байт-кода, операцию STORE_SUBSCR
Короткий ответ: да, именно поэтому они говорят, что расширенное задание, оценивающее его один раз, отличается.