Python Operators — Complete Guide with Precedence

The Story That Explains Operators 🍳Operators समझाने वाली कहानी 🍳一个解释运算符的故事 🍳

An operator is a symbol or keyword that does something with one or more values, called operands. In 5 + 3, the + is the operator and 5 and 3 are the operands. An operator with one operand (like -x or not x) is called unary; one with two operands is binary.

Operator एक symbol या keyword है जो एक या ज़्यादा मानों पर कुछ करता है, जिन्हें operands कहते हैं। 5 + 3 में + operator है और 5 और 3 operands हैं। एक operand वाला operator (जैसे -x या not x) unary कहलाता है; दो operands वाला binary।

运算符是对一个或多个值（称为操作数）进行操作的符号或关键字。在 5 + 3 中，+ 是运算符，5 和 3 是操作数。只有一个操作数的运算符（如 -x 或 not x）叫一元运算符；有两个操作数的叫二元运算符。

The Seven Families of Operators 🗂️Operators के सात परिवार 🗂️运算符的七个家族 🗂️

Arithmetic Operators — The Maths Toolkit ➕Arithmetic Operators — गणित के औज़ार ➕算术运算符 —— 数学工具箱 ➕

a, b = 17, 5
print(f"a + b  = {a + b}")
print(f"a - b  = {a - b}")
print(f"a * b  = {a * b}")
print(f"a / b  = {a / b}")       # true division: always a float
print(f"a // b = {a // b}")      # floor division
print(f"a % b  = {a % b}")       # remainder
print(f"a ** b = {a ** b}")      # power: 17 to the 5th

print("Ha" * 3)
print("Hello, " + "World!")
print([1, 2] + [3, 4])
print([0] * 5)

print(14 % 2 == 0, 15 % 2 == 0)  # even? odd?
total_min = 150
print(f"{total_min // 60}h {total_min % 60}min")
print((23 + 3) % 24)             # 23:00 + 3 hours on a 24-hour clock
print(divmod(150, 60))           # quotient and remainder together

// and % always fit together: a == (a // b) * b + a % b. divmod(a, b) gives both at once. With negative numbers, Python rounds down, not toward zero — so the results differ from C and Java:

// और % हमेशा साथ बैठते हैं: a == (a // b) * b + a % b। divmod(a, b) दोनों एक साथ देता है। Negative संख्याओं में Python शून्य की ओर नहीं, नीचे round करता है — इसलिए नतीजे C और Java से अलग आते हैं:

// 和 % 总是配套的：a == (a // b) * b + a % b。divmod(a, b) 一次返回两者。遇到负数时，Python 向下取整而不是向零取整 —— 所以结果与 C 和 Java 不同：

# floor division and modulo with negative numbers
print(7 // 2, -7 // 2)        # rounds DOWN, toward minus infinity
print(7 % 3, -7 % 3, 7 % -3)  # result takes the sign of the divisor
print(7.5 // 2, 7.5 % 2)      # works on floats too, result is a float
print(int(-7 / 2))            # int() cuts toward zero instead
print(2 ** -1, 4 ** 0.5)      # negative and fractional powers give floats
print(pow(2, 10, 1000))       # 2**10 % 1000, computed efficiently

Comparison Operators — Asking Questions ⚖️Comparison Operators — सवाल पूछना ⚖️比较运算符 —— 提出问题 ⚖️

Comparison operators compare two values and always give a boolean: True or False.

Comparison operators दो मानों की तुलना करते हैं और हमेशा boolean देते हैं: True या False।

比较运算符比较两个值，结果总是布尔值：True 或 False。

print(10 == 10)
print(10 == "10")             # int vs str: never equal
print(10 == 10.0)             # int vs float: compared by value
print(10 != 7)
print("apple" < "banana")     # strings compare letter by letter
print("Apple" < "apple")      # 'A' (65) comes before 'a' (97)
print("10" < "9")             # text comparison, not numeric!
print([1, 2, 3] < [1, 3])     # lists compare item by item

age = 25
print(age >= 18 and age < 65)
print(18 <= age < 65)         # chained: same meaning, easier to read
x = 50
print(0 < x < 100 < 1000)

score = 85
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"
print(f"Score {score} → Grade {grade}")

try:
    print(5 < "6")
except TypeError as err:
    print("TypeError:", err)

Three things to notice. Strings compare character by character using Unicode code points, so "10" < "9" is True — convert text to numbers before comparing. Comparisons can be chained: 18 <= age < 65 means 18 <= age and age < 65. And ordering values of unrelated types, such as 5 < "6", raises a TypeError.

तीन बातें ध्यान दें। Strings की तुलना Unicode code points से अक्षर-दर-अक्षर होती है, इसलिए "10" < "9" True है — तुलना से पहले text को संख्या में बदलें। Comparisons chain हो सकते हैं: 18 <= age < 65 का मतलब 18 <= age and age < 65। और असंबंधित types को क्रम में रखना, जैसे 5 < "6", TypeError देता है।

注意三点。字符串按 Unicode 码点逐字符比较，所以 "10" < "9" 为 True —— 比较前先把文本转成数字。比较可以链式书写：18 <= age < 65 等价于 18 <= age and age < 65。对无关类型排序（如 5 < "6"）会引发 TypeError。

x = 5
if x = 5:
    print("five")

Logical Operators — Combining Conditions 🧠Logical Operators — शर्तें जोड़ना 🧠逻辑运算符 —— 组合条件 🧠

Truth TablesTruth Tables真值表

age = 25
has_license = True
has_car = False

can_drive = age >= 18 and has_license
print(f"Can drive: {can_drive}")
needs_transport = not has_car or age < 16
print(f"Needs transport: {needs_transport}")
is_minor = not (age >= 18)
print(f"Is minor: {is_minor}")

username, password, is_locked = "asha", "secret123", False
can_login = (username == "asha" and
             password == "secret123" and
             not is_locked)
print(f"Can login: {can_login}")

# short-circuit: the right side is skipped when the left side decides
x = 0
if x == 0 or (10 / x) > 1:
    print("Safe — 10 / x never ran")


def check(name, value):
    print(f"  checking {name}")
    return value


print(check("A", False) and check("B", True))
print(check("A", True) or check("B", False))

The last two lines prove short-circuiting: only "checking A" is printed, because A alone decides the answer. This is why x == 0 or 10 / x > 1 never divides by zero.

आख़िरी दो lines short-circuiting साबित करती हैं: सिर्फ़ "checking A" छपता है, क्योंकि अकेले A से जवाब तय हो जाता है। इसीलिए x == 0 or 10 / x > 1 कभी शून्य से भाग नहीं करता।

最后两行证明了短路：只打印了 "checking A"，因为仅凭 A 就能决定结果。这就是 x == 0 or 10 / x > 1 永远不会除以零的原因。

So and and or return one of the original values, not always True/False. This gives a handy default-value pattern — with one trap:

तो and और or मूल मानों में से एक लौटाते हैं, हमेशा True/False नहीं। इससे default-value का एक काम का तरीक़ा मिलता है — एक जाल के साथ:

所以 and 和 or 返回的是原来的某个值，而不一定是 True/False。这带来一个方便的默认值写法 —— 但有一个陷阱：

print(5 and 10)          # both truthy → the last value
print(0 and 10)          # stops at the first falsy value
print(5 or 10)           # stops at the first truthy value
print(0 or 10)
print("" or "default")
print(None or [] or 0)   # all falsy → the last value
print(not "hello", not "")

name = ""
display = name or "Anonymous"
print(display)
count = 0
print(count or 10)       # careful: 0 is a real value but counts as falsy!
print(10 if count is None else count)

Assignment Operators — Store and Update 📝Assignment Operators — रखना और बदलना 📝赋值运算符 —— 存储与更新 📝

score = 0
score += 10        # score = score + 10
score += 25
score -= 5
score *= 2
score //= 3
print(f"Final score: {score}")

message = "Hello"
message += ", "
message += "World!"
print(message)

tasks = ["wake up"]
tasks += ["eat", "code"]
tasks *= 2
print(tasks)

# a += b on a list changes the SAME list; a = a + b builds a new one
a = [1]
alias = a
a += [2]
print(alias)
a = a + [3]
print(alias, a)

numbers = [3, 7, 15, 22, 31]
if (n := len(numbers)) > 3:          # walrus: assign inside an expression (3.8+)
    print(f"List has {n} items")

One subtle point, shown by alias: for a list, a += [2] changes the list in place, so every name for that list sees the change. a = a + [3] builds a new list and only moves a. For numbers and strings there is no difference, because they cannot be changed in place. Also, Python has no ++ or --:

एक बारीक बात, जो alias दिखाता है: list के लिए a += [2] list को अपनी जगह बदलता है, इसलिए उस list के हर नाम को बदलाव दिखता है। a = a + [3] एक नई list बनाता है और सिर्फ़ a को उस पर ले जाता है। Numbers और strings में कोई अंतर नहीं, क्योंकि वे अपनी जगह नहीं बदलते। साथ ही, Python में ++ या -- नहीं है:

alias 揭示了一个细节：对列表来说，a += [2] 是原地修改，所以指向该列表的所有名字都能看到变化；a = a + [3] 则创建一个新列表，只移动 a。对数字和字符串没有区别，因为它们不能原地修改。另外，Python 没有 ++ 或 --：

x = 5
x++

Bitwise Operators — Working with Binary 🔢Bitwise Operators — Binary के साथ काम 🔢位运算符 —— 操作二进制 🔢

Every integer is stored as bits (0s and 1s). Bitwise operators work on those bits directly. You will not need them every day, but they matter for permissions, network masks, file formats and hardware.

हर integer bits (0 और 1) के रूप में store होता है। Bitwise operators सीधे उन bits पर काम करते हैं। रोज़ इनकी ज़रूरत नहीं पड़ेगी, पर permissions, network masks, file formats और hardware में ये मायने रखते हैं।

每个整数都以二进制位（0 和 1）存储。位运算符直接操作这些位。日常编程不常用，但在权限、网络掩码、文件格式和硬件编程中很重要。

a, b = 12, 10
print(f"{a:04b} & {b:04b} = {a & b:04b} = {a & b}")
print(f"{a:04b} | {b:04b} = {a | b:04b} = {a | b}")
print(f"{a:04b} ^ {b:04b} = {a ^ b:04b} = {a ^ b}")
print(f"~{a} = {~a}  (always -x - 1)")
print(5 << 1, 5 << 3, 40 >> 2, 41 >> 2)   # shifts multiply / floor-divide by powers of 2
print(bin(12), bin(10), bin(12 & 10))

# real use: Unix file permissions (rwx bits)
mode = 0o754
for who, shift in [("owner", 6), ("group", 3), ("others", 0)]:
    bits = (mode >> shift) & 0b111
    print(f"{who:<6} {bits:03b} ", "r" if bits & 4 else "-", "w" if bits & 2 else "-", "x" if bits & 1 else "-", sep="")

Membership Operators — Is It Inside? 🔍Membership Operators — क्या अंदर है? 🔍成员运算符 —— 在不在里面？🔍

in and not in check whether a value is inside a collection. They work on strings (substring search), lists, tuples, sets, ranges and dictionaries.

in और not in जाँचते हैं कि मान किसी collection के अंदर है या नहीं। ये strings (substring खोज), lists, tuples, sets, ranges और dictionaries पर काम करते हैं।

in 和 not in 检查某个值是否在集合中。它们适用于字符串（子串查找）、列表、元组、集合、range 和字典。

fruits = ["apple", "banana", "cherry"]
print("apple" in fruits, "mango" in fruits, "mango" not in fruits)

sentence = "Python is awesome"
print("Python" in sentence, "python" in sentence, "awe" in sentence)

user = {"name": "Asha", "age": 30, "role": "admin"}
print("name" in user)             # dictionaries check KEYS
print("Asha" in user)
print("Asha" in user.values())

print(3 in range(0, 10, 3), 4 in range(0, 10, 3))

valid_roles = {"admin", "editor", "viewer"}   # a set: very fast lookups
current_role = input("Enter your role: ")
if current_role in valid_roles:
    print(f"Access granted as {current_role}")
else:
    print("Invalid role")

Identity Operators — Same Object or Just Equal? 🪪Identity Operators — वही Object या सिर्फ़ बराबर? 🪪身份运算符 —— 同一对象还是仅仅相等？🪪

== asks "do these have the same value?". is asks "are these the very same object?". Two lists can hold equal values and still be two separate objects.

== पूछता है "क्या इनका मान एक है?"। is पूछता है "क्या ये बिल्कुल वही object हैं?"। दो lists में बराबर मान होकर भी वे दो अलग objects हो सकती हैं।

== 问的是“它们的值相同吗？”。is 问的是“它们是同一个对象吗？”。两个列表可以值相等，却仍是两个不同的对象。

a = [1, 2, 3]
b = [1, 2, 3]        # equal values, but a different list
c = a                # a second name for the same list
print(a == b, a is b, a is c)
print(id(a) == id(c), id(a) == id(b))

value = None
if value is None:    # the right way to test for None
    print("No value provided")

b.append(4)          # changes only b
c.append(99)         # changes a too — they are the same object
print(a, b)

Comparing a number with is is a bug that Python now warns about at compile time. It even happened to print True here, because the compiler reused one 1000 object inside this file — the lab below shows the same code giving False in the REPL:

किसी संख्या की is से तुलना एक bug है जिस पर Python अब compile के समय चेतावनी देता है। यहाँ यह संयोग से True छाप गया, क्योंकि compiler ने इस file में 1000 का एक ही object दोबारा इस्तेमाल किया — नीचे का lab वही code REPL में False देते हुए दिखाता है:

用 is 比较数字是个 bug，Python 现在会在编译时发出警告。这里它碰巧打印了 True，因为编译器在这个文件中复用了同一个 1000 对象 —— 下面的实验显示同样的代码在 REPL 中得到 False：

x = 1000
print(x is 1000)

Operator Precedence — Who Goes First? 🪜Operator Precedence — पहले कौन? 🪜运算符优先级 —— 谁先算？🪜

One fine point: ** beats a minus on its left (-2 ** 2 is −4) but not a minus on its right (2 ** -1 is 0.5). Run them all:

एक बारीक बात: ** अपने बाएँ के minus से आगे है (-2 ** 2 = −4), पर दाएँ के minus से नहीं (2 ** -1 = 0.5)। सब चलाकर देखें:

一个细节：** 比其左边的负号优先（-2 ** 2 为 −4），但不比其右边的负号优先（2 ** -1 为 0.5）。全部运行看看：

print(2 + 3 * 4)                # * before +
print((2 + 3) * 4)              # brackets first
print(2 ** 3 ** 2)              # ** groups right to left: 2 ** 9
print((2 ** 3) ** 2)
print(-2 ** 2)                  # means -(2 ** 2)
print((-2) ** 2)
print(2 ** -1)                  # but a minus on the RIGHT of ** binds first
x = 10
print(x > 5 and x < 20 or x == 100)
print(10 + 20 + 30 / 3)         # / first: 10 + 20 + 10.0
print((10 + 20 + 30) / 3)
print(not 1 == 2)               # == first, then not
print(1 + 2 == 3 and 2 * 2 == 4)
print(6 & 3 == 2)               # & binds tighter than == here: (6 & 3) == 2 (C does the opposite)

Common Operator Traps 🪤Operators के आम जाल 🪤常见运算符陷阱 🪤

import math
print(0.1 + 0.2 == 0.3)
print(math.isclose(0.1 + 0.2, 0.3))
print(abs((0.1 + 0.2) - 0.3) < 1e-9)
print(10 / 2, 10 // 2)
print(True + True, True == 1)          # bool is a kind of int

Complete Practice Program — Operators Sandbox 🧪पूरा अभ्यास Program — Operators Sandbox 🧪完整练习程序 —— 运算符沙盒 🧪

This script uses every operator family in one small order system. Type it out, run it, then change the price, quantity or permissions and predict the new output first.

यह script एक छोटे order system में हर operator परिवार इस्तेमाल करती है। इसे टाइप करें, चलाएँ, फिर price, quantity या permissions बदलें और पहले नया output अंदाज़ा लगाएँ।

这个脚本在一个小型订单系统中用到了所有运算符家族。把它敲一遍并运行，然后修改价格、数量或权限，先预测新的输出。

# operators_sandbox.py — every operator family in one script


def main():
    # arithmetic
    price = 999.00
    quantity = 3
    gst_rate = 0.18
    subtotal = price * quantity
    gst = subtotal * gst_rate
    total = subtotal + gst
    print("=== ORDER SUMMARY ===")
    print(f"Subtotal: ₹{subtotal:,.2f}")
    print(f"GST 18%:  ₹{gst:,.2f}")
    print(f"Total:    ₹{total:,.2f}")

    # assignment (compound)
    balance = 5000.00
    balance -= total
    balance += 500.00                     # refund
    print(f"Balance:  ₹{balance:,.2f}")

    # comparison + logical
    is_member = True
    discount = (quantity >= 3 or is_member) and balance > 0 and not total > 10_000
    print(f"Discount: {discount}")

    # membership
    payment_methods = {"card", "upi", "cash"}
    chosen = "upi"
    print(f"Paying via: {chosen}" if chosen in payment_methods else "Unsupported method")

    # identity
    error = None
    if error is None:
        print("Order processed successfully")

    # precedence
    print(f"Precedence: {2 + 3 * 4}, {(2 + 3) * 4}, {2 ** 3 ** 2}")

    # bitwise flags
    READ, WRITE, EXECUTE = 0b100, 0b010, 0b001
    permissions = READ | WRITE
    print(f"Permissions: {permissions:03b}")
    print(f"Can read?    {bool(permissions & READ)}")
    print(f"Can write?   {bool(permissions & WRITE)}")
    print(f"Can execute? {bool(permissions & EXECUTE)}")


if __name__ == "__main__":
    main()

Exercises — Test Your Understanding 🎯अभ्यास — अपनी समझ जाँचें 🎯练习 —— 检验你的理解 🎯

Predict each answer on paper first, then run the code. Every answer below was produced by Python.

पहले हर जवाब काग़ज़ पर अंदाज़ा लगाएँ, फिर code चलाएँ। नीचे का हर जवाब Python से बना है।

先在纸上预测每个答案，再运行代码。下面的每个答案都由 Python 计算得出。

n = int(input("Enter a number: "))
if n % 2 == 0:
    print(f"{n} is even")
else:
    print(f"{n} is odd")

if n % 15 == 0:                 # divisible by 3 AND 5 → check this first
    print(f"{n} is divisible by both 3 and 5")
elif n % 3 == 0:
    print(f"{n} is divisible by 3")
elif n % 5 == 0:
    print(f"{n} is divisible by 5")

a = float(input("First number:  "))
op = input("Operator (+ - * / // % **): ")
b = float(input("Second number: "))

valid_ops = {"+", "-", "*", "/", "//", "%", "**"}
if op not in valid_ops:
    print("Invalid operator!")
elif op in {"/", "//", "%"} and b == 0:
    print("Cannot divide by zero!")
else:
    if op == "+":
        result = a + b
    elif op == "-":
        result = a - b
    elif op == "*":
        result = a * b
    elif op == "/":
        result = a / b
    elif op == "//":
        result = a // b
    elif op == "%":
        result = a % b
    else:
        result = a ** b
    print(f"{a} {op} {b} = {result}")

def is_strong(password):
    return (len(password) >= 8 and
            any(c.isdigit() for c in password) and
            any(c.isupper() for c in password) and
            any(c.islower() for c in password))


for pw in ["hello", "hello123", "Hello123", "HELLO123"]:
    print(f"{pw:<9} → {'strong' if is_strong(pw) else 'weak'}")

for year in [2000, 2020, 2024, 2025, 2100]:
    is_leap = (year % 4 == 0 and year % 100 != 0) or year % 400 == 0
    print(year, "leap" if is_leap else "not leap")

Golden Rules 🏆सुनहरे नियम 🏆黄金法则 🏆