“İ + = x”, Python'daki “i = i + x” den ne zaman farklıdır?

Bunun +=standart gösteriminden farklı etkileri olabileceği söylendi i = i +. i += 1Farklı olacak bir durum var mı i = i + 1?

Bu tamamen nesneye bağlıdır i.

+=aramaları __iadd__yöntemi (varsa - ile geri düşme __add__mevcut değil ise) ise +aramalar __add__yöntem ¹ veya __radd__bazı durumlarda yöntem ² .

Bir API perspektifinden bakıldığında, mutasyona uğramış __iadd__nesneleri yerinde değiştirmek (mutasyona uğramış nesneyi döndürmek) için kullanılırken, __add__bir şeyin yeni bir örneğini döndürmek gerekir . İçin değişmez nesneler, her iki yöntem yeni bir örnek dönmek fakat __iadd__eski örneği vardı, aynı adla geçerli ad alanında yeni bir örneğini koyacağız. Bu nedenle

i = 1
i += 1

artmış gibi görünüyor i. Gerçekte, yeni bir tamsayı alır ve bunu "üstüne" atarsınız i- eski tamsayıya bir referans kaybedersiniz. Bu durumda, i += 1tam olarak aynıdır i = i + 1. Ancak, değişebilir nesnelerle, bu farklı bir hikaye:

Somut bir örnek olarak:

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]

nazaran:

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

ihbar nasıl ilk örnekte, çünkü bve aaynı nesneye başvuran, ben kullandığınızda +=üzerinde b, aslında değişir b(ve açok bu değişikliği görür - Sonuçta, aynı listeyi referans oluyor). Ancak ikinci durumda, bunu yaptığımda b = b + [1, 2, 3], bbaşvurulan listeyi alır ve yeni bir listeyle birleştirir [1, 2, 3]. Daha sonra sıralı listeyi geçerli ad alanında b- Daha bönce satırın ne olduğuna bakmaksızın - olarak saklar .

^{1 ifadede x + y, eğer x.__add__uygulanmadı veya eğer x.__add__(y)döner NotImplemented ve xve yfarklı türleri vardır , o zaman x + yçağrı çalışır y.__radd__(x). Yani, sahip olduğunuz durumda}

^{foo_instance += bar_instance}

^{eğer Foouygulanmazsa __add__veya __iadd__o zaman buradaki sonuç aynı}

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

^{2 ifadesinde foo_instance + bar_instance, bar_instance.__radd__yargılanabileceklerdir foo_instance.__add__ halinde tipi bar_instancetürü bir alt sınıfı foo_instance(örneğin issubclass(Bar, Foo)). Çünkü bunun için rasyonel olan Bardaha "üst düzey" nesne Bir anlamda olduğu Fooböylece Bargeçersiz kılma seçeneği almalısınız Foo'ın davranışı.}

Kapakların altında, i += 1böyle bir şey yapar:

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

Buna i = i + 1benzer bir şey yaparken :

i = i.__add__(1)

Bu hafif bir aşırı basitleştirmedir, ancak fikri anlarsınız: Python, türlere +=bir __iadd__yöntem de oluşturarak özel olarak işlemek için bir yol verir __add__.

Amaç, değişebilir türlerin, örneğin list, mutasyona uğramış türler, onu uygulamamalarına rağmen, kendilerini mutasyona uğratacak __iadd__(ve sonra selfçok zor bir şey yapmazsanız geri dönecektir ) int.

Örneğin:

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

Çünkü l2aynı nesne l1ve siz mutasyona uğradınız l1, siz de mutasyona uğradınız l2.

Fakat:

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

Burada mutasyona uğramadın l1; bunun yerine, yeni bir liste oluşturulur l1 + [3]ve adını ribaund l1bırakarak ona noktaya l2orijinal listeye işaret.

(İçinde += Sürümde de yeniden hatırlıyorsunuz l1, sadece bu durumda listzaten bağlı olduğu aynı şekilde yeniden bağlıyorsunuz , bu yüzden genellikle bu kısmı göz ardı edebilirsiniz.)

Burada direkt olarak karşılaştıran bir örnek i += xile 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]