After finishing our previous tutorial on Python variables in this series, you should now have a good grasp of creating and naming Python objects of different types. Let’s do some work with them!

**Here’s what you’ll learn in this tutorial:** You’ll see how calculations can be performed on objects in Python. By the end of this tutorial, you will be able to create complex **expressions** by combining objects and **operators**.

**Don’t miss the follow up tutorial:** Click here to join the Real Python Newsletter and you’ll know when the next installment comes out.

In Python, operators are special symbols that designate that some sort of computation should be performed. The values that an operator acts on are called **operands**.

Here is an example:

```
>>> a = 10
>>> b = 20
>>> a + b
30
```

In this case, the `+`

operator adds the operands `a`

and `b`

together. An operand can be either a literal value or a variable that references an object:

```
>>> a = 10
>>> b = 20
>>> a + b - 5
25
```

A sequence of operands and operators, like `a + b - 5`

, is called an expression. Python supports many operators for combining data objects into expressions. These are explored below.

## Arithmetic Operators

The following table lists the arithmetic operators supported by Python:

Operator | Example | Meaning | Result |
---|---|---|---|

`+` (unary) | `+a` | Unary Positive | `a` In other words, it doesn’t really do anything. It mostly exists for the sake of completeness, to complement Unary Negation. |

`+` (binary) | `a + b` | Addition | Sum of `a` and `b` |

`-` (unary) | `-a` | Unary Negation | Value equal to `a` but opposite in sign |

`-` (binary) | `a - b` | Subtraction | `b` subtracted from `a` |

`*` | `a * b` | Multiplication | Product of `a` and `b` |

`/` | `a / b` | Division | Quotient when `a` is divided by `b` .The result always has type `float` . |

`%` | `a % b` | Modulus | Remainder when `a` is divided by `b` |

`//` | `a // b` | Floor Division (also called Integer Division) | Quotient when `a` is divided by `b` , rounded to the next smallest whole number |

`**` | `a ** b` | Exponentiation | `a` raised to the power of `b` |

Here are some examples of these operators in use:

```
>>> a = 4
>>> b = 3
>>> +a
4
>>> -b
-3
>>> a + b
7
>>> a - b
1
>>> a * b
12
>>> a / b
1.3333333333333333
>>> a % b
1
>>> a ** b
64
```

The result of standard division (`/`

) is always a `float`

, even if the dividend is evenly divisible by the divisor:

```
>>> 10 / 5
2.0
>>> type(10 / 5)
<class 'float'>
```

When the result of floor division (`//`

) is positive, it is as though the fractional portion is truncated off, leaving only the integer portion. When the result is negative, the result is rounded down to the next smallest (greater negative) integer:

```
>>> 10 / 4
2.5
>>> 10 // 4
2
>>> 10 // -4
-3
>>> -10 // 4
-3
>>> -10 // -4
2
```

Note, by the way, that in a REPL session, you can display the value of an expression by just typing it in at the `>>>`

prompt without `print()`

, the same as you can with a literal value or variable:

```
>>> 25
25
>>> x = 4
>>> y = 6
>>> x
4
>>> y
6
>>> x * 25 + y
106
```

## Comparison Operators

Operator | Example | Meaning | Result |
---|---|---|---|

`==` | `a == b` | Equal to | `True` if the value of `a` is equal to the value of `b` `False` otherwise |

`!=` | `a != b` | Not equal to | `True` if `a` is not equal to `b` `False` otherwise |

`<` | `a < b` | Less than | `True` if `a` is less than `b` `False` otherwise |

`<=` | `a <= b` | Less than or equal to | `True` if `a` is less than or equal to `b` `False` otherwise |

`>` | `a > b` | Greater than | `True` if `a` is greater than `b` `False` otherwise |

`>=` | `a >= b` | Greater than or equal to | `True` if `a` is greater than or equal to `b` `False` otherwise |

Here are examples of the comparison operators in use:

```
>>> a = 10
>>> b = 20
>>> a == b
False
>>> a != b
True
>>> a <= b
True
>>> a >= b
False
>>> a = 30
>>> b = 30
>>> a == b
True
>>> a <= b
True
>>> a >= b
True
```

Comparison operators are typically used in Boolean contexts like conditional and loop statements to direct program flow, as you will see later.

### Equality Comparison on Floating-Point Values

Recall from the earlier discussion of floating-point numbers that the value stored internally for a `float`

object may not be precisely what you’d think it would be. For that reason, it is poor practice to compare floating-point values for exact equality. Consider this example:

```
>>> x = 1.1 + 2.2
>>> x == 3.3
False
```

Yikes! The internal representations of the addition operands are not exactly equal to `1.1`

and `2.2`

, so you cannot rely on `x`

to compare exactly to `3.3`

.

The preferred way to determine whether two floating-point values are “equal” is to compute whether they are close to one another, given some tolerance. Take a look at this example:

```
>>> tolerance = 0.00001
>>> x = 1.1 + 2.2
>>> abs(x - 3.3) < tolerance
True
```

`abs()`

returns absolute value. If the absolute value of the difference between the two numbers is less than the specified tolerance, they are close enough to one another to be considered equal.

## Logical Operators

The logical operators `not`

, `or`

, and `and`

modify and join together expressions evaluated in Boolean context to create more complex conditions.

### Logical Expressions Involving Boolean Operands

As you have seen, some objects and expressions in Python actually are of Boolean type. That is, they are equal to one of the Python objects `True`

or `False`

. Consider these examples:

```
>>> x = 5
>>> x < 10
True
>>> type(x < 10)
<class 'bool'>
>>> t = x > 10
>>> t
False
>>> type(t)
<class 'bool'>
>>> callable(x)
False
>>> type(callable(x))
<class 'bool'>
>>> t = callable(len)
>>> t
True
>>> type(t)
<class 'bool'>
```

In the examples above, `x < 10`

, `callable(x)`

, and `t`

are all Boolean objects or expressions.

Interpretation of logical expressions involving `not`

, `or`

, and `and`

is straightforward when the operands are Boolean:

Operator | Example | Meaning |
---|---|---|

`not` | `not x` | `True` if `x` is `False` `False` if `x` is `True` (Logically reverses the sense of `x` ) |

`or` | `x or y` | `True` if either `x` or `y` is `True` `False` otherwise |

`and` | `x and y` | `True` if both `x` and `y` are `True` `False` otherwise |

Take a look at how they work in practice below.

#### “`not`

” and Boolean Operands

```
x = 5
not x < 10
False
not callable(x)
True
```

Operand | Value | Logical Expression | Value |
---|---|---|---|

`x < 10` | `True` | `not x < 10` | `False` |

`callable(x)` | `False` | `not callable(x)` | `True` |

#### “`or`

” and Boolean Operands

```
x = 5
x < 10 or callable(x)
True
x < 0 or callable(x)
False
```

Operand | Value | Operand | Value | Logical Expression | Value |
---|---|---|---|---|---|

`x < 10` | `True` | `callable(x)` | `False` | `x < 10 or callable(x)` | `True` |

`x < 0` | `False` | `callable(x)` | `False` | `x < 0 or callable(x)` | `False` |

#### “`and`

” and Boolean Operands

```
x = 5
x < 10 and callable(x)
False
x < 10 and callable(len)
True
```

Operand | Value | Operand | Value | Logical Expression | Value |
---|---|---|---|---|---|

`x < 10` | `True` | `callable(x)` | `False` | `x < 10 and callable(x)` | `False` |

`x < 10` | `True` | `callable(len)` | `True` | `x < 10 or callable(len)` | `True` |

### Evaluation of Non-Boolean Values in Boolean Context

Many objects and expressions are not equal to `True`

or `False`

. Nonetheless, they may still be evaluated in Boolean context and determined to be “truthy” or “falsy.”

So what is true and what isn’t? As a philosophical question, that is outside the scope of this tutorial!

But in Python, it is well-defined. All the following are considered false when evaluated in Boolean context:

- The Boolean value
`False`

- Any value that is numerically zero (
`0`

,`0.0`

,`0.0+0.0j`

) - An empty string
- An object of a built-in composite data type which is empty (see below)
- The special value denoted by the Python keyword
`None`

Virtually any other object built into Python is regarded as true.

You can determine the “truthiness” of an object or expression with the built-in `bool()`

function. `bool()`

returns `True`

if its argument is truthy and `False`

if it is falsy.

#### Numeric Value

A zero value is false.

A non-zero value is true.

```
>>> print(bool(0), bool(0.0), bool(0.0+0j))
False False False
>>> print(bool(-3), bool(3.14159), bool(1.0+1j))
True True True
```

#### String

An empty string is false.

A non-empty string is true.

```
>>> print(bool(''), bool(""), bool(""""""))
False False False
>>> print(bool('foo'), bool(" "), bool(''' '''))
True True True
```

#### Built-In Composite Data Object

Python provides built-in composite data types called

`list`

,`tuple`

,`dict`

, and`set`

. These are “container” types that contain other objects. An object of one of these types is considered false if it is empty and true if it is non-empty.The examples below demonstrate this for the

`list`

type. (Lists are defined in Python with square brackets.)For more information on the

`list`

,`tuple`

,`dict`

, and`set`

types, see the upcoming tutorials.

```
>>> type([])
<class 'list'>
>>> bool([])
False
>>> type([1, 2, 3])
<class 'list'>
>>> bool([1, 2, 3])
True
```

#### The “`None`

” Keyword

`None`

is always false:

```
>>> bool(None)
False
```

### Logical Expressions Involving Non-Boolean Operands

Non-Boolean values can also be modified and joined by `not`

, `or`

and, `and`

. The result depends on the “truthiness” of the operands.

#### “`not`

” and Non-Boolean Operands

Here is what happens for a non-Boolean value `x`

:

If `x` is | `not x` is |
---|---|

“truthy” | `False` |

“falsy” | `True` |

Here are some concrete examples:

```
>>> x = 3
>>> bool(x)
True
>>> not x
False
>>> x = 0.0
>>> bool(x)
False
>>> not x
True
```

#### “`or`

” and Non-Boolean Operands

This is what happens for two non-Boolean values `x`

and `y`

:

If `x` is | `x or y` is |
---|---|

truthy | `x` |

falsy | `y` |

Note that in this case, the expression `x or y`

does not evaluate to either `True`

or `False`

, but instead to one of either `x`

or `y`

:

```
>>> x = 3
>>> y = 4
>>> x or y
3
>>> x = 0.0
>>> y = 4.4
>>> x or y
4.4
```

Even so, it is still the case that the expression `x or y`

will be truthy if either `x`

or `y`

is truthy, and falsy if both `x`

and `y`

are falsy.

#### “`and`

” and Non-Boolean Operands

Here’s what you’ll get for two non-Boolean values `x`

and `y`

:

If `x` is | `x and y` is |
---|---|

“truthy” | `y` |

“falsy” | `x` |

```
>>> x = 3
>>> y = 4
>>> x and y
4
>>> x = 0.0
>>> y = 4.4
>>> x and y
0.0
```

As with `or`

, the expression `x and y`

does not evaluate to either `True`

or `False`

, but instead to one of either `x`

or `y`

. `x and y`

will be truthy if both `x`

and `y`

are truthy, and falsy otherwise.

### Compound Logical Expressions and Short-Circuit Evaluation

So far, you have seen expressions with only a single `or`

or `and`

operator and two operands:

```
x or y
x and y
```

Multiple logical operators and operands can be strung together to form compound logical expressions.

#### Compound “`or`

” Expressions

Consider the following expression:

x_{1}`or`

x_{2}`or`

x_{3}`or`

…x_{n}

This expression is true if any of the **x _{i}** are true.

In an expression like this, Python uses a methodology called short-circuit evaluation, also called McCarthy evaluation in honor of computer scientist John McCarthy. The **x _{i}** operands are evaluated in order from left to right. As soon as one is found to be true, the entire expression is known to be true. At that point, Python stops and no more terms are evaluated. The value of the entire expression is that of the

**x**that terminated evaluation.

_{i}To help demonstrate short-circuit evaluation, suppose that you have a simple “identity” function `f()`

that behaves as follows:

`f()`

takes a single argument.- It displays the argument to the console.
- It returns the argument passed to it as its return value.

(You will see how to define such a function in the upcoming tutorial on Functions.)

Several example calls to `f()`

are shown below:

```
>>> f(0)
-> f(0) = 0
0
>>> f(False)
-> f(False) = False
False
>>> f(1.5)
-> f(1.5) = 1.5
1.5
```

Because `f()`

simply returns the argument passed to it, we can make the expression `f(arg)`

be truthy or falsy as needed by specifying a value for `arg`

that is appropriately truthy or falsy. Additionally, `f()`

displays its argument to the console, which visually confirms whether or not it was called.

Now, consider the following compound logical expression:

```
>>> f(0) or f(False) or f(1) or f(2) or f(3)
-> f(0) = 0
-> f(False) = False
-> f(1) = 1
1
```

The interpreter first evaluates `f(0)`

, which is `0`

. A numeric value of `0`

is false. The expression is not true yet, so evaluation proceeds left to right. The next operand, `f(False)`

, returns `False`

. That is also false, so evaluation continues.

Next up is `f(1)`

. That evaluates to `1`

, which is true. At that point, the interpreter stops because it now knows the entire expression to be true. `1`

is returned as the value of the expression, and the remaining operands, `f(2)`

and `f(3)`

, are never evaluated. You can see from the display that the `f(2)`

and `f(3)`

calls do not occur.

#### Compound “`and`

” Expressions

A similar situation exists in an expression with multiple `and`

operators:

x_{1}`and`

x_{2}`and`

x_{3}`and`

…x_{n}

This expression is true if all the **x _{i}** are true.

In this case, short-circuit evaluation dictates that the interpreter stop evaluating as soon as any operand is found to be false, because at that point the entire expression is known to be false. Once that is the case, no more operands are evaluated, and the falsy operand that terminated evaluation is returned as the value of the expression:

```
>>> f(1) and f(False) and f(2) and f(3)
-> f(1) = 1
-> f(False) = False
False
>>> f(1) and f(0.0) and f(2) and f(3)
-> f(1) = 1
-> f(0.0) = 0.0
0.0
```

In both examples above, evaluation stops at the first term that is false—`f(False)`

in the first case, `f(0.0)`

in the second case—and neither the `f(2)`

nor `f(3)`

call occurs. `False`

and `0.0`

, respectively, are returned as the value of the expression.

If all the operands are truthy, they all get evaluated and the last (rightmost) one is returned as the value of the expression:

```
>>> f(1) and f(2.2) and f('bar')
-> f(1) = 1
-> f(2.2) = 2.2
-> f(bar) = bar
'bar'
```

### Idioms That Exploit Short-Circuit Evaluation

There are some common idiomatic patterns that exploit short-circuit evaluation for conciseness of expression.

#### Avoiding an Exception

Suppose you have defined two variables `a`

and `b`

, and you want to know whether `(b / a) > 0`

:

```
>>> a = 3
>>> b = 1
>>> (b / a) > 0
True
```

But you need to account for the possibility that `a`

might be `0`

, in which case the interpreter will raise an exception:

```
>>> a = 0
>>> b = 1
>>> (b / a) > 0
Traceback (most recent call last):
File "<pyshell#2>", line 1, in <module>
(b / a) > 0
ZeroDivisionError: division by zero
```

You can avoid an error with an expression like this:

```
>>> a = 0
>>> b = 1
>>> a != 0 and (b / a) > 0
False
```

When `a`

is `0`

, `a != 0`

is false. Short-circuit evaluation ensures that evaluation stops at that point. `(b / a)`

is not evaluated, and no error is raised.

If fact, you can be even more concise than that. When `a`

is `0`

, the expression `a`

by itself is falsy. There is no need for the explicit comparison `a != 0`

:

```
>>> a = 0
>>> b = 1
>>> a and (b / a) > 0
0
```

#### Selecting a Default Value

Another idiom involves selecting a default value when a specified value is zero or empty. For example, suppose you want to assign a variable `s`

to the value contained in another variable called `string`

. But if `string`

is empty, you want to supply a default value.

Here is a concise way of expressing this using short-circuit evaluation:

```
s = string or '<default_value>'
```

If `string`

is non-empty, it is truthy, and the expression `string or '<default_value>'`

will be true at that point. Evaluation stops, and the value of `string`

is returned and assigned to `s`

:

```
>>> string = 'foo bar'
>>> s = string or '<default_value>'
>>> s
'foo bar'
```

On the other hand, if `string`

is an empty string, it is falsy. Evaluation of `string or '<default_value>'`

continues to the next operand, `'<default_value>'`

, which is returned and assigned to `s`

:

```
>>> string = ''
>>> s = string or '<default_value>'
>>> s
'<default_value>'
```

### Chained Comparisons

Comparison operators can be chained together to arbitrary length. For example, the following expressions are nearly equivalent:

```
x < y <= z
x < y and y <= z
```

They will both evaluate to the same Boolean value. The subtle difference between the two is that in the chained comparison `x < y <= z`

, `y`

is evaluated only once. The longer expression `x < y and y <= z`

will cause `y`

to be evaluated twice.

**Note:** In cases where `y`

is a static value, this will not be a significant distinction. But consider these expressions:

```
x < f() <= z
x < f() and f() <= z
```

If `f()`

is a function that causes program data to be modified, the difference between its being called once in the first case and twice in the second case may be important.

More generally, if ** op_{1}, op_{2},** …,

**are comparison operators, then the following have the same Boolean value:**

*op*_{n}x

_{1}xop_{1}_{2}xop_{2}_{3}… x_{n-1}xop_{n}_{n}x

_{1}xop_{1}_{2}`and`

x_{2}xop_{2}_{3}`and`

… x_{n-1}xop_{n}_{n}

In the former case, each x_{i} is only evaluated once. In the latter case, each will be evaluated twice except the first and last, unless short-circuit evaluation causes premature termination.

## Bitwise Operators

Bitwise operators treat operands as sequences of binary digits and operate on them bit by bit. The following operators are supported:

Operator | Example | Meaning | Result |
---|---|---|---|

`&` | `a & b` | bitwise AND | Each bit position in the result is the logical AND of the bits in the corresponding position of the operands. (`1` if both are `1` , otherwise `0` .) |

`|` | `a | b` | bitwise OR | Each bit position in the result is the logical OR of the bits in the corresponding position of the operands. (`1` if either is `1` , otherwise `0` .) |

`~` | `~a` | bitwise negation | Each bit position in the result is the logical negation of the bit in the corresponding position of the operand. (`1` if `0` , `0` if `1` .) |

`^` | `a ^ b` | bitwise XOR (exclusive OR) | Each bit position in the result is the logical XOR of the bits in the corresponding position of the operands. (`1` if the bits in the operands are different, `0` if they are the same.) |

`>>` | `a >> n` | Shift right `n` places | Each bit is shifted right `n` places. |

`<<` | `a << n` | Shift left `n` places | Each bit is shifted left `n` places. |

Here are some examples:

```
>>> '0b{:04b}'.format(0b1100 & 0b1010)
'0b1000'
>>> '0b{:04b}'.format(0b1100 | 0b1010)
'0b1110'
>>> '0b{:04b}'.format(0b1100 ^ 0b1010)
'0b0110'
>>> '0b{:04b}'.format(0b1100 >> 2)
'0b0011'
>>> '0b{:04b}'.format(0b0011 << 2)
'0b1100'
```

**Note:** The purpose of the `'0b{:04b}'.format()`

is to format the numeric output of the bitwise operations, to make them easier to read. You will see the `format()`

method in much more detail later. For now, just pay attention to the operands of the bitwise operations, and the results.

## Identity Operators

Python provides two operators, `is`

and `is not`

, that determine whether the given operands have the same identity—that is, refer to the same object. This is not the same thing as equality, which means the two operands refer to objects that contain the same data but are not necessarily the same object.

Here is an example of two object that are equal but not identical:

```
>>> x = 1001
>>> y = 1000 + 1
>>> print(x, y)
1001 1001
>>> x == y
True
>>> x is y
False
```

Here, `x`

and `y`

both refer to objects whose value is `1001`

. They are equal. But they do not reference the same object, as you can verify:

```
>>> id(x)
60307920
>>> id(y)
60307936
```

`x`

and `y`

do not have the same identity, and `x is y`

returns `False`

.

You saw previously that when you make an assignment like `x = y`

, Python merely creates a second reference to the same object, and that you could confirm that fact with the `id()`

function. You can also confirm it using the `is`

operator:

```
>>> a = 'I am a string'
>>> b = a
>>> id(a)
55993992
>>> id(b)
55993992
>>> a is b
True
>>> a == b
True
```

In this case, since `a`

and `b`

reference the same object, it stands to reason that `a`

and `b`

would be equal as well.

Unsurprisingly, the opposite of `is`

is `is not`

:

```
>>> x = 10
>>> y = 20
>>> x is not y
True
```

## Operator Precedence

Consider this expression:

```
>>> 20 + 4 * 10
60
```

There is ambiguity here. Should Python perform the addition `20 + 4`

first and then multiply the sum by `10`

? Or should the multiplication `4 * 10`

be performed first, and the addition of `20`

second?

Clearly, since the result is `60`

, Python has chosen the latter; if it had chosen the former, the result would be `240`

. This is standard algebraic procedure, found universally in virtually all programming languages.

All operators that the language supports are assigned a precedence. In an expression, all operators of highest precedence are performed first. Once those results are obtained, operators of the next highest precedence are performed. So it continues, until the expression is fully evaluated. Any operators of equal precedence are performed in left-to-right order.

Here is the order of precedence of the Python operators you have seen so far, from lowest to highest:

Operator | Description | |
---|---|---|

lowest precedence | `or` | Boolean OR |

`and` | Boolean AND | |

`not` | Boolean NOT | |

`==` , `!=` , `<` , `<=` , `>` , `>=` , `is` , `is not` | comparisons, identity | |

`|` | bitwise OR | |

`^` | bitwise XOR | |

`&` | bitwise AND | |

`<<` , `>>` | bit shifts | |

`+` , `-` | addition, subtraction | |

`*` , `/` , `//` , `%` | multiplication, division, floor division, modulo | |

`+x` , `-x` , `~x` | unary positive, unary negation, bitwise negation | |

highest precedence | `**` | exponentiation |

Operators at the top of the table have the lowest precedence, and those at the bottom of the table have the highest. Any operators in the same row of the table have equal precedence.

It is clear why multiplication is performed first in the example above: multiplication has a higher precedence than addition.

Similarly, in the example below, `3`

is raised to the power of `4`

first, which equals `81`

, and then the multiplications are carried out in order from left to right (`2 * 81 * 5 = 810`

):

```
>>> 2 * 3 ** 4 * 5
810
```

Operator precedence can be overridden using parentheses. Expressions in parentheses are always performed first, before expressions that are not parenthesized. Thus, the following happens:

```
>>> 20 + 4 * 10
60
>>> (20 + 4) * 10
240
>>> 2 * 3 ** 4 * 5
810
>>> 2 * 3 ** (4 * 5)
6973568802
```

In the first example, `20 + 4`

is computed first, then the result is multiplied by `10`

. In the second example, `4 * 5`

is calculated first, then `3`

is raised to that power, then the result is multiplied by `2`

.

There is nothing wrong with making liberal use of parentheses, even when they aren’t necessary to change the order of evaluation. In fact, it is considered good practice, because it can make the code more readable, and it relieves the reader of having to recall operator precedence from memory. Consider the following:

```
(a < 10) and (b > 30)
```

Here the parentheses are fully unnecessary, as the comparison operators have higher precedence than `and`

does and would have been performed first anyhow. But some might consider the intent of the parenthesized version more immediately obvious than this version without parentheses:

```
a < 10 and b > 30
```

On the other hand, there are probably those who would prefer the latter; it’s a matter of personal preference. The point is, you can always use parentheses if you feel it makes the code more readable, even if they aren’t necessary to change the order of evaluation.

## Augmented Assignment Operators

You have seen that a single equal sign (`=`

) is used to assign a value to a variable. It is, of course, perfectly viable for the value to the right of the assignment to be an expression containing other variables:

```
>>> a = 10
>>> b = 20
>>> c = a * 5 + b
>>> c
70
```

In fact, the expression to the right of the assignment can include references to the variable that is being assigned to:

```
>>> a = 10
>>> a = a + 5
>>> a
15
>>> b = 20
>>> b = b * 3
>>> b
60
```

The first example is interpreted as “`a`

is assigned the current value of `a`

plus `5`

,” effectively increasing the value of `a`

by `5`

. The second reads “`b`

is assigned the current value of `b`

times `3`

,” effectively increasing the value of `b`

threefold.

Of course, this sort of assignment only makes sense if the variable in question has already previously been assigned a value:

```
>>> z = z / 12
Traceback (most recent call last):
File "<pyshell#11>", line 1, in <module>
z = z / 12
NameError: name 'z' is not defined
```

Python supports a shorthand augmented assignment notation for these arithmetic and bitwise operators:

Arithmetic | Bitwise |
---|---|

`+` `-` `*` `/` `%` `//` `**` | `&` `|` `^` `>>` `<<` |

For these operators, the following are equivalent:

```
x <op>= y
x = x <op> y
```

Take a look at these examples:

Augmented Assignment | Standard Assignment | |
---|---|---|

`a += 5` | is equivalent to | `a = a + 5` |

`a /= 10` | is equivalent to | `a = a / 10` |

`a ^= b` | is equivalent to | `a = a ^ b` |

## Conclusion

In this tutorial, you learned about the diverse **operators** Python supports to combine objects into **expressions**.

Most of the examples you have seen so far have involved only simple atomic data, but you saw a brief introduction to the **string** data type. The next tutorial will explore **string** objects in much more detail.

**Get Notified:** Don’t miss the follow up to this tutorial—Click here to join the Real Python Newsletter and you’ll know when the next installment comes out.

*[ Improve Your Python With 🐍 Python Tricks 💌 – Get a short & sweet Python Trick delivered to your inbox every couple of days. >> Click here to learn more and see examples ]*

**
Source From: realpython.com.
Original article title: Operators and Expressions in Python.
This full article can be read at: Operators and Expressions in Python.
**

**Advertisement**