ఆపరేటర్లు & ఎక్స్‌ప్రెషన్స్

1 పైథాన్ ఆపరేటర్లు అంటే ఏమిటి? (Operators & Expressions Architecture)

ఒకటి లేదా అంతకంటే ఎక్కువ విలువలపై (Operands) ఒక నిర్దిష్ట గణిత లేదా లాజికల్ పనిని చేయడానికి ఉపయోగించే ప్రత్యేక చిహ్నాలను ఆపరేటర్లు (Operators) అంటారు. ఆపరేటర్లు మరియు ఆపరాండ్స్ కలయికతో ఏర్పడే ఫార్ములాను ఎక్స్‌ప్రెషన్ (Expression) అంటారు (ఉదా: total = subtotal + (tax * 0.18)).

2 అర్థమెటిక్ ఆపరేటర్లు (Arithmetic Operators — +, -, *, /, //, %, **)

పైథాన్‌లో అర్థమెటిక్ ఆపరేటర్లు అత్యంత సహజంగా ఉంటాయి. అయితే డివిజన్ విషయంలో పైథాన్ ప్రత్యేక నియమాలను కలిగి ఉంటుంది:

• 1. ట్రూ డివిజన్ (/): సాధారణ భాగాహారం. సంఖ్యలు నిశ్శేషంగా భాగించబడినప్పటికీ, పైథాన్ 3 లో ఇది ఎల్లప్పుడూ float ఇస్తుంది!
  ఉదాహరణ: 10 / 2 అనేది 5.0 అవుతుంది (5 కాదు!).
• 2. ఫ్లోర్ డివిజన్ (// - Integer Division): ఫలితంలోని దశాంశాలను తొలగించి, పూర్ణాంక భాగాన్ని మాత్రమే ఇస్తుంది (Floor value).
  ఉదాహరణ: 10 // 3 విలువ 3.
  జాగ్రత్త: నెగటివ్ నంబర్లకు ఫ్లోరింగ్ ఎల్లప్పుడూ చిన్న సంఖ్య వైపు వెళ్తుంది: -7 // 2 విలువ -4 (ఎందుకంటే -3.5 కంటే చిన్న పూర్ణాంకం -4).
• 3. మాడ్యులో (% - Remainder): భాగాహారం చేయగా మిగిలిన శేషాన్ని ఇస్తుంది.
  ఉదాహరణ: 14 % 4 విలువ 2. సరి/బేసి సంఖ్యలను కనుగొనడానికి ఇది ఉపయోగపడుతుంది (n % 2 == 0).
• 4. ఎక్స్‌పోనెన్షియేషన్ (** - Power): ఘాతాంకాలను లెక్కించడానికి ప్రత్యేక సింబల్.
  ఉదాహరణ: 2 ** 10 విలువ 1024. C/C++ లో దీని కోసం pow() ఫంక్షన్ వాడాలి, కానీ పైథాన్‌లో ఇన్-బిల్ట్ ఆపరేటర్ ఉంది!

3 కోడ్ డెమో 1: అర్థమెటిక్ ఆపరేటర్లు & మ్యాథమెటికల్ ప్రిసిషన్

ట్రూ డివిజన్, నెగటివ్ ఫ్లోర్ డివిజన్ మరియు భారీ ఎక్స్‌పోనెన్షియల్ లెక్కలను క్రింది కోడ్‌లో పరీక్షించండి:

# పైథాన్ 3 అర్థమెటిక్ ఆపరేటర్ల లోతైన డెమో

a, b = 17, 5

print(f"సంఖ్యలు: a = {a}, b = {b}\n")
print(f"కూడిక (Addition)         : a + b  = {a + b}")
print(f"తీసివేత (Subtraction)     : a - b  = {a - b}")
print(f"గుణకారం (Multiplication) : a * b  = {a * b}")
print(f"ట్రూ డివిజన్ (True Div)  : a / b  = {a / b} (Type: {type(a / b).__name__})")
print(f"ఫ్లోర్ డివిజన్ (Floor Div): a // b = {a // b} (Type: {type(a // b).__name__})")
print(f"శేషం (Modulo Remainder)  : a % b  = {a % b}")
print(f"పవర్ (Exponentiation)    : a ** b = {a ** b}")

# నెగటివ్ ఫ్లోర్ డివిజన్ ప్రవర్తన
neg_num, div = -17, 5
print(f"\nనెగటివ్ ఫ్లోర్ డివిజన్ (-17 // 5): {neg_num // div}")  # Output: -4
print(f"నెగటివ్ మాడ్యులో (-17 % 5)       : {neg_num % div}")   # Output: 3

# భారీ ఘాతాంకాలు (2 పవర్ 64)
ram_bytes = 2 ** 64
print(f"\n64-bit అడ్రస్ స్పేస్ గరిష్ట సైజు: {ram_bytes:,} బైట్స్")

4 కంపారిజన్ ఆపరేటర్లు & చైన్డ్ కంపారిజన్స్ (Chained Comparisons)

రెండు విలువల మధ్య సంబంధాన్ని పోల్చడానికి కంపారిజన్ (రిలేషనల్) ఆపరేటర్లను వాడతాము: ==, !=, >, <, >=, <=. ఫలితం ఎల్లప్పుడూ True లేదా False గా ఉంటుంది.

5 లాజికల్ ఆపరేటర్లు & షార్ట్-సర్క్యూట్ ఇవాల్యుయేషన్ (and, or, not)

ఇతర భాషల్లో లాగా &&, ||, ! కాకుండా, పైథాన్‌లో ఇంగ్లీష్ పదాలు and, or, not లను వాడతాము:

• and: ఇచ్చిన అన్ని షరతులు True అయితేనే మొత్తం ఫలితం True. ఏదైనా ఒక్కటి False అయినా ఫలితం False.
• or: ఇచ్చిన షరతులలో ఏ ఒక్కటి True అయినా ఫలితం True. అన్నీ False అయితేనే False.
• not: ఫలితాన్ని తిరగరాస్తుంది (Negation: not True -> False, not False -> True).

6 అసైన్‌మెంట్ & కాంపౌండ్ ఆపరేటర్లు + వాల్రస్ ఆపరేటర్ (:=)

ఒక వేరియబుల్ విలువను అప్‌డేట్ చేయడానికి కాంపౌండ్ (Augmented) అసైన్‌మెంట్ ఆపరేటర్లను ఉపయోగిస్తాము: +=, -=, *=, /=, //=, %=, **=. ఉదాహరణకు count += 1 అనేది count = count + 1 తో సమానం.

7 కోడ్ డెమో 2: చైన్డ్ కంపారిజన్స్, షార్ట్-సర్క్యూట్ & వాల్రస్ ఆపరేటర్

ఈ ఆధునిక పైథాన్ ఫీచర్లు నిజమైన ప్రొడక్షన్ కోడ్‌లో ఎలా సమయాన్ని ఆదా చేస్తాయో క్రింది ఉదాహరణలో చూడండి:

# చైన్డ్ కంపారిజన్స్, షార్ట్-సర్క్యూటింగ్ & వాల్రస్ ఆపరేటర్ డెమో

# 1. చైన్డ్ కంపారిజన్స్ (Chained Comparisons)
exam_score = 88
if 80 <= exam_score <= 100:
    print("✅ అభినందనలు! మీరు 'Distinction A+' గ్రేడ్ పొందారు!")

# 2. లాజికల్ షార్ట్-సర్క్యూట్ ద్వారా జీరో డివిజన్ నివారణ
denominator = 0
# denominator != 0 ఫాల్స్ అవ్వగానే తర్వాతి భాగాన్ని పైథాన్ రన్ చేయదు!
if denominator != 0 and (100 / denominator > 5):
    print("విభజన విజయవంతం!")
else:
    print("⚠️ సేఫ్ షార్ట్-సర్క్యూట్: ZeroDivisionError రాకుండా రక్షించబడింది!")

# 3. 'or' ఆపరేటర్‌తో డిఫాల్ట్ విలువలు (Fallback pattern)
entered_theme = "" # యూజర్ ఖాళీగా వదిలాడు (Falsy)
active_theme = entered_theme or "dark-mode-default"
print(f"ప్రస్తుత థీమ్: {active_theme}")

# 4. వాల్రస్ ఆపరేటర్ (:=) డెమో
product_catalog = ["ఐఫోన్ 16", "మ్యాక్‌బుక్ ప్రో", "ఐప్యాడ్ ఎయిర్", "ఆపిల్ వాచ్"]

if (total_items := len(product_catalog)) >= 4:
    print(f"స్టాక్ నిండుగా ఉంది! మొత్తం వస్తువులు: {total_items}")

8 ఐడెంటిటీ ఆపరేటర్లు: is vs == (Memory Identity vs Value Equality)

ఇంటర్వ్యూలలో మరియు ప్రొడక్షన్ డీబగ్గింగ్‌లో అత్యంత సాధారణమైన ప్రశ్న: == కి మరియు is కి తేడా ఏమిటి?

PEP 8 అధికారిక నియమం: None ను తనిఖీ చేసేటప్పుడు ఎప్పుడూ if val == None: అని రాయకూడదు ❌; ఎల్లప్పుడూ if val is None: లేదా if val is not None: అని మాత్రమే రాయాలి ✅.

9 మెంబర్‌షిప్ ఆపరేటర్లు (in & not in)

ఒక విలువ ఇచ్చిన సీక్వెన్స్ (స్ట్రింగ్, లిస్ట్, టపుల్, సెట్ లేదా డిక్షనరీ) లో ఉందో లేదో తనిఖీ చేయడానికి in మరియు not in ఆపరేటర్లను ఉపయోగిస్తాము:

• స్ట్రింగ్స్ లో సబ్‌స్ట్రింగ్ సెర్చ్: "python" in "learn python in telugu" => True.
• లిస్ట్‌లలో ఎలిమెంట్ ఉనికి: 404 in [200, 301, 404, 500] => True.
• డిక్షనరీలలో కీ సెర్చ్: డిక్షనరీపై in వాడినప్పుడు అది కీలను (Keys) మాత్రమే వెతుకుతుంది:
  user = {"id": 101, "role": "admin"}
"role" in user => True; "admin" in user => False (విలువలను వెతకాలంటే "admin" in user.values() వాడాలి).
• పెర్ఫార్మెన్స్ గమనిక: లిస్ట్ లేదా టపుల్‌లో in వెతకడం $O(N)$ లీనియర్ టైమ్ పడుతుంది; కానీ సెట్స్ (Set) లేదా డిక్షనరీలలో హాష్ టేబుల్ ఉండటం వల్ల $O(1)$ కాన్‌స్టాంట్ టైమ్ లో తక్షణమే వెతుకుతుంది!

10 బిట్‌వైజ్ ఆపరేటర్లు (Bitwise Operators — &, |, ^, ~, <<, >>)

కంప్యూటర్ మెమరీలో డేటా 0 మరియు 1 ల రూపంలో ఉంటుంది. ఈ బైనరీ బిట్స్ పై నేరుగా పనిచేసే ఆపరేటర్లను బిట్‌వైజ్ ఆపరేటర్లు అంటారు. సైబర్ సెక్యూరిటీ, నెట్‌వర్కింగ్, గేమింగ్ మరియు పర్మిషన్ సిస్టమ్స్ (Bitmasking) లో ఇవి అత్యంత కీలకం:

# రియల్-వరల్డ్ బిట్‌వైజ్ పర్మిషన్ సిస్టమ్ (Linux/Cloud Style Bitmasking)

# పర్మిషన్ ఫ్లాగ్స్ (Powers of 2)
READ    = 0b001  # 1
WRITE   = 0b010  # 2
EXECUTE = 0b100  # 4

# 1. యూజర్‌కు READ మరియు WRITE పర్మిషన్లు ఇవ్వడం (Bitwise OR |)
user_permissions = READ | WRITE
print(f"యూజర్ పర్మిషన్ బిట్స్: {bin(user_permissions)} (Decimal: {user_permissions})")

# 2. పర్మిషన్ ఉందో లేదో తనిఖీ చేయడం (Bitwise AND &)
can_read = (user_permissions & READ) != 0
can_write = (user_permissions & WRITE) != 0
can_execute = (user_permissions & EXECUTE) != 0

print(f"చదవగలరా (Can Read)?     : {can_read}")
print(f"రాయగలరా (Can Write)?    : {can_write}")
print(f"రన్ చేయగలరా (Can Exec)? : {can_execute}")

# 3. లెఫ్ట్ షిఫ్ట్ ద్వారా 2తో వేగవంతమైన గుణకారం
val = 8
print(f"\n8 << 2 (8 * 4): {val << 2}")
print(f"8 >> 2 (8 // 4): {val >> 2}")

11 ఆపరేటర్ ప్రెసిడెన్స్ & అసోసియేటివిటీ (Precedence Table & PEMDAS)

ఒకే ఎక్స్‌ప్రెషన్‌లో బహుళ ఆపరేటర్లు ఉన్నప్పుడు ఏది ముందుగా ఎగ్జిక్యూట్ అవ్వాలో నిర్ణయించే నియమాలను ఆపరేటర్ ప్రెసిడెన్స్ (Operator Precedence) అంటారు. గణితంలోని BODMAS / PEMDAS నియమాలతో పాటు పైథాన్‌లో పూర్తి ప్రెసిడెన్స్ క్రమం ఇలా ఉంటుంది (పైనుండి క్రిందికి ప్రాధాన్యత తగ్గుతుంది):

12 కామన్ బిగినర్స్ మిస్టేక్స్ & ప్రొడక్షన్ బెస్ట్ ప్రాక్టీసెస్

• Mistake 1: అసైన్‌మెంట్ (=) మరియు ఈక్వాలిటీ (==) గందరగోళం: if x = 5: అని రాస్తే సింటాక్స్ ఎర్రర్ వస్తుంది. పోల్చడానికి ఎల్లప్పుడూ రెండు ఈక్వల్స్ == వాడాలి.
• Mistake 2: ఫ్లోట్స్‌ను == తో నేరుగా పోల్చడం: బైనరీ ఫ్లోటింగ్ పాయింట్ ప్రెసిషన్ వల్ల 0.1 + 0.2 == 0.3 ఫాల్స్ అవుతుంది! ఫ్లోటింగ్ పాయింట్ సంఖ్యలను పోల్చడానికి math.isclose(a, b) వాడాలి.
• Mistake 3: పెద్ద సంఖ్యలకు is వాడటం: పైథాన్ -5 నుండి 256 వరకు మాత్రమే క్యాష్ చేస్తుంది. x = 1000; y = 1000; x is y అనేది False రావచ్చు! కాబట్టి విలువల కోసం ఎల్లప్పుడూ == వాడండి.
• Mistake 4: ఎక్స్‌పోనెన్షియేషన్ అసోసియేటివిటీ: 2 ** 3 ** 2 విలువ 64 కాదు; కుడి నుండి ఎడమకు లెక్కించడం వల్ల 2 ** (3 ** 2) = 2 ** 9 = 512 అవుతుంది!

13 రియల్-వరల్డ్ ప్రాజెక్ట్: "Enterprise E-Commerce Discount, Loyalty & Tax Pricing Engine"

ఈ ఐదవ అధ్యాయంలో నేర్చుకున్న అన్ని అంశాలను (అర్థమెటిక్, చైన్డ్ కంపారిజన్స్, లాజికల్ షార్ట్-సర్క్యూటింగ్, వాల్రస్ ఆపరేటర్, ఐడెంటిటీ, మెంబర్‌షిప్ మరియు బిట్‌వైజ్ పర్మిషన్స్) కలగలిపి — ఒక పూర్తి స్థాయి Enterprise Dynamic Pricing & Loyalty Engine ను నిర్మిద్దాం!

# =====================================================================
# చాప్టర్ 05 మినీ ప్రాజెక్ట్: E-Commerce Dynamic Pricing & Loyalty Engine
# కాన్సెప్ట్స్: Arithmetic, Chained Comparisons, Walrus Operator (:=),
#             Membership (in), Identity (is), Bitwise Flags & Short-circuit
# =====================================================================

# యూజర్ రోల్ బిట్ ఫ్లాగ్స్
ROLE_STANDARD = 0b001
ROLE_AFFILIATE = 0b010
ROLE_STAFF     = 0b100

VALID_COUPONS = {"FESTIVE20": 0.20, "FLASH10": 0.10, "WELCOME50": 0.50}

def calculate_dynamic_cart_bill(
    customer_name: str,
    raw_subtotal: float,
    coupon_code: str | None,
    loyalty_points: int,
    user_roles: int
):
    print("=" * 68)
    print(f"{'🛒 E-COMMERCE DYNAMIC PRICING ENGINE 2026':^68}")
    print("=" * 68)

    subtotal = raw_subtotal
    print(f"కస్టమర్ పేరు        : {customer_name}")
    print(f"ప్రారంభ కార్ట్ విలువ : ₹ {subtotal:>15,.2f}")

    # 1. వాల్రస్ ఆపరేటర్ & మెంబర్‌షిప్ ద్వారా కూపన్ డిస్కౌంట్
    discount_amount = 0.0
    if coupon_code is not None and (clean_code := coupon_code.strip().upper()) in VALID_COUPONS:
        rate = VALID_COUPONS[clean_code]
        discount_amount = subtotal * rate
        print(f"కూపన్ అప్లై అయ్యింది : [{clean_code}] -₹ {discount_amount:>11,.2f} ({rate:.0%})")
    else:
        print("కూపన్ కోడ్          : వర్తించలేదు లేదా చెల్లనిది")

    # 2. చైన్డ్ కంపారిజన్ ద్వారా లాయల్టీ బోనస్ పాయింట్లు
    loyalty_cashback = 0.0
    if 500 <= loyalty_points <= 5000:
        loyalty_cashback = min(loyalty_points * 0.5, 500.0)
        print(f"లాయల్టీ క్యాష్‌బ్యాక్ : {loyalty_points} పాయింట్లు = -₹ {loyalty_cashback:>9,.2f}")

    # 3. బిట్‌వైజ్ ఆపరేటర్ ద్వారా స్టాఫ్ డిస్కౌంట్
    is_staff = (user_roles & ROLE_STAFF) != 0
    staff_discount = (subtotal * 0.05) if is_staff else 0.0
    if is_staff:
        print(f"సిబ్బంది డిస్కౌంట్  : 5% అదనపు తగ్గింపు = -₹ {staff_discount:>9,.2f}")

    # 4. నెట్ మొత్తం & GST పన్ను (అర్థమెటిక్ & రౌండింగ్)
    taxable_amount = max(0.0, subtotal - discount_amount - loyalty_cashback - staff_discount)
    gst_tax = taxable_amount * 0.18 # 18% GST
    final_total = taxable_amount + gst_tax

    print("-" * 68)
    print(f"{'పన్ను విధించదగిన మొత్తం:':<38} ₹ {taxable_amount:>15,.2f}")
    print(f"{'GST పన్ను (18%):':<38} ₹ {gst_tax:>15,.2f}")
    print("=" * 68)
    print(f"{'తుది చెల్లింపు మొత్తం (Net Total):':<38} ₹ {final_total:>15,.2f}")
    print("=" * 68)

# లైవ్ టెస్టింగ్
calculate_dynamic_cart_bill(
    customer_name="బాలాజీ రావు",
    raw_subtotal=14999.00,
    coupon_code="FESTIVE20",
    loyalty_points=1200,
    user_roles=ROLE_STANDARD | ROLE_STAFF
)

★ ఈ అధ్యాయంపై ప్రాక్టీస్ క్విజ్ (Knowledge Check)