Adding and multiplying and then copying back into one variable increases, or *augments* that value.

```
a = a + b => a increases by b
a = a * b => a increases by a factor of b
a = a ** b => a increases by a power of b; b > 1
```

We can roll these operations into one statement using augmentation operators.

```
a += b
a *= b
a **= b
```

By the same token, subtracting, dividing and rooting decrease a value when the result is copied back onto itself.

```
a = a - b => decreases a by b
a = a / b => decreases a by a factor of b
a = a // b => decreases a by a factor of b, rounded down
a = a % b => decreases a to the modulo of b
a = a ** b => decreases a by a power of b; b < 1
```

Again, we can role these into one simple statement

```
a -= b
a /= b
a //= b
a %= b
a **= b; b is a fraction, such as, 9 ** 0.5 == 3
```

Segue

A number divided by 10 can be a float with some decimal fraction portion. A number floor divided by 10 can be a float or an integer, but it will have no decimal fraction portion.

```
11.0 // 2 => 5.0
11 // 2 => 5
```

Python 2 treats division differently than Python 3. We are eventually going to have to migrate over to P3 so forming good habits in P2 will help adapt to the changes in 3.

Consider the following...

```
11 / 2 => 5 in Python 2; 5.5 in Python 3
11 / 2.0 => 5.5 in Python 2; same in Python 3
```

The latter is implicitly defining a float. When we see this we can't help but think, hey, cool! But it is a poor practice to get drawn into. Explicit declarations are best.

```
float(11 / 2) => 5.5
int(11 / 2) => 5
```