ತಾರ್ಕಿಕ ಆಪರೇಟರ್‌ಗಳು (Logical Operators)

ಪೈಥಾನ್‌ನಲ್ಲಿ, ತಾರ್ಕಿಕ ಆಪರೇಟರ್‌ಗಳು (Logical Operators) ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಷರತ್ತುಗಳನ್ನು (conditions) ಸಂಯೋಜಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಆಪರೇಟರ್‌ಗಳ ಫಲಿತಾಂಶವು ಸಾಮಾನ್ಯವಾಗಿ ಬೂಲಿಯನ್ ಮೌಲ್ಯ (True ಅಥವಾ False) ಆಗಿರುತ್ತದೆ.

---

ಮುಖ್ಯ ತಾರ್ಕಿಕ ಆಪರೇಟರ್‌ಗಳು

ಆಪರೇಟರ್	ಹೆಸರು	ವಿವರಣೆ
and	ಮತ್ತು (AND)	ಎರಡೂ ಷರತ್ತುಗಳು True ಆಗಿದ್ದರೆ ಮಾತ್ರ True ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
or	ಅಥವಾ (OR)	ಯಾವುದಾದರೂ ಒಂದು ಷರತ್ತು True ಆಗಿದ್ದರೆ True ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
not	ಅಲ್ಲ (NOT)	ಷರತ್ತಿನ ಫಲಿತಾಂಶವನ್ನು ಉಲ್ಟಾ ಮಾಡುತ್ತದೆ (True ಇದ್ದರೆ False, False ಇದ್ದರೆ True).

---

1. and ಆಪರೇಟರ್

ಎರಡೂ ಬದಿಯ ಷರತ್ತುಗಳು ನಿಜವಾಗಿದ್ದಾಗ ಮಾತ್ರ and ಆಪರೇಟರ್ True ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಒಂದಾದರೂ ಸುಳ್ಳಾದರೆ, ಫಲಿತಾಂಶ False ಆಗಿರುತ್ತದೆ.

ಸತ್ಯ ಕೋಷ್ಟಕ (Truth Table):

A	B	A and B
True	True	True
True	False	False
False	True	False
False	False	False

ಉದಾಹರಣೆ:

age = 25
has_citizenship = True

if age >= 18 and has_citizenship:
    print("ನೀವು ಮತ ಚಲಾಯಿಸಲು ಅರ್ಹರು.")
else:
    print("ನೀವು ಮತ ಚಲಾಯಿಸಲು ಅರ್ಹರಲ್ಲ.")

---

2. or ಆಪರೇಟರ್

ಯಾವುದಾದರೂ ಒಂದು ಷರತ್ತು ನಿಜವಾಗಿದ್ದರೆ or ಆಪರೇಟರ್ True ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಎರಡೂ ಷರತ್ತುಗಳು ಸುಳ್ಳಾದಾಗ ಮಾತ್ರ ಫಲಿತಾಂಶ False ಆಗಿರುತ್ತದೆ.

ಸತ್ಯ ಕೋಷ್ಟಕ (Truth Table):

A	B	A or B
True	True	True
True	False	True
False	True	True
False	False	False

ಉದಾಹರಣೆ:

day = "Sunday"

if day == "Saturday" or day == "Sunday":
    print("ಇಂದು ರಜೆ!")
else:
    print("ಇಂದು ಕೆಲಸದ ದಿನ.")

---

3. not ಆಪರೇಟರ್

not ಆಪರೇಟರ್ ಒಂದು ಬೂಲಿಯನ್ ಮೌಲ್ಯವನ್ನು ಹಿಮ್ಮುಖಗೊಳಿಸುತ್ತದೆ.

ಸತ್ಯ ಕೋಷ್ಟಕ (Truth Table):

A	not A
True	False
False	True

ಉದಾಹರಣೆ:

is_logged_in = False

if not is_logged_in:
    print("ದಯವಿಟ್ಟು ಲಾಗಿನ್ ಮಾಡಿ.")

ಶಾರ್ಟ್-ಸರ್ಕ್ಯೂಟ್ ಮೌಲ್ಯಮಾಪನ (Short-circuit Evaluation)

ತಾರ್ಕಿಕ ಆಪರೇಟರ್‌ಗಳು "ಶಾರ್ಟ್-ಸರ್ಕ್ಯೂಟ್" ತತ್ವವನ್ನು ಅನುಸರಿಸುತ್ತವೆ.

• and: ಮೊದಲ ಷರತ್ತು False ಆಗಿದ್ದರೆ, ಎರಡನೇ ಷರತ್ತನ್ನು ಪರೀಕ್ಷಿಸುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಫಲಿತಾಂಶವು ಖಂಡಿತವಾಗಿಯೂ False ಆಗಿರುತ್ತದೆ.
• or: ಮೊದಲ ಷರತ್ತು True ಆಗಿದ್ದರೆ, ಎರಡನೇ ಷರತ್ತನ್ನು ಪರೀಕ್ಷಿಸುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಫಲಿತಾಂಶವು ಖಂಡಿತವಾಗಿಯೂ True ಆಗಿರುತ್ತದೆ.

ಈ ಗುಣಲಕ್ಷಣವು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ಮತ್ತು ಕೆಲವು ಎರರ್‌ಗಳನ್ನು ತಡೆಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ಉದಾಹರಣೆ:

x = 10
y = 0

# y ಶೂನ್ಯವಾಗಿರುವುದರಿಂದ, y ನಿಂದ ಭಾಗಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
# ಆದರೆ 'and' ನ ಮೊದಲ ಷರತ್ತು (x > 20) ಸುಳ್ಳಾಗಿರುವುದರಿಂದ, ಎರಡನೇ ಷರತ್ತನ್ನು ಪರೀಕ್ಷಿಸುವುದಿಲ್ಲ.
# ಇದರಿಂದಾಗಿ ZeroDivisionError ಬರುವುದಿಲ್ಲ.
if x > 20 and (x / y) > 2:
    print("ಷರತ್ತು ನಿಜವಾಗಿದೆ.")
else:
    print("ಷರತ್ತು ಸುಳ್ಳಾಗಿದೆ.")

ತಾರ್ಕಿಕ ಆಪರೇಟರ್‌ಗಳು ಸಂಕೀರ್ಣ ಷರತ್ತುಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ಪ್ರೋಗ್ರಾಮ್‌ನ ಹರಿವನ್ನು ನಿಖರವಾಗಿ ನಿಯಂತ್ರಿಸಲು ಅತ್ಯಗತ್ಯ.