# Python Operators Overview

## What Are Python Operators?

Python operators are special syntactical sugar to run basic operations without calling their respective methods. For example, you can use the `+` operator in `a + b` instead of the more clunky `.add()` method in `a.add(b)`. Each operator has a unique symbol that is placed between the two arguments called operands.

A simple example is given next where the + operator is applied to operands 40 and 2 to generate the sum 42:

```>>> 40 + 2
42```

## Comparison Operators

Comparison operators are applied to comparable objects and they return a Boolean value (`True` or `False`).

You can check out a full guide on all of those comparison operators in the following blog tutorial on the Finxter blog.

Related Tutorial: Python Comparison Operators

## Arithmetic Operators

Arithmetic operators are syntactical shortcuts to perform basic mathematical operations on numbers.

## Logical Operators

Logical operators are shortcuts to perform Boolean comparisons, but can be used on integers and other objects as well.

Related Tutorial: Python Logical Operators

## Bitwise Operators

Bitwise operators perform operations on the binary (bit) representation of integers.

Background: Each integer is first written as a binary number that is a sequence of digits 0 or 1. For example:

• 0 is written as “0”
• 1 is written as “1”
• 2 is written as “10”
• 3 is written as “11”
• 4 is written as “100”
• 5 is written as “101”

The bitwise operators are then applied on those binary representations. The resulting binary number is then converted back to the integer representation (decimal number).

In the following table, we exemplify all bit-wise operators with variables `x` and `y` defined as follows:

```>>> x = 4  # 100
>>> y = 5  # 101```

As a comment, we also provide the binary representation `100` for the decimal integer `4`, and `101` for the decimal integer `5`.

Related Tutorial: Python Bitwise Operators

## In-Place Assignment Operators

In-place assignment operators (also called compound assignment operators) perform an operation in-place on a variable provided as first operand. They overwrite the value of the first operand variable with the result of the operation when performing the operator without assignment. For example, `x += 3` is the same as `x = x + 3` of first calculating the result of `x +3` and then assigning it to the variable x.

## Identity Operators

Python has two identity operators: `is` and `is not`. They are used to check if two values or variables reside at the same memory location, i.e., refer to the same object in memory. However, if two variables are equal, this doesn’t imply that they are identical. For example, two lists `[1, 2, 3]` and `[1, 2, 3]` may be different objects (not identical) but they’re equal in value.

## Membership Operators

Python has two membership operators `in` and `not in` that test whether a value or variable exists in a collection such as string, list, tuple, set, and dictionary.

## Python Operators Precedence

The following table describes Python’s operator precedence relationship, from highest to lowest precedence.

Operators in the same row have the same precedence. For example, comparisons, membership, and identity have the same precedence. In case of a conflict, they have a left-to-right precedence resolution scheme. In other words, the left operator has precedence over the right operator if both have the same theoretical precedence level.

Related Article: Operator Precedence [Blog + Video]