问题描述
有人告诉我是否存在i += 1与i = i + 1不同的情况?
I was told that += can have different effects than the standard notation of i = i +. Is there a case in which i += 1 would be different from i = i + 1?
推荐答案
这完全取决于对象i.
+=调用 __iadd__方法(如果存在-如果不存在则返回__add__)，而+调用 __add__方法 或 __radd__方法在少数情况下 .
+= calls the __iadd__ method (if it exists -- falling back on __add__ if it doesn't exist) whereas + calls the __add__ method or the __radd__ method in a few cases.
从API的角度来看，应该使用__iadd__来修改可变对象 (返回已变异的对象)，而__add__应该返回一个 new实例.对于 immutable 对象，这两个方法都返回一个新实例，但是__iadd__会将新实例放置在当前名称空间中，并具有与旧实例相同的名称.这就是为什么
From an API perspective, __iadd__ is supposed to be used for modifying mutable objects in place (returning the object which was mutated) whereas __add__ should return a new instance of something. For immutable objects, both methods return a new instance, but __iadd__ will put the new instance in the current namespace with the same name that the old instance had. This is why
i = 1 i += 1
似乎增加了i.实际上，您获得了一个新的整数并将其"i之上"分配-丢失了对旧整数的一个引用.在这种情况下，i += 1与i = i + 1完全相同.但是，对于大多数易变的物体，情况就不同了:
seems to increment i. In reality, you get a new integer and assign it "on top of" i -- losing one reference to the old integer. In this case, i += 1 is exactly the same as i = i + 1. But, with most mutable objects, it's a different story:
作为一个具体示例:
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.
notice how in the first example, since b and a reference the same object, when I use += on b, it actually changes b (and a sees that change too -- After all, it's referencing the same list). In the second case however, when I do b = b + [1, 2, 3], this takes the list that b is referencing and concatenates it with a new list [1, 2, 3]. It then stores the concatenated list in the current namespace as b -- With no regard for what b was the line before.
在表达式x + y中，如果未实现x.__add__或x.__add__(y)返回NotImplemented 和 x和y具有不同的类型，然后x + y尝试调用 y.__radd__(x) .因此，如果您拥有
In the expression x + y, if x.__add__ isn't implemented or if x.__add__(y) returns NotImplemented and x and y have different types, then x + y tries to call y.__radd__(x). So, in the case where you have
在表达式foo_instance + bar_instance中，如果bar_instance的类型是foo_instance.__add__的子类，则会在foo_instance.__add__ 之前尝试bar_instance.__radd__. foo_instance的类型(例如issubclass(Bar, Foo)).这样做的合理性是因为Bar在某种意义上是比Foo更高级别"的对象，因此Bar应该可以选择替代Foo的行为.
In the expression foo_instance + bar_instance, bar_instance.__radd__ will be tried before foo_instance.__add__ if the type of bar_instance is a subclass of the type of foo_instance (e.g. issubclass(Bar, Foo)). The rational for this is because Bar is in some sense a "higher-level" object than Foo so Bar should get the option of overriding Foo's behavior.
这篇关于什么时候"i + = x"?与"i = i + x"不同在Python中?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！