Когда «i + = x» отличается от «i = i + x» в Python?

Question

Мне сказали, что += может иметь разные эффекты, чем стандартная нотация i = i +. Есть ли случай, когда i += 1 будет отличаться от i = i + 1?

Answer 1

Это полностью зависит от объекта i.

+= называет __iadd__ method (если она существует - падение назад на __add__, если он не существует), тогда как + называет __add__ method или __radd__ method in a few cases .

С точки зрения API, __iadd__ предполагается использовать для модификации изменяемых объектов вместо (возвращая объект, который был мутантный), тогда как __add__ должен возвращать новый экземпляр чего-то. Для неизменяемых объектов оба метода возвращают новый экземпляр, но __iadd__ помещает новый экземпляр в текущее пространство имен с тем же именем, что и у старого экземпляра. Вот почему

i = 1 
i += 1 

, похоже, увеличивает i. На самом деле вы получаете новое целое число и назначаете его «поверх» i - теряете одну ссылку на старое целое число. В этом случае i += 1 точно такой же, как i = i + 1. Но, с большинством изменяемых объектов, это другая история:

В качестве конкретного примера:

a = [1, 2, 3] 
b = a 
b += [1, 2, 3] 
print a #[1, 2, 3, 1, 2, 3] 
print b #[1, 2, 3, 1, 2, 3] 

по сравнению с:

a = [1, 2, 3] 
b = a 
b = b + [1, 2, 3] 
print a #[1, 2, 3] 
print b #[1, 2, 3, 1, 2, 3] 

Обратите внимание, как в первом примере, так как b и a эталонным тот же объект, когда я использую += на b, он фактически меняет b (и a видит, что тоже меняется). В конце концов, он ссылается на тот же список). Во втором случае, однако, когда я делаю b = b + [1, 2, 3], это берет список, который b ссылается и объединяет его с новым списком [1, 2, 3]. Затем он сохраняет объединенный список в текущем пространстве имен как b - без учета того, что было b.

---

^{В выражении x + y, если x.__add__ не реализован или если x.__add__(y) возвращает NotImplementedиx и y имеют различные типы, затем x + y пытается вызвать y.__radd__(x).Таким образом, в случае, когда у вас есть}

^{foo_instance += bar_instance}

^{если Foo не реализует __add__ или __iadd__ то результат здесь такой же, как}

^{foo_instance = bar_instance.__radd__(bar_instance, foo_instance)}

^{В выражении foo_instance + bar_instance, bar_instance.__radd__ будет проверяться до foo_instance.__add__, если тип bar_instance является подклассом типа foo_instance (например, issubclass(Bar, Foo)). Рациональным для этого является то, что Bar в некотором смысле является объектом «более высокого уровня», чем Foo, поэтому Bar должен получить возможность переопределения поведения Foo.}

Answer 2

Под одеялом, i += 1 делает что-то вроде этого:

try: 
    i = i.__iadd__(1) 
except AttributeError: 
    i = i.__add__(1) 

Хотя i = i + 1 делает что-то вроде этого:

i = i.__add__(1) 

Это небольшое упрощение, но вы получите идею: Python дает тип способ обработки += специально, создав метод __iadd__, а также __add__.

Намерение состоит в том, что изменяемые типы, как list, мутирует себя в __iadd__ (а затем вернуться self, если вы делаете что-то очень сложно), в то время как неизменные типы, как int, просто не реализовать.

Например:

>>> l1 = [] 
>>> l2 = l1 
>>> l1 += [3] 
>>> l2 
[3] 

Поскольку l2 тот же объект, как l1, и вы мутировали l1, вы также мутировали l2.

Но:

>>> l1 = [] 
>>> l2 = l1 
>>> l1 = l1 + [3] 
>>> l2 
[] 

Здесь вы не мутировать l1; вместо этого вы создали новый список, l1 + [3], и отскочите имя l1, чтобы указать на него, оставив l2, указывая на исходный список.

(В версии +=, вы также подмена l1, это просто, что в этом случае вы пересвязывание его к тому же list он был уже связан с, так что вы можете обычно игнорировать эту часть.)

Answer 3

Если вы просто имеете дело с литералами, то i += 1 имеет то же поведение, что и i = i + 1.

Answer 4

Вот пример, который непосредственно сравнивает i += x с i = i + x:

def foo(x): 
    x = x + [42] 

def bar(x): 
    x += [42] 

c = [27] 
foo(c); # c is not changed 
bar(c); # c is changed to [27, 42] 

Answer 5

Говоря простыми словами, у вас есть два случая:

i = i + 1 

Это создает новую переменную я, используя значение предыдущего I и увеличивает его на единицу и сохраняет его в другом месте памяти.

i += 1 

Это не создает новую переменную, а увеличивает приращение переменной i в той же ячейке памяти. Это намного эффективнее предыдущего.