{"id":2638,"date":"2026-10-19T10:04:55","date_gmt":"2026-10-19T10:04:55","guid":{"rendered":"https:\/\/prwatech.in\/blog\/?p=2638"},"modified":"2026-10-20T05:42:55","modified_gmt":"2026-10-20T05:42:55","slug":"python-operators-tutorial","status":"publish","type":"post","link":"https:\/\/prwatech.in\/blog\/python\/python-data-types\/python-operators-tutorial\/","title":{"rendered":"Python Operators"},"content":{"rendered":"

Python Operators Tutorial With Examples<\/b><\/strong><\/h1>\r\n

Every program you write does the same few things with data. It adds numbers, compares two values, checks whether an item is in a list, or decides whether two conditions are both true. Each of these small actions is done by an operator, a symbol such as the plus sign, the equals sign or a word such as and<\/code>.<\/p>\r\n

An operator tells Python what to do with the values next to it. Those values are called operands. In the expression 20 + 3<\/code>, the plus sign is the operator, and 20 and 3 are the operands. The whole thing is called an expression, and Python works out its value. You will use operators in the first program you write and in the ten thousandth, so it pays to learn them properly once.<\/p>\r\n

In this tutorial, we go through all seven groups of Python operators: arithmetic, assignment, comparison, logical, identity, membership and bitwise. Every example uses the same two variables, x<\/code> as 20 and y<\/code> as 3, and shows the real output from Python 3.13. We then cover operator precedence, which decides what runs first, and the mistakes beginners make most often, such as comparing floats with the equals operator and confusing is<\/code> with ==<\/code>. We finish with a quick reference and the complete script.<\/p>\r\n

Types of Operators in Python<\/h2>\r\n

Python groups its operators by the job they do. Here are the seven groups, with what each one answers.<\/p>\r\n

\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n
The seven groups of Python operators<\/caption>\r\n
Group<\/th>\r\nWhat it does<\/th>\r\nExamples<\/th>\r\n<\/tr>\r\n<\/thead>\r\n
Arithmetic<\/th>\r\nDoes maths on numbers<\/td>\r\n+ – * \/ % ** \/\/<\/td>\r\n<\/tr>\r\n
Assignment<\/th>\r\nStores a value in a variable<\/td>\r\n= += -= *= and more<\/td>\r\n<\/tr>\r\n
Comparison<\/th>\r\nCompares two values, gives True or False<\/td>\r\n== != > < >= <=<\/td>\r\n<\/tr>\r\n
Logical<\/th>\r\nCombines conditions<\/td>\r\nand or not<\/td>\r\n<\/tr>\r\n
Identity<\/th>\r\nChecks if two names point to the same object<\/td>\r\nis is not<\/td>\r\n<\/tr>\r\n
Membership<\/th>\r\nChecks if a value is inside a collection<\/td>\r\nin not in<\/td>\r\n<\/tr>\r\n
Bitwise<\/th>\r\nWorks on the binary bits of whole numbers<\/td>\r\n& | ^ ~ << >><\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/div>\r\n

For every example below, we start with these two variables:<\/p>\r\n

\r\n
python<\/div>\r\n
x = 20\r\ny = 3<\/pre>\r\n<\/div>\r\n
Arithmetic Operators in Python<\/h2>\r\n
Arithmetic operators do the maths you learned at school. Python has seven of them.<\/p>\r\n
\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n
Arithmetic operators with x as 20 and y as 3<\/caption>\r\n
Name<\/th>\r\nSymbol<\/th>\r\nExample<\/th>\r\nResult<\/th>\r\n<\/tr>\r\n<\/thead>\r\n
Addition<\/th>\r\n+<\/td>\r\nx + y<\/td>\r\n23<\/td>\r\n<\/tr>\r\n
Subtraction<\/th>\r\n–<\/td>\r\nx – y<\/td>\r\n17<\/td>\r\n<\/tr>\r\n
Multiplication<\/th>\r\n*<\/td>\r\nx * y<\/td>\r\n60<\/td>\r\n<\/tr>\r\n
Division<\/th>\r\n\/<\/td>\r\nx \/ y<\/td>\r\n6.666666666666667<\/td>\r\n<\/tr>\r\n
Modulus<\/th>\r\n%<\/td>\r\nx % y<\/td>\r\n2 (the remainder)<\/td>\r\n<\/tr>\r\n
Exponent<\/th>\r\n**<\/td>\r\nx ** y<\/td>\r\n8000 (20 to the power 3)<\/td>\r\n<\/tr>\r\n
Floor division<\/th>\r\n\/\/<\/td>\r\nx \/\/ y<\/td>\r\n6 (the whole number part)<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/div>\r\n
\r\n
python<\/div>\r\n
x = 20\r\ny = 3\r\nprint(x + y, x - y, x * y)\r\nprint(x \/ y)\r\nprint(round(x \/ y, 2))\r\nprint(x % y, x ** y, x \/\/ y)<\/pre>\r\n
output<\/div>\r\n
23 17 60\r\n6.666666666666667\r\n6.67\r\n2 8000 6<\/pre>\r\n<\/div>\r\n
Two points trip up beginners. First, the division operator always returns a float, even when the numbers divide evenly, so 8 divided by 2 gives 4.0 and not 4. Second, Python does not round on its own, so the division above prints 6.666666666666667. Use the round<\/code> function when you want fewer decimals.<\/p>\r\n
Floor Division and Modulus With Negative Numbers<\/h3>\r\n
Floor division rounds down toward minus infinity, not toward zero. That surprises people when a number is negative.<\/p>\r\n
\r\n
python<\/div>\r\n
print(-20 \/\/ 3, -20 % 3)<\/pre>\r\n
output<\/div>\r\n
-7 1<\/pre>\r\n<\/div>\r\n
The result of minus 20 floor divided by 3 is minus 7, not minus 6, and the remainder is 1. Python keeps the rule that (a \/\/ b) * b + (a % b)<\/code> always gives back a<\/code>.<\/p>\r\n
Assignment Operators in Python<\/h2>\r\n
The plain equals sign stores a value in a variable. The other assignment operators are shortcuts. They do an operation and store the result back in the same variable, so x += 5<\/code> means the same as x = x + 5<\/code>. In the table, every row starts again with x<\/code> as 20.<\/p>\r\n
\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n
Assignment operators<\/caption>\r\n
Name<\/th>\r\nSymbol<\/th>\r\nExample<\/th>\r\nSame as<\/th>\r\nResult<\/th>\r\n<\/tr>\r\n<\/thead>\r\n
Assign<\/th>\r\n=<\/td>\r\nx = 20<\/td>\r\nx = 20<\/td>\r\n20<\/td>\r\n<\/tr>\r\n
Add and assign<\/th>\r\n+=<\/td>\r\nx += 5<\/td>\r\nx = x + 5<\/td>\r\n25<\/td>\r\n<\/tr>\r\n
Subtract and assign<\/th>\r\n-=<\/td>\r\nx -= 5<\/td>\r\nx = x – 5<\/td>\r\n15<\/td>\r\n<\/tr>\r\n
Multiply and assign<\/th>\r\n*=<\/td>\r\nx *= 2<\/td>\r\nx = x * 2<\/td>\r\n40<\/td>\r\n<\/tr>\r\n
Divide and assign<\/th>\r\n\/=<\/td>\r\nx \/= 2<\/td>\r\nx = x \/ 2<\/td>\r\n10.0<\/td>\r\n<\/tr>\r\n
Modulus and assign<\/th>\r\n%=<\/td>\r\nx %= 3<\/td>\r\nx = x % 3<\/td>\r\n2<\/td>\r\n<\/tr>\r\n
Floor divide and assign<\/th>\r\n\/\/=<\/td>\r\nx \/\/= 3<\/td>\r\nx = x \/\/ 3<\/td>\r\n6<\/td>\r\n<\/tr>\r\n
Exponent and assign<\/th>\r\n**=<\/td>\r\nx **= 2<\/td>\r\nx = x ** 2<\/td>\r\n400<\/td>\r\n<\/tr>\r\n
Bitwise AND and assign<\/th>\r\n&=<\/td>\r\nx &= 3<\/td>\r\nx = x & 3<\/td>\r\n0<\/td>\r\n<\/tr>\r\n
Bitwise OR and assign<\/th>\r\n|=<\/td>\r\nx |= 3<\/td>\r\nx = x | 3<\/td>\r\n23<\/td>\r\n<\/tr>\r\n
Bitwise XOR and assign<\/th>\r\n^=<\/td>\r\nx ^= 3<\/td>\r\nx = x ^ 3<\/td>\r\n23<\/td>\r\n<\/tr>\r\n
Right shift and assign<\/th>\r\n>>=<\/td>\r\nx >>= 2<\/td>\r\nx = x >> 2<\/td>\r\n5<\/td>\r\n<\/tr>\r\n
Left shift and assign<\/th>\r\n<<=<\/td>\r\nx <<= 3<\/td>\r\nx = x << 3<\/td>\r\n160<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/div>\r\n
\r\n
python<\/div>\r\n
x = 20\r\nx += 5\r\nprint(x)\r\nx \/= 5\r\nprint(x)<\/pre>\r\n
output<\/div>\r\n
25\r\n5.0<\/pre>\r\n<\/div>\r\n
The bitwise rows give whole numbers, because those operators work on integers. The last six rows make sense after you read the bitwise section further down.<\/p>\r\n
Comparison Operators in Python<\/h2>\r\n
Comparison operators compare two values and return True or False. You will use them in every if<\/code> statement and every loop condition.<\/p>\r\n
\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n
Comparison operators with x as 20 and y as 3<\/caption>\r\n
Name<\/th>\r\nSymbol<\/th>\r\nExample<\/th>\r\nResult<\/th>\r\n<\/tr>\r\n<\/thead>\r\n
Equal to<\/th>\r\n==<\/td>\r\nx == y<\/td>\r\nFalse<\/td>\r\n<\/tr>\r\n
Not equal to<\/th>\r\n!=<\/td>\r\nx != y<\/td>\r\nTrue<\/td>\r\n<\/tr>\r\n
Greater than<\/th>\r\n><\/td>\r\nx > y<\/td>\r\nTrue<\/td>\r\n<\/tr>\r\n
Less than<\/th>\r\n<<\/td>\r\nx < y<\/td>\r\nFalse<\/td>\r\n<\/tr>\r\n
Greater than or equal to<\/th>\r\n>=<\/td>\r\nx >= y<\/td>\r\nTrue<\/td>\r\n<\/tr>\r\n
Less than or equal to<\/th>\r\n<=<\/td>\r\nx <= y<\/td>\r\nFalse<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/div>\r\n
\r\n
python<\/div>\r\n
x = 20\r\ny = 3\r\nprint(x == y, x != y, x > y, x < y, x >= y, x <= y)<\/pre>\r\n
output<\/div>\r\n
False True True False True False<\/pre>\r\n<\/div>\r\n
One equals sign stores a value, and two equals signs compare. Mixing them up is a very common first error.<\/p>\r\n
Logical Operators in Python<\/h2>\r\n
Logical operators combine conditions. The word and<\/code> gives True only when both sides are true. The word or<\/code> gives True when at least one side is true. The word not<\/code> flips the answer.<\/p>\r\n
\r\n\r\n\r\n\r\n\r\n\r\n\r\n
Logical operators<\/caption>\r\n
Operator<\/th>\r\nMeaning<\/th>\r\nExample<\/th>\r\n<\/tr>\r\n<\/thead>\r\n
and<\/th>\r\nTrue if both conditions are true<\/td>\r\nx > 10 and y < 5<\/td>\r\n<\/tr>\r\n
or<\/th>\r\nTrue if at least one condition is true<\/td>\r\nx > 10 or y > 5<\/td>\r\n<\/tr>\r\n
not<\/th>\r\nReverses the result<\/td>\r\nnot x > 10<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/div>\r\n
\r\n
python<\/div>\r\n
x = 20\r\ny = 3\r\nprint(x > 10 and y < 5, x > 10 or y > 5, not x > 10)<\/pre>\r\n
output<\/div>\r\n
True True False<\/pre>\r\n<\/div>\r\n
and and or Return an Operand, Not Just True or False<\/h3>\r\n
With conditions, and<\/code> and or<\/code> give True or False. With plain values, they return one of the two values themselves. Python treats 0, empty text, an empty list and None as false, and everything else as true.<\/p>\r\n
\r\n
python<\/div>\r\n
x = 20\r\nprint(x and 0, x or 0, 0 or \"default\", 0 and 5)<\/pre>\r\n
output<\/div>\r\n
0 20 default 0<\/pre>\r\n<\/div>\r\n
Here, x and 0<\/code> gives 0 because x<\/code> is true, so Python moves to the second value and returns it. And x or 0<\/code> gives 20, because x<\/code> is already true and Python stops there. Python also stops early when the answer is known. That is called short circuit evaluation, and it lets you write safe checks such as len(items) > 0 and items[0] == 5<\/code>, where the second part never runs if the list is empty.<\/p>\r\n
Identity Operators in Python<\/h2>\r\n
\"operator<\/p>\r\n
Identity operators check whether two names point to the same object in memory. That is different from asking whether two values look equal.<\/p>\r\n
\r\n\r\n\r\n\r\n\r\n\r\n
Identity operators<\/caption>\r\n
Operator<\/th>\r\nMeaning<\/th>\r\nExample<\/th>\r\n<\/tr>\r\n<\/thead>\r\n
is<\/th>\r\nTrue if both names point to the same object<\/td>\r\np is q<\/td>\r\n<\/tr>\r\n
is not<\/th>\r\nTrue if they point to different objects<\/td>\r\np is not r<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/div>\r\n
\r\n
python<\/div>\r\n
p = [1, 2, 3]\r\nq = p\r\nr = [1, 2, 3]\r\nprint(p is q, p is r, p == r, p is not r)<\/pre>\r\n
output<\/div>\r\n
True False True True<\/pre>\r\n<\/div>\r\n
The names p<\/code> and q<\/code> point to the same list, so p is q<\/code> is True. The name r<\/code> is a separate list that holds the same values, so p == r<\/code> is True, but p is r<\/code> is False. In short, ==<\/code> asks whether the values are equal, and is<\/code> asks whether it is the very same object.<\/p>\r\n
The most useful everyday use of is<\/code> is the check against None:<\/p>\r\n
\r\n
python<\/div>\r\n
v = None\r\nprint(v is None)<\/pre>\r\n
output<\/div>\r\n
True<\/pre>\r\n<\/div>\r\n
Avoid using is<\/code> to compare numbers or text. Python sometimes reuses small objects, so the answer can change from one case to another. Use ==<\/code> for values.<\/p>\r\n
Membership Operators in Python<\/h2>\r\n
Membership operators check whether a value is present inside a collection such as a string, list, tuple, set or dictionary.<\/p>\r\n
\r\n\r\n\r\n\r\n\r\n\r\n
Membership operators<\/caption>\r\n
Operator<\/th>\r\nMeaning<\/th>\r\nExample<\/th>\r\n<\/tr>\r\n<\/thead>\r\n
in<\/th>\r\nTrue if the value is found in the collection<\/td>\r\n3 in [1, 2, 3]<\/td>\r\n<\/tr>\r\n
not in<\/th>\r\nTrue if the value is not found<\/td>\r\n“z” not in “apple”<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/div>\r\n
\r\n
python<\/div>\r\n
print(\"a\" in \"apple\", \"z\" not in \"apple\")\r\nprint(3 in [1, 2, 3], 5 in (1, 2), \"k\" in {\"k\": 1}, 1 in {\"k\": 1})<\/pre>\r\n
output<\/div>\r\n
True True\r\nTrue False True False<\/pre>\r\n<\/div>\r\n
For a dictionary, in<\/code> checks the keys and not the values, which is why 1 in the dictionary gives False. Using in<\/code> with a plain number on the right raises an error, because a number is not a collection:<\/p>\r\n
\r\n
python<\/div>\r\n
try:\r\n    print(3 in 20)\r\nexcept TypeError as error:\r\n    print(\"TypeError:\", error)<\/pre>\r\n
output<\/div>\r\n
TypeError: argument of type 'int' is not iterable<\/pre>\r\n<\/div>\r\n
Bitwise Operators in Python<\/h2>\r\n
Bitwise operators work on the individual bits, the ones and zeros, of whole numbers. You will not need them every day, but they appear in permissions, flags, networking, hardware code and interview questions. Here is a worked example using 12 and 10.<\/p>\r\n
\r\n
python<\/div>\r\n
a = 12\r\nb = 10\r\nprint(format(a, \"04b\"), format(b, \"04b\"))<\/pre>\r\n
output<\/div>\r\n
1100 1010<\/pre>\r\n<\/div>\r\n
\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n
Bitwise operators with a as 12 and b as 10<\/caption>\r\n
Name<\/th>\r\nSymbol<\/th>\r\nWhat it does<\/th>\r\nExample and result<\/th>\r\n<\/tr>\r\n<\/thead>\r\n
Bitwise AND<\/th>\r\n&<\/td>\r\n1 only where both bits are 1<\/td>\r\n12 & 10 gives 8 (1000)<\/td>\r\n<\/tr>\r\n
Bitwise OR<\/th>\r\n|<\/td>\r\n1 where at least one bit is 1<\/td>\r\n12 | 10 gives 14 (1110)<\/td>\r\n<\/tr>\r\n
Bitwise XOR<\/th>\r\n^<\/td>\r\n1 where the bits differ<\/td>\r\n12 ^ 10 gives 6 (0110)<\/td>\r\n<\/tr>\r\n
Bitwise NOT<\/th>\r\n~<\/td>\r\nFlips every bit<\/td>\r\n~12 gives minus 13<\/td>\r\n<\/tr>\r\n
Left shift<\/th>\r\n<<<\/td>\r\nMoves bits left, fills with zeros<\/td>\r\n12 << 2 gives 48<\/td>\r\n<\/tr>\r\n
Right shift<\/th>\r\n>><\/td>\r\nMoves bits right<\/td>\r\n12 >> 2 gives 3<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/div>\r\n
\r\n
python<\/div>\r\n
a = 12\r\nb = 10\r\nprint(a & b, a | b, a ^ b)\r\nprint(~a)\r\nprint(a << 2, a >> 2)<\/pre>\r\n
output<\/div>\r\n
8 14 6\r\n-13\r\n48 3<\/pre>\r\n<\/div>\r\n
The tilde operator is bitwise NOT, not NOR. For whole numbers, ~a<\/code> equals minus a<\/code> minus 1, which is why ~12<\/code> gives minus 13. A left shift by 2 multiplies by 4, and a right shift by 2 divides by 4 and drops the remainder.<\/p>\r\n