Vivasoft-logo

Operators āĻ•āĻŋ?

āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ Programming Language āĻāϰ āĻŽāϤ⧋āχ āĻĒāĻžāχāĻĨāύ āĻ Operators āĻšāĻšā§āϛ⧇ āĻ•āϤāϗ⧁āϞ⧋ symbol,  āϝāĻž āϏāĻžāϧāĻžāϰāĻŖāϤ āĻāĻ•āϟāĻŋ action āĻŦāĻž process āϕ⧇ represents āĻ•āϰ⧇ āĨ¤
āϏāĻšāϜ āĻ­āĻžāĻŦ⧇ āϝāĻĻāĻŋ āĻŦāϞāĻž āĻšāϝāĻŧ āϤāĻž āĻšāĻšā§āϛ⧇ Python Interpreter āϕ⧇ āĻ•āĻŋāϛ⧁ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ mathematical, logical āĻāĻŦāĻ‚ relational āϏāĻš āφāϰ⧋ āĻ­āĻŋāĻ¨ā§āύ āϧāϰāϪ⧇āϰ operation āĻ•āϰāĻžāϰ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž āĻĒāĻžāĻ āĻžā§Ÿ āĻāĻŦāĻ‚ āύāĻŋāĻ°ā§āĻĻ⧇āĻļāύāĻž āĻ…āύ⧁āϝāĻžā§Ÿā§€ Python Interpreter āϏ⧇āχ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻ•āĻžāĻœā§‡āϰ āĻĢāϞāĻžāĻĢāϞ āĻĒā§āϰāĻĻāĻ°ā§āĻļāύ āĻ•āϰ⧇āĨ¤
 
>āĻāχāĻŦāĻžāϰ āύāĻŋāĻšā§‡āϰ āωāĻĻāĻžāĻšāϰāĻŖ āϟāĻŋ āĻāĻ•āϟ⧁ āĻ–ā§‡ā§ŸāĻžāϞ āĻ•āϰāĻŦā§‹
 
 
 
first_number = 10
second_number = 15
result = first_number + second_number
print(result) # Output 25
 

***āĻŦā§āϝāĻžāĻ–ā§āϝāĻž:***

āωāĻĒāϰ⧇āϰ āϕ⧋āĻĄāϟ⧁āϕ⧁ āϰāĻžāύ āĻ•āϰāϞ⧇ āĻĻ⧇āĻ–āϤ⧇ āĻĒāĻžāϰāĻŦā§‹ āϝ⧇ āφāĻŽāĻžāĻĻ⧇āϰ āφāωāϟāĻĒ⧁āϟ āĻšāĻŋāϏ⧇āĻŦ⧇ 25 āĻĒāĻžāĻŦā§‹āĨ¤ āĻāχāĻ–āĻžāύ⧇ āφāĻŽāϰāĻž āĻĒā§āϰāĻĨāĻŽā§‡ first_number āĻāĻŦāĻ‚ second_number āĻĻ⧁āχāϟāĻž variable āύāĻŋā§Ÿā§‡āĻ›āĻŋ āĻāĻŦāĻ‚ variable  āĻĻ⧁āχāϟāĻŋāϤ⧇ āĻĻ⧁āχāϟāĻž āĻ­ā§āϝāĻžāϞ⧁ āϝāĻĨāĻžāĻ•ā§āϰāĻŽā§‡ 10 āĻāĻŦāĻ‚ 15 assign āĻ•āϰ⧇āĻ›āĻŋāĨ¤ āĻāϏāĻžāχāύ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āφāĻŽāϰāĻž “=” sign āĻŦā§āϝāĻžāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĻ›āĻŋāĨ¤ āĻāχ “=” sign āĻšāĻšā§āϛ⧇ āĻāĻ•āϧāϰāϪ⧇āϰ Operator (Assignment )āĨ¤ āφāĻŦāĻžāϰ ā§Š āύāĻžāĻŽā§āĻŦāĻžāϰ āϞāĻžāχāύ āĻ first_number āĻāĻŦāĻ‚ second_number āĻāϰ āĻ­ā§āϝāĻžāϞ⧁ āĻĻ⧁āϟāĻŋ āϕ⧇ āϝ⧋āĻ— āĻ•āϰ⧇ result āĻ­ā§āϝāĻžāϰāĻŋā§Ÿā§‡āĻŦāϞ āĻ āĻāϏāĻžāχāύ āĻ•āϰ⧇āĻ›āĻŋāĨ¤ āϝ⧋āĻ— āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āφāĻŽāϰāĻž “+” (plus ) Sign āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĻ›āĻŋ, āĻāχāĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ + āĻšāĻšā§āϛ⧇ āĻāĻ•āϧāϰāϪ⧇āϰ Arithmetic Operator āĨ¤ āĻĒāĻžāχāĻĨāύ⧇ āĻ­āĻŋāĻ¨ā§āύ āϧāϰāϪ⧇āϰ Operator āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšā§Ÿ āϝāĻž āφāĻŽāϰāĻž āĻĒā§āϰāĻ¤ā§āϝ⧇āĻ•āϟāĻŋāχ āĻĒāĻ°ā§āϝāĻžā§ŸāĻ•ā§āϰāĻŽā§‡ āĻĻ⧇āĻ–āĻŦā§‹āĨ¤
 
***āύ⧋āϟ:***
Operator āĻāϰ āĻĻ⧁āχ āĻĒāĻžāĻļ⧇ āϝ⧇āχ āϏāĻŦ variable āĻ…āĻĨāĻŦāĻž value āĻĨāĻžāϕ⧇, Programming Language āĻāϰ āĻĒāϰāĻŋāĻ­āĻžāώāĻžā§Ÿ āĻāϕ⧇ Operand āĻŦāϞ⧇ āĨ¤
āωāĻĒāϰ⧇āϰ āωāĻĻāĻžāĻšāϰāϪ⧇ first_number āĻāĻŦāĻ‚ second_number āĻšāĻšā§āϛ⧇ Operand
 

python āĻ Operator āĻāϰ āĻļā§āϰ⧇āĻŖā§€āĻŦāĻŋāĻ­āĻžāĻ—

***āĻĒāĻžāχāĻĨāύ āĻ…āĻĒāĻžāϰ⧇āϟāϰāĻĻ⧇āϰ āύāĻŋāĻŽā§āύāϞāĻŋāĻ–āĻŋāϤ āĻ—ā§āϰ⧁āĻĒ⧇ āĻŦāĻŋāĻ­āĻ•ā§āϤ āĻ•āϰ⧇:***
1. Arithmetic Operators.
2. Assignment Operators.
3. Comparison Operators.
4. Logical Operators.
5. Membership Operators.
6. Identity Operators.
7. Bitwise Operators.
 
 
 
Arithmetic Operators:
āĻ—āĻžāĻŖāĻŋāϤāĻŋāĻ• āĻ­āĻŋāĻ¨ā§āύ āĻšāĻŋāϏāĻžāĻŦ āύāĻŋāĻ•āĻžāĻļ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āϝ⧇ symbol āĻŦāĻž āϚāĻŋāĻšā§āύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ,āĻĒāĻžāχāĻĨāύ⧇ āĻ āϗ⧁āϞ⧋āϕ⧇ āĻŦāϞāĻž āĻšā§Ÿ Arithmetic Operators āĨ¤āĻāĻ–āĻžāύ⧇ āĻāĻ•āϟāĻž āĻŦāĻŋāώ⧟ āϜāĻžāύāĻž āĻĻāϰāĻ•āĻžāϰ āϝ⧇ ,  āϏāĻŦ programming āĻ˛ā§āϝāĻžāĻ‚āĻ—ā§ā§Ÿā§‡āĻœā§‡ Arithmetic Operators āϗ⧁āϞāĻž āĻĒā§āϰāĻžā§Ÿ āĻāĻ•āχ āϰāĻ•āĻŽ
Arithmetic Operator āϏāĻŽā§‚āĻš āύāĻŋāĻŽā§āύāϰ⧁āĻĒāσ
āĻ…āĻĒāĻžāϰ⧇āϟāϰ
āĻŦā§āϝāĻŦāĻšāĻžāϰ
āωāĻĻāĻžāĻšāϰāĻŖ
āĻŦā§āϝāĻžāĻ–ā§āϝāĻž
+
āĻĻ⧁āχāϟāĻž Operand āĻāϰ Add āĻŦāĻž āϝ⧋āĻ— āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ
print(31+50)
āĻŦāĻžāĻŽ āĻĒāĻžāĻļ⧇āϰ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽ āϟāĻŋ āϕ⧇ āϝāĻĻāĻŋ āϰāĻžāύ āĻ•āϰāĻžāĻšā§Ÿ āϤāĻžāĻšāϞ⧇ ,31 āϕ⧇ 50 āĻāϰ āϏāĻžāĻĨ⧇ āϝ⧋āĻ— āĻ•āϰāϞ⧇ āφāĻŽāϰāĻž āĻĢāϞāĻžāĻĢāϞ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻžāĻŦā§‹ 81
–
āĻĻ⧁āχāϟāĻž Operand āĻāϰ Subtract āĻŦāĻž āĻŦāĻŋā§Ÿā§‹āĻ— āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ
print(50-32)
āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽ āϟāĻŋ āϕ⧇ āϝāĻĻāĻŋ āϰāĻžāύ āĻ•āϰāĻžāĻšā§Ÿ āϤāĻžāĻšāϞ⧇ ,50 āĻĨ⧇āϕ⧇ 32 āĻŦāĻŋā§Ÿā§‹āĻ— āĻ•āϰāϞ⧇ āφāĻŽāϰāĻž āĻĢāϞāĻžāĻĢāϞ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻžāĻŦā§‹ 18
*
āχāϟāĻž Operand āĻāϰ Multiply āĻŦāĻž āϗ⧁āύ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ
print(31*50)
āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽ āϟāĻŋ āϕ⧇ āϝāĻĻāĻŋ āϰāĻžāύ āĻ•āϰāĻžāĻšā§Ÿ āϤāĻžāĻšāϞ⧇ ,31 āϕ⧇ 50 āĻĻā§āĻŦāĻžāϰāĻž āϗ⧁āύ āĻ•āϰāϞ⧇ āφāĻŽāϰāĻž āĻĢāϞāĻžāĻĢāϞ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻžāĻŦā§‹ 1550
/
āĻĻ⧁āχāϟāĻž Operand āĻāϰ Divide āĻŦāĻž āĻ­āĻžāĻ— āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ
print(100/50)
āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽ āϟāĻŋ āϕ⧇ āϝāĻĻāĻŋ āϰāĻžāύ āĻ•āϰāĻžāĻšā§Ÿ āϤāĻžāĻšāϞ⧇ ,100 āϕ⧇ 50 āĻĻā§āĻŦāĻžāϰāĻž āĻ­āĻžāĻ— āĻ•āϰāϞ⧇ āφāĻŽāϰāĻž āĻĢāϞāĻžāĻĢāϞ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻžāĻŦā§‹ 2
%
āĻĻ⧁āχāϟāĻž Operand āĻāϰ Modulus āĻŦāĻž āĻ­āĻžāĻ— āĻ•āϰāĻžāϰ āĻĒāϰ āĻ­āĻžāĻ—āĻļ⧇āώ āĻŦ⧇āϰ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ
print(50%20)
āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽ āϟāĻŋ āϕ⧇ āϝāĻĻāĻŋ āϰāĻžāύ āĻ•āϰāĻžāĻšā§Ÿ āϤāĻžāĻšāϞ⧇ ,50 āϕ⧇ 20 āĻĻā§āĻŦāĻžāϰāĻž āĻ­āĻžāĻ— āĻ•āϰāϞ⧇ āφāĻŽāϰāĻž āĻ­āĻžāĻ—āĻļ⧇āώ āĻĢāϞāĻžāĻĢāϞ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻžāĻŦā§‹ 10
//
āĻĻ⧁āχāϟāĻž Operand āĻāϰ Floor division -āĻ­āĻžāĻ—āĻļ⧇āώ āĻŦāĻžāĻĻ⧇ āĻĒā§‚āĻ°ā§āĻŖ āϏāĻ‚āĻ–ā§āϝāĻžā§Ÿ āĻ­āĻžāĻ—āĻĢāϞ āĻŦ⧇āϰ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ
print(50//20)
āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽ āϟāĻŋ āϕ⧇ āϝāĻĻāĻŋ āϰāĻžāύ āĻ•āϰāĻžāĻšā§Ÿ āϤāĻžāĻšāϞ⧇ ,50 āϕ⧇ 20 āĻĻā§āĻŦāĻžāϰāĻž āĻ­āĻžāĻ— āĻ•āϰāϞ⧇ āφāĻŽāϰāĻž āĻ­āĻžāĻ—āĻĢāϞ āĻĢāϞāĻžāĻĢāϞ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻžāĻŦā§‹ 2
**
āĻĻ⧁āχāϟāĻž Operand āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻĻā§āĻŦāĻŋāĻ¤ā§€ā§Ÿ operand āϟāĻŋ āĻĒā§āϰāĻĨāĻŽ Operand āĻāϰ Power āĻšāĻŋāϏ⧇āĻŦ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ
print(2**3)
āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽ āϟāĻŋ āϕ⧇ āϝāĻĻāĻŋ āϰāĻžāύ āĻ•āϰāĻžāĻšā§Ÿ āϤāĻžāĻšāϞ⧇ , āĻĢāϞāĻžāĻĢāϞ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻžāĻŦā§‹ 8 (2 * 2 * 2)
 
 
 
Assignment Operator
āĻ­ā§āϝāĻžāϰāĻŋā§Ÿā§‡āĻŦāϞ āĻ āϕ⧋āύ⧋ value āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰāϤ⧇ āϝ⧇āχāϏāĻŦ symbol āĻŦāĻž āϚāĻŋāĻšā§āύ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§Ÿ, āĻāϗ⧁āϞ⧋āϕ⧇ āĻŦāϞāĻž āĻšā§Ÿ Assignment Operator
Assignment Operator āϏāĻŽā§‚āĻš āύāĻŋāĻŽā§āύāϰ⧁āĻĒāσ
āĻ…āĻĒāĻžāϰ⧇āϟāϰ
āĻŦā§āϝāĻŦāĻšāĻžāϰ
āωāĻĻāĻžāĻšāϰāĻŖ
āĻŦā§āϝāĻžāĻ–ā§āϝāĻž
=
āĻĄāĻžāύ āĻĻāĻŋāϕ⧇āϰ operand āĻāϰ āĻŽāĻžāύ āĻŦāĻžāĻŽ āĻĒāĻžāĻļ⧇āϰ operand āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇
z=x+y
z = x + y āĻ…āĻ°ā§āĻĨ x + y āĻāϰ āĻŽāĻžāύ x āϤ⧇ āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰāĻž
+=
(Add AND)
āĻĄāĻžāύ āĻĻāĻŋāϕ⧇āϰ operand āĻāϰ āĻŽāĻžāύ āĻŦāĻžāĻŽ āĻĒāĻžāĻļ⧇āϰ operand āĻāϰ āϏāĻžāĻĨ⧇ āϝ⧋āĻ— āĻ•āϰ⧇ āύāϤ⧁āύ āĻ•āϰ⧇ āĻŦāĻžāĻŽ āĻĻāĻŋāϕ⧇āϰ operand āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ
x += y
x += y āĻāϰ āĻ…āĻ°ā§āĻĨ x = x+y
-=
(Subtract AND)
āĻĄāĻžāύ āĻĻāĻŋāϕ⧇āϰ operand āĻāϰ āĻŽāĻžāύ āĻŦāĻžāĻŽ āĻĒāĻžāĻļ⧇āϰ operand āĻĨ⧇āϕ⧇ āĻŦāĻŋā§Ÿā§‹āĻ— āĻ•āϰ⧇ āύāϤ⧁āύ āĻ•āϰ⧇ āĻŦāĻžāĻŽ āĻĻāĻŋāϕ⧇āϰ operand āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇
x -= y
x -= y āĻāϰ āĻ…āĻ°ā§āĻĨ x = x – y
*=
(Multiply AND)
āĻĻ⧁āχ āĻĒāĻžāĻļ⧇āϰ operand āϗ⧁āύ āĻ•āϰ⧇ āĻŦāĻžāĻŽ āĻĻāĻŋāϕ⧇āϰ operand āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇
x *= y
 
x *= y āĻāϰ āĻ…āĻ°ā§āĻĨ x = x * y
/=
(Divide AND)
āĻŦāĻžāĻŽ āĻĻāĻŋāϕ⧇āϰ operand āĻĄāĻžāύ āĻĒāĻžāĻļ⧇āϰ operand āĻĻāĻŋā§Ÿā§‡ āĻ­āĻžāĻ— āĻ•āϰ⧇ āĻĒā§āϰāĻžāĻĒā§āϤ āĻ­āĻžāĻ—āĻĢāϞ āĻŦāĻžāĻŽ āĻĻāĻŋāϕ⧇āϰ operand āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇
x /= y
x /= y āĻāϰ āĻ…āĻ°ā§āĻĨ x = x / y
%=
(Modulus AND)
āĻĻ⧁āχ āĻĻāĻŋāϕ⧇āϰ operands āĻāϰ āĻŽāĻĄā§āϞāĻžāϏ (āĻ­āĻžāĻ—āĻļ⧇āώ) āĻŦāĻžāĻŽ āĻĒāĻžāĻļ⧇āϰ operand āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇
x %= y
x %= y āĻāϰ āĻ…āĻ°ā§āĻĨ x = x % y
 **=
(Exponent AND)
āĻĻ⧁āχ āĻĻāĻŋāϕ⧇āϰ operands āĻāϰ āĻĒāĻžāĻ“ā§ŸāĻžāϰ āĻŦāĻžāĻŽ āĻĒāĻžāĻļ⧇āϰ operand āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇
x **= y
x **= y āĻāϰ āĻ…āĻ°ā§āĻĨ x = x^y ( x to the power y )
//=
(Floor Division)
āĻĻ⧁āχ āĻĻāĻŋāϕ⧇āϰ operands āĻāϰ Floor Division āĻŦāĻžāĻŽ āĻĒāĻžāĻļ⧇āϰ operand āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇
x //= y
x //= y āĻāϰ āĻ…āĻ°ā§āĻĨ x = x // y
&=
(Bitwise AND)
āĻĻ⧁āχ āĻĻāĻŋāϕ⧇āϰ operands āĻāϰ Bitwise AND āĻŦāĻžāĻŽ āĻĒāĻžāĻļ⧇āϰ operand āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇
x &= 5
x &= 5 āĻāϰ āĻ…āĻ°ā§āĻĨ x = x & 5
|=
(Bitwise OR)
āĻĻ⧁āχ āĻĻāĻŋāϕ⧇āϰ operands āĻāϰ Bitwise OR āĻŦāĻžāĻŽ āĻĒāĻžāĻļ⧇āϰ operand āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ
x |= 5
x |= 5 āĻāϰ āĻ…āĻ°ā§āĻĨ x = x | 5
^=
(Bitwise xOR)
āĻĻ⧁āχ āĻĻāĻŋāϕ⧇āϰ operands āĻāϰ Bitwise xOR āĻŦāĻžāĻŽ āĻĒāĻžāĻļ⧇āϰ operand āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇
x ^= 5
x ^= 5 āĻāϰ āĻ…āĻ°ā§āĻĨ x = x ^ 5
>>=
(Bitwise right shift)
āĻĻ⧁āχ āĻĻāĻŋāϕ⧇āϰ operands āĻāϰ Bitwise right shift āĻŦāĻžāĻŽ āĻĒāĻžāĻļ⧇āϰ operand āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇
x >>= 5
x >>= 5 āĻāϰ āĻ…āĻ°ā§āĻĨ x = x >> 5
 <<=
(Bitwise left shift
āĻĻ⧁āχ āĻĻāĻŋāϕ⧇āϰ operands āĻāϰ Bitwise left shift āĻŦāĻžāĻŽ āĻĒāĻžāĻļ⧇āϰ operand āĻ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇
x <<= 5
x <<= 5 āĻāϰ āĻ…āĻ°ā§āĻĨ x = x << 5
 
 
 
Comparison Operator
 
āϝ⧇āχāϏāĻŦ symbol āĻŦāĻž āϚāĻŋāĻšā§āύ āϝāĻž āĻĻ⧁āχāϟāĻŋ variable āĻāϰ āĻāĻ•āϟāĻŋāϰ āϏāĻžāĻĨ⧇ āφāϰ⧇āĻ•āϟāĻŋāϰ compare āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧ Programming Language āĻāϰ āĻĒāϰāĻŋāĻ­āĻžāώāĻžā§Ÿ āĻ āϗ⧁āϞ⧋āϕ⧇ āĻŦāϞāĻž āĻšā§Ÿ Comparison Operators. Comparison Operator āϏāĻžāϧāĻžāϰāĻŖāϤ āϕ⧋āύ⧋ condition āωāĻĒāϰ⧇ āĻ­āĻŋāĻ¤ā§āϤāĻŋāĻ•āϰ⧇ True āĻ…āĻĨāĻŦāĻž False āϰāĻŋāϟāĻžāĻ°ā§āύ āĻ•āϰ⧇āĨ¤
Comparison Operator āϏāĻŽā§‚āĻš āύāĻŋāĻŽā§āύāϰ⧁āĻĒāσ
āĻ…āĻĒāĻžāϰ⧇āϟāϰ
āĻŦā§āϝāĻŦāĻšāĻžāϰ
āωāĻĻāĻžāĻšāϰāĻŖ
āĻŦā§āϝāĻžāĻ–ā§āϝāĻž
 >
(Greater Than)
āĻŦāĻžāĻŽāĻĒāĻ•ā§āώ āĻāϰ āĻŽāĻžāύ āĻĄāĻžāύāĻĒāĻ•ā§āώ⧇āϰ āĻšā§‡ā§Ÿā§‡ āĻŦ⧜ āĻšāϞ⧇ True āĻšāĻŦ⧇āĨ¤āĻ…āĻ¨ā§āϝāĻĨāĻžā§Ÿ False āĻšāĻŦ⧇
30>25
āĻŦāĻžāĻŽāĻĒāĻ•ā§āώ āĻāϰ āĻŽāĻžāύ āĻĄāĻžāύāĻĒāĻ•ā§āώ⧇āϰ āĻšā§‡ā§Ÿā§‡ āĻŦ⧜ ,āϤāĻžāχ True āĻšāĻŦ⧇āĨ¤
<
(Less Than)
āĻŦāĻžāĻŽ āĻĒāĻ•ā§āĻˇā§āϝ āĻāϰ āĻŽāĻžāύ āĻĄāĻžāύāĻĒāĻ•ā§āώ⧇āϰ āĻšā§‡ā§Ÿā§‡ āϛ⧋āϟ āĻšāϞ⧇ True āĻšāĻŦ⧇āĨ¤āĻ…āĻ¨ā§āϝāĻĨāĻžā§Ÿ False āĻšāĻŦ⧇
25<30
āĻŦāĻžāĻŽ āĻĒāĻ•ā§āĻˇā§āϝ āĻāϰ āĻŽāĻžāύ āĻĄāĻžāύāĻĒāĻ•ā§āώ⧇āϰ āĻšā§‡ā§Ÿā§‡ āϛ⧋āϟ, āϤāĻžāχ True āĻšāĻŦ⧇āĨ¤
==
(Equal )
āĻŦāĻžāĻŽāĻĒāĻ•ā§āώ āĻāϰ āĻŽāĻžāύ āĻāĻŦāĻ‚ āĻĄāĻžāύāĻĒāĻ•ā§āώ āϏāĻŽāĻžāύ āĻšāϞ⧇ True āĻšāĻŦ⧇āĨ¤āĻ…āĻ¨ā§āϝāĻĨāĻžā§Ÿ False āĻšāĻŦ⧇
10==10
āĻŦāĻžāĻŽāĻĒāĻ•ā§āώ āĻāϰ āĻŽāĻžāύ āĻāĻŦāĻ‚ āĻĄāĻžāύāĻĒāĻ•ā§āώ āϏāĻŽāĻžāύ āĻŦāϞ⧇ True āĻšāĻŦ⧇āĨ¤
!= (Not equal)
āĻŦāĻžāĻŽāĻĒāĻ•ā§āώ āĻāϰ āĻŽāĻžāύ āĻāĻŦāĻ‚ āĻĄāĻžāύāĻĒāĻ•ā§āώ āϏāĻŽāĻžāύ āύāĻž āĻšāϞ⧇ True āĻšāĻŦ⧇āĨ¤ āĻ…āĻ¨ā§āϝāĻĨāĻžā§Ÿ False āĻšāĻŦ⧇
10 !=20
āĻŦāĻžāĻŽāĻĒāĻ•ā§āώ āĻāϰ āĻŽāĻžāύ āĻāĻŦāĻ‚ āĻĄāĻžāύāĻĒāĻ•ā§āώ āϏāĻŽāĻžāύ āύāĻž , āϤāĻžāχ True āĻšāĻŦ⧇āĨ¤
>=
(Greater than or equal)
āĻŦāĻžāĻŽāĻĒāĻ•ā§āώ āĻāϰ āĻŽāĻžāύ āĻĄāĻžāύāĻĒāĻ•ā§āώ⧇āϰ āĻšā§‡ā§Ÿā§‡ āĻŦ⧜ āĻŦāĻž āϏāĻŽāĻžāύ āĻšāϞ⧇ True āĻšāĻŦ⧇āĨ¤ āĻ…āĻ¨ā§āϝāĻĨāĻžā§Ÿ False āĻšāĻŦ⧇
10 >=10
āĻŦāĻžāĻŽāĻĒāĻ•ā§āώ āĻāϰ āĻŽāĻžāύ āĻĄāĻžāύāĻĒāĻ•ā§āώ⧇āϰ āĻŽāĻžāύ āϏāĻŽāĻžāύ āϤāĻžāχ True āĻšāĻŦ⧇
<= Less than or equal
āĻŦāĻžāĻŽāĻĒāĻ•ā§āώ āĻāϰ āĻŽāĻžāύ āĻĄāĻžāύāĻĒāĻ•ā§āώ⧇āϰ āĻšā§‡ā§Ÿā§‡ āϛ⧋āϟ āĻŦāĻž āϏāĻŽāĻžāύ āĻšāϞ⧇ True āĻšāĻŦ⧇āĨ¤ āĻ…āĻ¨ā§āϝāĻĨāĻžā§Ÿ False āĻšāĻŦ⧇
10<=10
āĻŦāĻžāĻŽāĻĒāĻ•ā§āώ āĻāϰ āĻŽāĻžāύ āĻĄāĻžāύāĻĒāĻ•ā§āώ⧇āϰ āĻāϰ āϏāĻŽāĻžāύ āϤāĻžāχ True āĻšāĻŦ⧇āĨ¤
 
 
Logical Operators
Logical Operator āĻšāĻšā§āϛ⧇ āϏ⧇āχāϏāĻŦ Operator āϝāĻž āĻĻ⧁āχ āĻŦāĻž āϤāĻžāϰ āĻ“ āĻ…āϧāĻŋāĻ• condition āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āĻ—ā§āϰāĻšāĻŖ āĻ•āϰ⧇āĨ¤
Logical Operator āϏāĻžāϧāĻžāϰāĻŖāϤ āĻĻ⧁āχ āĻŦāĻž āϤāĻžāϰ āĻ“ āĻ…āϧāĻŋāĻ• condition āωāĻĒāϰ⧇ āĻ­āĻŋāĻ¤ā§āϤāĻŋāĻ•āϰ⧇ āĻāϟāĻŋ True āĻ…āĻĨāĻŦāĻž False āϰāĻŋāϟāĻžāĻ°ā§āύ āĻ•āϰ⧇āĨ¤
Logical Operator āϏāĻŽā§‚āĻš āύāĻŋāĻŽā§āύāϰ⧁āĻĒāσ
 
āĻ…āĻĒāĻžāϰ⧇āϟāϰ
āĻŦā§āϝāĻŦāĻšāĻžāϰ
āωāĻĻāĻžāĻšāϰāĻŖ
āĻŦā§āϝāĻžāĻ–ā§āϝāĻž
and
āωāϭ⧟ Operand true āĻšāϞ⧇ True Return āĻ•āϰāĻŦ⧇āĨ¤ āĻ…āĻ¨ā§āϝāĻĨāĻžā§Ÿ False āĻšāĻŦ⧇
print(5>3 and 30>20)
āĻĢāϞāĻžāĻĢāϞ āĻšāĻŋāϏ⧇āĻŦ⧇ āφāĻŽāϰāĻž True āĻĒāĻžāĻŦā§‹āĨ¤ āϝ⧇āĻšā§‡āϤ⧁ āωāϭ⧟ condition true
or
āωāϭ⧟ Operand āĻāϰ āϝ⧇āϕ⧋āύ⧋ āĻāĻ•āϟāĻŋ True āĻ…āĻĨāĻŦāĻž āωāϭ⧟āϟāĻŋ True āĻšāϞ⧇ True Return āĻ•āϰāĻŦ⧇āĨ¤ āĻ…āĻ¨ā§āϝāĻĨāĻžā§Ÿ False āĻšāĻŦ⧇
print(5>3 or 3>20)
āĻĒā§āϰāĻĨāĻŽ condition āϟāĻŋ True āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĻā§āĻŦāĻŋāĻ¤ā§€ā§Ÿ condition āϟāĻŋ FalseāĨ¤ āϝ⧇āĻšā§‡āϤ⧁ āϝ⧇āϕ⧋āύ⧋ āĻāĻ•āϟāĻŋ True āĻ…āĻĨāĻŦāĻž āωāϭ⧟āϟāĻŋ True āĻšāϞ⧇ True Return āĻ•āϰāĻŦ⧇āĨ¤ āϤāĻžāχ āĻāχāĻ–āĻžāύ⧇ True āĻšāĻŦ⧇
not
āĻ…āĻĒāĻžāϰ⧇āĻ¨ā§āĻĄ false āĻšāϞ⧇ True
print(not(3>4))
āϝ⧇āĻšā§‡āϤ⧁ ā§Š āĻāϰ āĻšā§‡ā§Ÿā§‡ āϚāĻžāϰ āĻŦ⧜ āύ⧟, āĻāĻŦāĻ‚ āφāĻŽāϰāĻž not āĻŦā§āϝāĻžāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĻ›āĻŋ āϤāĻžāχ āĻāχāĻ–āĻžāύ⧇ True āĻšāĻŦ⧇
 
 
 
Identity Operators
āĻĻ⧁āϟāĻŋ value āĻ…āĻĨāĻŦāĻž variable āĻŽā§‡āĻŽā§‹āϰāĻŋāϰ āĻāĻ•āχ āĻ…āĻ‚āĻļ⧇ āĻ…āĻŦāĻ¸ā§āĻĨāĻŋāϤ āĻ•āĻŋāύāĻž āĻšā§‡āĻ• āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻĒāĻžāχāĻĨāύ⧇ is āĻāĻŦāĻ‚ is not āĻĻ⧁āϟāĻŋ Operator āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ āĻĒāĻžāχāĻĨāύ⧇āϰ āĻĒāϰāĻŋāĻ­āĻžāώāĻžā§Ÿ āĻāϗ⧁āϞ⧋āϕ⧇ āĻŦāϞāĻž āĻšā§Ÿ Identity Operator.
āωāĻ˛ā§āϞ⧇āĻ–ā§āϝ: āĻĻ⧁āϟāĻŋ āĻ­ā§āϝāĻžāϰāĻŋā§Ÿā§‡āĻŦāϞ āϏāĻŽāĻžāύ āĻšāĻ“ā§ŸāĻžāϰ āĻ…āĻ°ā§āĻĨ āĻāχ āύ⧟ āϝ⧇ āϤāĻžāϰāĻž Identical. āϏ⧁āϤāϰāĻžāĻ‚ āĻĻ⧁āϟāĻŋ value āϏāĻŽāĻžāύ āĻšāϞ⧇ āϤāĻžāϰāĻž Identical āύāĻžāĻ“ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
 
 
āĻ…āĻĒāĻžāϰ⧇āϟāϰ
āĻŦā§āϝāĻŦāĻšāĻžāϰ
āωāĻĻāĻžāĻšāϰāĻŖ
āĻŦā§āϝāĻžāĻ–ā§āϝāĻž
is
āϝāĻĻāĻŋ āĻĻ⧁āϟāĻŋ Operand āĻāϰ Identity āĻāĻ•āχ āĻšā§Ÿ āϤāĻžāĻšāϞ⧇ True āĻĻāĻŋāĻŦ⧇ āĻ…āĻ¨ā§āϝāĻĨāĻžā§Ÿ False āĻĻāĻŋāĻŦ⧇āĨ¤
x = [“apple”, “banana”]
y = [“apple”, “banana”]
z = x
print(x is z)

Output: True

āĻĒāĻžāχāĻĨāύ⧇ āϞāĻŋāĻ¸ā§āϟ āĻāĻŦāĻ‚ āĻĄāĻŋāĻ•āĻļāύāĻžāϰāĻŋ āϕ⧇ āϰ⧇āĻĢāĻžāϰ⧇āĻ¨ā§āϏ āϟāĻžāχāĻĒ⧇āϰ āĻ­ā§āϝāĻžāϰāĻŋā§Ÿā§‡āĻŦāϞ āĻŦāϞ⧇āĨ¤ āĻ…āĻ°ā§āĻĨāĻžā§Ž, āĻāĻ•āχ āϞāĻŋāĻ¸ā§āϟ āĻāĻ•āĻžāϧāĻŋāĻ• āĻ­ā§āϝāĻžāϰāĻŋā§Ÿā§‡āĻŦāϞ āĻ āĻāϏāĻžāχāĻ‚ āĻ•āϰāϞ⧇āĻ“ , āϏāĻŦ āϗ⧁āϞ⧋ āĻ­ā§āϝāĻžāϰāĻŋāĻŦāϞ āĻāĻ•āχ āϞāĻŋāĻ¸ā§āϟ āϕ⧇ āϧāĻžāϰāĻŖ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ , āϏāĻŦ āϗ⧁āϞ⧋ āĻ­ā§āϝāĻžāϰāĻŋā§Ÿā§‡āĻŦāϞ āĻāϰ āφāχāĻĄā§‡āĻ¨ā§āϟāĻŋāϟāĻŋ āϏāĻŽāĻžāύāĨ¤

is not
>āϝāĻĻāĻŋ āĻĻ⧁āϟāĻŋ Operand āĻāϰ Identity āĻāĻ•āχ āύāĻž āĻšā§Ÿ āϤāĻžāĻšāϞ⧇ True āĻĻāĻŋāĻŦ⧇ āĻ…āĻ¨ā§āϝāĻĨāĻžā§Ÿ False āĻĻāĻŋāĻŦ⧇āĨ¤
x = [“apple”, “banana”]
y = [“apple”, “banana”]
z = x
print(x is not z) </td>
Output: False
 
Membership Operators āϏāĻŽā§‚āĻš āύāĻŋāĻŽā§āύāϰ⧁āĻĒāσ
Membership Operators
āϕ⧋āύ⧋ āĻ­ā§āϝāĻžāϞ⧁ āĻŦāĻž āĻ­ā§āϝāĻžāϰāĻŋā§Ÿā§‡āĻŦāϞ string, list, tuple, set āĻ•ā§āϰāĻŽā§‡āϰ āĻŽāĻ§ā§āϝ⧇ āφāϛ⧇ āĻ•āĻŋ āύāĻž āĻāĻŦāĻ‚ dictionary āϕ⧋āύ⧋ āϕ⧀(key)-āĻāϰ āωāĻĒāĻ¸ā§āĻĨāĻŋāϤāĻŋ āφāϛ⧇ āĻ•āĻŋāύāĻž āϤāĻž āϝāĻžāϚāĻžāχ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻĒāĻžāχāĻĨāύ⧇ in āĻāĻŦāĻ‚ not in āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšā§ŸāĨ¤ āĻĒāĻžāχāĻĨāύ⧇āϰ āĻĒāϰāĻŋāĻ­āĻžāώāĻžā§Ÿ āĻāϗ⧁āϞ⧋āϕ⧇ āĻŽā§‡āĻŽā§āĻŦāĻžāϰāĻļāĻŋāĻĒ āĻ…āĻĒāĻžāϰ⧇āϟāϰ(Membership operator) āĻŦāϞāĻž āĻšā§ŸāĨ¤
Membership Operators āϏāĻŽā§‚āĻš āύāĻŋāĻŽā§āύāϰ⧁āĻĒāσ
āĻ…āĻĒāĻžāϰ⧇āϟāϰ
āĻŦā§āϝāĻŦāĻšāĻžāϰ
āωāĻĻāĻžāĻšāϰāĻŖ
āĻŦā§āϝāĻžāĻ–ā§āϝāĻž
in
āĻ•ā§āϰāĻŽ(sequence)-āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻ­ā§āϝāϞ⧁/āĻ­ā§āϝāĻžāϰāĻŋā§Ÿā§‡āĻŦāϞ āĻĨāĻžāĻ•āϞ⧇ True āĻšāĻŦ⧇āĨ¤
print(10 in [10,20,30])
āĻĢāϞāĻžāĻĢāϞ āĻšāĻŋāϏ⧇āĻŦ⧇ āφāĻŽāϰāĻž True āĻĒāĻžāĻŦā§‹āĨ¤ āϝ⧇āĻšā§‡āϤ⧁ 10 āϞāĻŋāĻ¸ā§āϟ āφāϰ āĻŽāĻ§ā§āϝ⧇ āĻŦāĻŋāĻĻā§āϝāĻŽāĻžāύ
not in
āĻ•ā§āϰāĻŽ(sequence)-āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻ­ā§āϝāϞ⧁/āĻ­ā§āϝāĻžāϰāĻŋā§Ÿā§‡āĻŦāϞ āύāĻž āĻĨāĻžāĻ•āϞ⧇ True āĻšāĻŦ⧇āĨ¤
print(11 not in [10,20,30])
āϝ⧇āĻšā§‡āϤ⧁ 11 āϞāĻŋāĻ¸ā§āϟāĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻŦāĻŋāĻĻā§āϝāĻŽāĻžāύ āύ⧟ āĻāĻŦāĻ‚ āφāĻŽāϰāĻž āύ⧋āϟ āχāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĻ›āĻŋ āϤāĻžāχ āĻāĻ–āĻžāύ⧇ āφāĻŽāϰāĻž False āĻĒāĻžāĻŦā§‹
 
Bitwise Operators
āϝ⧇āχāϏāĻŦ symbol āĻŦāĻž āϚāĻŋāĻšā§āύ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻžāϰ⧇āϰ binary āĻĒāĻ°ā§āϝāĻžā§Ÿā§‡ āĻāĻ• āĻŦāĻž āĻāĻ•āĻžāϧāĻŋāĻ• Integer Number āĻāϰ āĻŽāĻ§ā§āϝ⧇ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āĻŦāĻŋāϟ āĻŽā§‚āĻ˛ā§āϝāĻžā§Ÿāύ,āĻŽā§āϝāĻžāύāĻŋāĻĒ⧁āϞ⧇āĻļāύ āĻāĻŦāĻ‚ decision āĻŦāĻž āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āĻŽā§‚āϞāĻ• āĻ•āĻžāϜ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ, āĻ āϗ⧁āϞ⧋āϕ⧇ āĻŦāϞāĻž āĻšā§Ÿ Bitwise Operators.
Bitwise Operators āϏāĻŽā§‚āĻš āύāĻŋāĻŽā§āύāϰ⧁āĻĒ
āĻ…āĻĒāĻžāϰ⧇āϟāϰ
āωāĻĻāĻžāĻšāϰāĻŖ
āĻŦā§āϝāĻžāĻ–ā§āϝāĻž
&
(and)
print(a & b)
āϏ⧇āχ Binary Bit āϗ⧁āϞāĻŋāχ āφāϏāĻŦ⧇ āϝ⧇āϗ⧁āϞ⧋ a āĻāĻŦāĻ‚ b variable āĻĻ⧁āĻŸā§‹āϤ⧇āχ Binary Value Set āĻŦāĻž 1
 |
(or)
print( x | y )
āϏ⧇āχ Binary Bit āϗ⧁āϞāĻŋāχ āφāϏāĻŦ⧇ āϝ⧇āϗ⧁āϞ⧋ x āĻāĻŦāĻ‚ y variable āĻĻ⧁āĻŸā§‹āϰ āĻŽāĻ§ā§āϝ⧇ āϝ⧇āϕ⧋āύ⧋ āĻāĻ•āϟāĻŋ Set āĻŦāĻž 1
^
(XOR)
x ^ y
 
āϏ⧇āχ Binary Bit āϗ⧁āϞāĻŋāχ āφāϏāĻŦ⧇ āϝ⧇āϗ⧁āϞ⧋ x āĻāĻŦāĻ‚ y variable āĻĻ⧁āĻŸā§‹āϰ āĻŽāĻ§ā§āϝ⧇ āϝ⧇āϕ⧋āύ⧋ āĻāĻ•āϟāĻŋ Set āĻŦāĻž 1 āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĻ⧁āϟāĻŋāχ SET āĻšāĻ“ā§ŸāĻž āϝāĻžāĻŦ⧇āύāĻžāĨ¤
 ~
(Not)
~x
āϝāĻž āφāϛ⧇ āϤāĻžāϰ āĻŦāĻŋāĻĒāϰ⧀āϤ āφāϏāĻŦ⧇āĨ¤ āĻ…āĻ°ā§āĻĨāĻžā§Ž : āϝāĻĻāĻŋ x āĻāϰ Binary Bit 0 āĻĨāĻžāϕ⧇ , āϤāĻžāĻšāϞ⧇ Output āφāϏāĻŦ⧇ 1 . āĻāĻ•āχ āĻ­āĻžāĻŦ⧇ x āĻāϰ Binary Bit 1 āĻĨāĻžāϕ⧇, Output āφāϏāĻŦ⧇ 0
 <<
(Left Shift )
x<<y
x āĻāϰ Binary Bit āϗ⧁āϞ⧋ y āĻāϰ āϏāĻŽāϏāĻ‚āĻ–ā§āϝāĻ• Bit āĻŦāĻžāĻŽā§‡ shift āĻšāĻŦ⧇āĨ¤
 >>
(Right Shift )
x>>y
x āĻāϰ Binary Bit āϗ⧁āϞ⧋ y āĻāϰ āϏāĻŽāϏāĻ‚āĻ–ā§āϝāĻ• Bit āĻĄāĻžāύ⧇ shift āĻšāĻŦ⧇āĨ¤

āωāĻĻāĻžāĻšāϰāύ ā§§) Arithmetic operators

x = 15 y = 4

# Output: x + y = 19

print('x + y =',x+y)

# Output: x - y = 11

print('x - y =',x-y)

# Output: x * y = 60

print('x * y =',x*y)

# Output: x / y = 3.75

print('x / y =',x/y)

# Output: x // y = 3

print('x // y =',x//y)

# Output: x ** y = 50625

print('x ** y =',x**y)

 

āωāĻĻāĻžāĻšāϰāύ ⧍) Comparison operators

x = 10

y = 12

# Output: x > y is False

print('x > y is',x>y)

# Output: x < y is True

print('x < y is',x<y)

# Output: x == y is False

print('x == y is',x==y)

# Output: x != y is True

print('x != y is',x!=y)

# Output: x >= y is False

print('x >= y is',x>=y)

# Output: x <= y is True

print('x <= y is',x<=y)

 

āωāĻĻāĻžāĻšāϰāύ ā§Š) Logical operators

x = True

y = False

print('x and y is',x and y)

print('x or y is',x or y)

print('not x is',not x)

 

āωāĻĻāĻžāĻšāϰāύ ā§Ē) Identity operators

x1 = 5

y1 = 5

x2 = 'Hello'

y2 = 'Hello'

x3 = [1,2,3]

y3 = [1,2,3]

# Output: False

print(x1 is not y1)

# Output: True

print(x2 is y2)

# Output: False

print(x3 is y3)

 

āωāĻĻāĻžāĻšāϰāύ ā§Ģ) Membership operators

x = 'Hello world'

y = {1:'a',2:'b'}

# Output: True

print('H' in x)

# Output: True

print('hello' not in x)

# Output: True

print(1 in y)

# Output: False

print('a' in y)
āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āύ āĻĒā§āϰāĻļā§āύāϏāĻŽā§āĻš
 
 
 
 
a = 4
b = 11
print(a | b)
print(a >> 2)
 
* āφāωāϟāĻĒ⧁āϟ āĻ•āĻŋ āĻšāĻŦ⧇ ?
* āĻŽāĻžāĻā§‡āϰ āϤāĻŋāύāϟāĻŋ āĻ…āĻ•ā§āώāϰ āĻĻāĻŋāϝāĻŧ⧇ āϤ⧈āϰāĻŋ āĻāĻ•āϟāĻŋ āĻ¸ā§āĻŸā§āϰāĻŋāĻ‚ āϤ⧈āϰāĻŋ āĻ•āϰ⧁āύ
    Case 1 : str1 = “GtfeRifLjta”
    Case 1 : str2 = "HySonRy"
* āĻ¸ā§āĻŸā§āϰāĻŋāĻ‚ āĻ…āĻ•ā§āώāϰāϗ⧁āϞāĻŋ āĻāĻŽāύāĻ­āĻžāĻŦ⧇ āϏāĻžāϜāĻžāύ āϝāĻžāϤ⧇ āϛ⧋āϟ āĻšāĻžāϤ⧇āϰ āĻ…āĻ•ā§āώāϰāϗ⧁āϞāĻŋ āĻĒā§āϰāĻĨāĻŽā§‡ āφāϏ⧇
str1 = VivaSoft
* āĻĻ⧁āϟāĻŋ āĻ¸ā§āĻŸā§āϰāĻŋāĻ‚ āĻ­āĻžāϰāϏāĻžāĻŽā§āϝāĻĒā§‚āĻ°ā§āĻŖ āĻ•āĻŋāύāĻž āϤāĻž āĻĒāϰ⧀āĻ•ā§āώāĻž āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻŋ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽ āϞāĻŋāϖ⧁āύāĨ¤ āωāĻĻāĻžāĻšāϰāĻŖāĻ¸ā§āĻŦāϰ⧂āĻĒ, āĻ¸ā§āĻŸā§āϰāĻŋāĻ‚ s1 āĻāĻŦāĻ‚ s2 āĻ­āĻžāϰāϏāĻžāĻŽā§āϝāĻĒā§‚āĻ°ā§āĻŖ āĻšāϝāĻŧ āϝāĻĻāĻŋ s1-āĻāϰ āϏāĻŽāĻ¸ā§āϤ āĻ…āĻ•ā§āώāϰ s2 āϤ⧇ āωāĻĒāĻ¸ā§āĻĨāĻŋāϤ āĻĨāĻžāϕ⧇āĨ¤ character āĻāϰ āĻ…āĻŦāĻ¸ā§āĻĨāĻžāύ āϕ⧋āύ āĻŦā§āϝāĻžāĻĒāĻžāϰ āύāĻžāĨ¤

    Case 1:   s1 = “Yn” s2 = “PYnative”  ,  Output: True

    Case 2:  s1 = “Ynf” s2 = “PYnative”  ,   Output: False

* āύāĻŋāĻŽā§āύāϞāĻŋāĻ–āĻŋāϤ āĻ¸ā§āĻŸā§āϰāĻŋāĻ‚-āĻ āĻĒā§āϰāϤāĻŋāϟāĻŋ āĻŦāĻŋāĻļ⧇āώ āĻĒā§āϰāϤ⧀āĻ• # āĻĻāĻŋāϝāĻŧ⧇ āĻĒā§āϰāϤāĻŋāĻ¸ā§āĻĨāĻžāĻĒāύ āĻ•āϰ⧁āύ

     Input:    str1 = ‘/*Akash is @developer & musician!!’

     Output:  ##Akash is #developer # musician##

ā§§) x = a + b – 25

āĻāĻ–āĻžāύ⧇ (a+b-25) āϕ⧇ āĻ•āĻŋ āĻŦāϞāĻŦā§‹ , (a,b) āϕ⧇ āĻ•āĻŋ āĻŦāϞāĻŦā§‹ ?
⧍) 100 / 25 āφāωāϟāĻĒ⧁āϟ āĻ•āĻŋ āĻšāĻŦ⧇ ?
ā§Š) āĻ…āĻĒāĻžāϰ⧇āϟāϰ is,not,in āĻāϰ āωāĻĻā§āĻĻ⧇āĻļā§āϝ āĻ•āĻŋ?
ā§Ē) āĻĒāĻžāχāĻĨāύ⧇ / āĻāĻŦāĻ‚ // āĻ…āĻĒāĻžāϰ⧇āϟāϰ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āϕ⧀?
ā§Ģ) āĻ•āĻŋāĻ­āĻžāĻŦ⧇ ternary āĻ…āĻĒāĻžāϰ⧇āϟāϰāϗ⧁āϞāĻŋ āĻĒāĻžāχāĻĨāύ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āϝ⧇āϤ⧇ āĻĒāĻžāϰ⧇?