На этой странице официального справочника 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 дважды с помощью простого присваивания?
🤔 А знаете ли вы, что...
Python поддерживает параллельное и асинхронное программирование с помощью модулей asyncio и multiprocessing.
# 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].
Пример, где вы можете увидеть разницу:
d = {None: 0}
d[print('hello')] += 1
d = {None: 0}
d[print('world')] = d[print('world')] + 1
Результат (Попробуйте это онлайн!):
hello
world
world