What exactly does += do?

I need to know what += does in Python. It's that simple. I also would appreciate links to definitions of other shorthand tools in Python.

In Python, += is sugar coating for the __iadd__ special method, or __add__ or __radd__ if __iadd__ isn't present. The __iadd__ method of a class can do anything it wants. The list object implements it and uses it to iterate over an iterable object appending each element to itself in the same way that the list's extend method does.

Here's a simple custom class that implements the __iadd__ special method. You initialize the object with an int, then can use the += operator to add a number. I've added a print statement in __iadd__ to show that it gets called. Also, __iadd__ is expected to return an object, so I returned the addition of itself plus the other number which makes sense in this case.

>>> class Adder(object):
	    def __init__(self, num=0):
	        self.num = num

	    def __iadd__(self, other):
	        print 'in __iadd__', other
            self.num = self.num + other
	        return self.num
	
>>> a = Adder(2)
>>> a += 3
in __iadd__ 3
>>> a
5

Hope this helps.

+= adds another value with the variable's value and assigns the new value to the variable.

>>> x = 3
>>> x += 2
>>> print x
5

-=, *=, /= does similar for subtraction, multiplication and division.

x += 5 is not exactly the same as saying x = x + 5 in Python.

Note here:

In [1]: x = [2, 3, 4]    

In [2]: y = x    

In [3]: x += 7, 8, 9    

In [4]: x
Out[4]: [2, 3, 4, 7, 8, 9]    

In [5]: y
Out[5]: [2, 3, 4, 7, 8, 9]    

In [6]: x += [44, 55]    

In [7]: x
Out[7]: [2, 3, 4, 7, 8, 9, 44, 55]    

In [8]: y
Out[8]: [2, 3, 4, 7, 8, 9, 44, 55]    

In [9]: x = x + [33, 22]    

In [10]: x
Out[10]: [2, 3, 4, 7, 8, 9, 44, 55, 33, 22]    

In [11]: y
Out[11]: [2, 3, 4, 7, 8, 9, 44, 55]

See for reference: https://stackoverflow.com/questions/2347265/why-does-behave-unexpectedly-on-lists?noredirect=1&lq=1

+= adds a number to a variable, changing the variable itself in the process (whereas + would not). Similar to this, there are the following that also modifies the variable:

• -=, subtracts a value from variable, setting the variable to the result
• *=, multiplies the variable and a value, making the outcome the variable
• /=, divides the variable by the value, making the outcome the variable
• %=, performs modulus on the variable, with the variable then being set to the result of it

There may be others. I am not a Python programmer.

It is not mere a syntactic sugar. Try this:

x = []                 # empty list
x += "something"       # iterates over the string and appends to list
print(x)               # ['s', 'o', 'm', 'e', 't', 'h', 'i', 'n', 'g']

versus

x = []                 # empty list
x = x + "something"    # TypeError: can only concatenate list (not "str") to list

The += operator invokes the __iadd__() list method, while + one invokes the __add__() one. They do different things with lists.

It adds the right operand to the left. x += 2 means x = x + 2

It can also add elements to a list -- see this SO thread.

Notionally a += b "adds" b to a storing the result in a. This simplistic description would describe the += operator in many languages.

However the simplistic description raises a couple of questions.

1. What exactly do we mean by "adding"?
2. What exactly do we mean by "storing the result in a"? python variables don't store values directly they store references to objects.

In python the answers to both of these questions depend on the data type of a.

---

So what exactly does "adding" mean?

• For numbers it means numeric addition.
• For lists, tuples, strings etc it means concatenation.

Note that for lists += is more flexible than +, the + operator on a list requires another list, but the += operator will accept any iterable.

---

So what does "storing the value in a" mean?

If the object is mutable then it is encouraged (but not required) to perform the modification in-place. So a points to the same object it did before but that object now has different content.

If the object is immutable then it obviously can't perform the modification in-place. Some mutable objects may also not have an implementation of an in-place "add" operation . In this case the variable "a" will be updated to point to a new object containing the result of an addition operation.

Technically this is implemented by looking for __IADD__ first, if that is not implemented then __ADD__ is tried and finally __RADD__.

---

Care is required when using += in python on variables where we are not certain of the exact type and in particular where we are not certain if the type is mutable or not. For example consider the following code.

def dostuff(a):
    b = a
    a += (3,4)
    print(repr(a)+' '+repr(b))

dostuff((1,2))
dostuff([1,2])

When we invoke dostuff with a tuple then the tuple is copied as part of the += operation and so b is unaffected. However when we invoke it with a list the list is modified in place, so both a and b are affected.

In python 3, similar behaviour is observed with the "bytes" and "bytearray" types.

---

Finally note that reassignment happens even if the object is not replaced. This doesn't matter much if the left hand side is simply a variable but it can cause confusing behaviour when you have an immutable collection referring to mutable collections for example:

a = ([1,2],[3,4])
a[0] += [5]

In this case [5] will successfully be added to the list referred to by a[0] but then afterwards an exception will be raised when the code tries and fails to reassign a[0].

Note x += y is not the same as x = x + y in some situations where an additional operator is included because of the operator precedence combined with the fact that the right hand side is always evaluated first, e.g.

>>> x = 2
>>> x += 2 and 1
>>> x
3

>>> x = 2
>>> x = x + 2 and 1
>>> x
1

Note the first case expand to:

>>> x = 2
>>> x = x + (2 and 1)
>>> x
3

You are more likely to encounter this in the 'real world' with other operators, e.g.

x *= 2 + 1 == x = x * (2 + 1) != x = x * 2 + 1

The short answer is += can be translated as "add whatever is to the right of the += to the variable on the left of the +=".

Ex. If you have a = 10 then a += 5 would be: a = a + 5

So, "a" now equal to 15.

+= is just a shortcut for writing

number = 4
number = number + 1

So instead you would write

numbers = 4
numbers += 1

Both ways are correct but example two helps you write a little less code

According to the documentation

> x += y is equivalent to x = operator.iadd(x, y). Another way to > put it is to say that z = operator.iadd(x, y) is equivalent to the > compound statement z = x; z += y.

So x += 3 is the same as x = x + 3.

x = 2

x += 3

print(x)

will output 5.

Notice that there's also

• &=
• //=
• <<=
• %=
• *=
• @=
• |=
• **=
• >>=
• -=
• /=
• ^=

Let's look at the byte code that CPython generates for x += y and x = x = y. (Yes, this is implementation-depenent, but it gives you an idea of the language-defined semantics being implemented.)

>>> import dis
>>> dis.dis("x += y")
  1           0 LOAD_NAME                0 (x)
              2 LOAD_NAME                1 (y)
              4 INPLACE_ADD
              6 STORE_NAME               0 (x)
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE
>>> dis.dis("x = x + y")
  1           0 LOAD_NAME                0 (x)
              2 LOAD_NAME                1 (y)
              4 BINARY_ADD
              6 STORE_NAME               0 (x)
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE

The only difference between the two is the bytecode used for the operator: INPLACE_ADD for +=, and BINARY_ADD for +.

BINARY_ADD is implemented using x.__add__ (or y.__radd__ if necessary), so x = x + y is roughly the same as x = x.__add__(y). Both __add__ and __radd__ typically return new instances, without modifying either argument.

INPLACE_ADD is implemented using x.__iadd__. If that does not exist, then x.__add__ is used in its place. x.__iadd__ typically returns x, so that the resulting STORE_NAME does not change the referent of x, though that object may have been mutated. (Indeed, the purpose of INPLACE_ADD is to provide a way to mutate an object rather than always create a new object.)

For example, int.__iadd__ is not defined, so x += 7 when x is an int is the same as x = x.__add__(y), setting x to a new instance of int.

On the other hand, list.__iadd__ is defined, so x += [7] when x is a list is the same as x = x.__iadd__([9]). list.__iadd__ effectively calls extend to add the elements of its argument to the end of x. It's not really possible to tell by looking at the value of x before and after the augmented assignment that x was reassigned, because the same object was assigned to the name.

As others also said, the += operator is a shortcut. An example:

var = 1;
var = var + 1;
#var = 2

It could also be written like so:

var = 1;
var += 1;
#var = 2

So instead of writing the first example, you can just write the second one, which would work just fine.

Remember when you used to sum, for example 2 & 3, in your old calculator and every time you hit the = you see 3 added to the total, the += does similar job. Example:

>>> orange = 2
>>> orange += 3
>>> print(orange)
5
>>> orange +=3
>>> print(orange)
8

I'm seeing a lot of answers that don't bring up using += with multiple integers.

One example:

x -= 1 + 3

This would be similar to:

x = x - (1 + 3)

and not:

x = (x - 1) + 3