డెసిషన్ మేకింగ్ (if, elif, else & match-case)

🐍 Modern Python (Python 3.12+) 🎯 Chapter 6 of 25 ⚙️ Phase 02: కంట్రోల్ ఫ్లో, లూప్స్ & స్ట్రింగ్స్ 📅 2026 Edition
📌 Covered in this chapter: కంట్రోల్ ఫ్లో & బ్రాంచింగ్ · if, if-else, if-elif-else లాడర్ · Truth Value Testing · నెస్టెడ్ కండిషన్స్ & గార్డ్ క్లాజులు (Guard Clauses) · సింగిల్-లైన్ టెర్నరీ ఆపరేటర్ · Modern Python 3.10+ Pattern Matching (match-case) · కేస్ గార్డ్స్ & వైల్డ్‌కార్డ్స్ · Automated Loan KYC & Risk Engine ప్రాజెక్ట్!
కంప్యూటర్ కేవలం లెక్కలు చేసే క్యాలిక్యులేటర్ మాత్రమే కాదు; ఒక పరిస్థితిని విశ్లేషించి, సరైన నిర్ణయాన్ని తీసుకునే సామర్థ్యం ఉన్నప్పుడే అది నిజమైన ఇంటెలిజెంట్ సాఫ్ట్‌వేర్ అవుతుంది. సాధారణంగా ప్రోగ్రామ్‌లు పైనుండి క్రిందికి వరుసగా (Sequentially) రన్ అవుతాయి. కానీ కొన్ని నిర్దిష్ట పరిస్థితుల ఆధారంగా ఏ కోడ్ నడవాలో, ఏ కోడ్‌ను దాటవేయాలో నిర్ణయించే ప్రక్రియనే డెసిషన్ మేకింగ్ లేదా కంట్రోల్ ఫ్లో (Control Flow & Branching) అంటారు. పైథాన్‌లో if, elif, else స్టేట్‌మెంట్‌లు ఇండెంటేషన్ ఆధారంగా ఎంతో స్వచ్ఛంగా ఉండటమే కాకుండా, Python 3.10 లో వచ్చిన గేమ్-చేంజర్ Structural Pattern Matching (match-case) ఇతర భాషల్లోని సాంప్రదాయ switch స్టేట్‌మెంట్ కంటే ఎన్నో రెట్లు శక్తివంతమైన ఆప్షన్లను అందిస్తుంది. ఈ ఆరవ అధ్యాయంతో మనం Phase 02: కంట్రోల్ ఫ్లో, లూప్స్ & స్ట్రింగ్స్ ను అద్భుతంగా ప్రారంభిస్తూ — పూర్తి స్థాయి Automated Banking Loan Approval & KYC Risk Engine ప్రాజెక్ట్ ద్వారా డెసిషన్ మేకింగ్‌పై పూర్తి ఆధిపత్యం సాధిద్దాం!

1 కంట్రోల్ ఫ్లో & డెసిషన్ మేకింగ్ ఆర్కిటెక్చర్ (Control Flow & Branching)

సాధారణ పైథాన్ స్క్రిప్ట్ లైన్ 1 నుండి మొదలై వరుసగా ఆఖరి లైన్ వరకు వెళ్తుంది. దీనిని సీక్వెన్షియల్ ఎగ్జిక్యూషన్ (Sequential Execution) అంటారు. కానీ వాస్తవ ప్రపంచంలో యూజర్ సరైన పాస్‌వర్డ్ కొట్టాడా? అకౌంట్‌లో తగినంత డబ్బు ఉందా? లాంటి ప్రశ్నల ఆధారంగా ప్రోగ్రామ్ మార్గం మారాలి. దీనినే కండిషనల్ బ్రాంచింగ్ (Conditional Branching) అంటారు.

[పైథాన్ డెసిషన్ మేకింగ్ కంట్రోల్ ఫ్లో ఆర్కిటెక్చర్] ┌──────────────────────────┐ │ ప్రోగ్రామ్ ప్రారంభం │ └────────────┬─────────────┘ │ ▼ ╱───────────────╲ ╱ కండిషన్ True? ╲────────────┐ ╲ ╱ │ (ఒకవేళ True అయితే) ╲───────────────╱ ▼ │ ┌───────────────┐ │ (False) │ True బ్లాక్ │ ▼ │ కోడ్ ఎగ్జిక్యూట్│ ┌───────────────┐ └───────┬───────┘ │ False బ్లాక్ │ │ │ కోడ్ ఎగ్జిక్యూట్│ │ └───────┬───────┘ │ │ │ └──────────┬──────────┘ ▼ ┌──────────────────────────┐ │ తర్వాతి ప్రోగ్రామ్ ఫ్లో │ └──────────────────────────┘
💡 పైథాన్ Truth Value Testing (Truthiness) నియమాలు:

పైథాన్‌లో if condition: అని రాసినప్పుడు, ఆ కండిషన్ కేవలం బూలియన్ (True/False) మాత్రమే కానవసరం లేదు! ఏదైనా ఆబ్జెక్ట్ Falsy (0, "", [], {}, None, False) అయితే ఫాల్స్ బ్రాంచ్‌కు వెళ్తుంది; ఏవైనా విలువలు ఉన్న ఆబ్జెక్ట్ Truthy అయి ట్రూ బ్రాంచ్‌కు వెళ్తుంది.

2 సింపుల్ if స్టేట్‌మెంట్ — సింటాక్స్ & ఇండెంటేషన్ నియమాలు

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

if condition:
    # కండిషన్ True అయినప్పుడు మాత్రమే రన్ అయ్యే కోడ్ (4 spaces indentation)
    statement_1
    statement_2

ముఖ్యమైన నియమాలు:

3 if-else స్టేట్‌మెంట్ — ద్వంద్వ మార్గాల నియంత్రణ (Two-Way Branching)

ఒక షరతు నిజమైతే ఒక పని, అబద్ధమైతే మరొక పని చేయవలసి వచ్చినప్పుడు if-else జంటను వాడతాము:

if balance >= withdrawal_amount:
    balance -= withdrawal_amount
    print("✅ నగదు విత్‌డ్రా విజయవంతమైంది!")
else:
    print("❌ ఖాతాలో తగినంత నగదు నిల్వ లేదు (Insufficient Balance)!")

ఇక్కడ if బ్లాక్ లేదా else బ్లాక్ — ఈ రెండింటిలో ఏదో ఒక్కటి మాత్రమే ఎగ్జిక్యూట్ అవుతుంది; రెండూ ఒకేసారి రన్ అవ్వడం అసాధ్యం.

4 if-elif-else లాడర్ — బహుళ షరతుల తనిఖీ (Multi-Way Branching)

రెండు కంటే ఎక్కువ ఎంపికలు లేదా విభిన్న పరిస్థితులను వరుసగా తనిఖీ చేయాల్సి వచ్చినప్పుడు elif (Else-If సంక్షిప్త రూపం) లాడర్‌ను ఉపయోగిస్తాము:

స్టేట్‌మెంట్ ఎప్పుడు ఎగ్జిక్యూట్ అవుతుంది? పరిమితి
if condition_1: మొదటి షరతును పరీక్షిస్తుంది. తప్పనిసరిగా మొదట్లో ఒక్కటే ఉండాలి.
elif condition_2: మునుపటి షరతులు ఫెయిల్ అయి, ఈ షరతు ట్రూ అయినప్పుడు. ఎన్నైనా elif బ్లాక్‌లను అమర్చుకోవచ్చు.
else: పైనున్న ఏ ఒక్క షరతు కూడా నిజం కానప్పుడు (డిఫాల్ట్ ఫాల్‌బ్యాక్). ఐచ్ఛికం (Optional), చివరలో ఒక్కటే ఉండాలి.
⚠️ కండిషన్ల క్రమం (Order of Conditions) ఎందుకు అత్యంత ముఖ్యం?

పైథాన్ పైనుండి క్రిందికి ఒక్కొక్క కండిషన్‌ను మాత్రమే పరీక్షిస్తుంది. మొదటి ఏ కండిషన్ అయితే True అవుతుందో, ఆ బ్లాక్‌ను రన్ చేసి వెంటనే మొత్తం if-elif-else లాడర్ నుండి బయటకు వచ్చేస్తుంది! కింద ఉన్న మిగిలిన elif కండిషన్లు True అయినప్పటికీ వాటిని పైథాన్ అస్సలు పరీక్షించదు. కాబట్టి ఎల్లప్పుడూ అత్యంత నిర్దిష్టమైన (Most specific) షరతులను పైన, సాధారణ షరతులను క్రింద రాయాలి.

5 కోడ్ డెమో 1: if-elif-else ఆధారిత స్టూడెంట్ గ్రేడింగ్ & స్కాలర్‌షిప్

విద్యార్థి మార్కుల ఆధారంగా గ్రేడ్ కేటాయించడం మరియు స్కాలర్‌షిప్ అర్హతను నిర్ణయించే పూర్తి కోడ్‌ను పరిశీలించండి:

01_student_grading_scholarship.py
# స్టూడెంట్ గ్రేడింగ్ & స్కాలర్‌షిప్ కాలిక్యులేటర్ డెమో

student_name = "సాయి తేజ"
marks = 88.5
annual_income = 240000 # వార్షిక ఆదాయం

print("=" * 55)
print(f"విద్యార్థి పేరు : {student_name}")
print(f"పొందిన మార్కులు : {marks}%")
print("=" * 55)

# 1. if-elif-else లాడర్ ద్వారా గ్రేడ్ నిర్ణయం
if marks >= 90:
    grade = "A+ (Out Standing)"
    gpa = 10.0
elif marks >= 80:
    grade = "A (Excellent)"
    gpa = 9.0
elif marks >= 70:
    grade = "B (Good)"
    gpa = 8.0
elif marks >= 60:
    grade = "C (Average)"
    gpa = 7.0
elif marks >= 35:
    grade = "D (Pass)"
    gpa = 5.0
else:
    grade = "F (Failed)"
    gpa = 0.0

print(f"ఫలితం గ్రేడ్  : {grade}")
print(f"గ్రేడ్ పాయింట్లు : {gpa} GPA")

# 2. స్కాలర్‌షిప్ కోసం లాజికల్ కండిషన్స్
if marks >= 80 and annual_income <= 300000:
    scholarship_amount = 50000.00
    print(f"స్కాలర్‌షిప్   : అర్హత ఉంది! మంజూరైన మొత్తం: ₹ {scholarship_amount:,.2f}")
elif marks >= 70 and annual_income <= 150000:
    scholarship_amount = 25000.00
    print(f"స్కాలర్‌షిప్   : అర్హత ఉంది! మంజూరైన మొత్తం: ₹ {scholarship_amount:,.2f}")
else:
    print("స్కాలర్‌షిప్   : ఈ కేటగిరీలో స్కాలర్‌షిప్ వర్తించదు.")
print("=" * 55)

6 నెస్టెడ్ కండిషన్స్ (Nested if-else) & గార్డ్ క్లాజులు (Guard Clauses)

ఒక if లేదా else బ్లాక్ లోపల మరొక if-else ను ఉంచడాన్ని నెస్టెడ్ కండిషన్ (Nested if-else) అంటారు. ఉదాహరణకు యూజర్ లాగిన్ అయ్యాడా? లాగిన్ అయితే అడ్మిన్ రోల్ ఉందా? అడ్మిన్ అయితే సూపర్-అడ్మిన్ పర్మిషన్స్ ఉన్నాయా? లాంటి సందర్భాలలో ఇది అవసరం అవుతుంది.

⚠️ ది పిరమిడ్ ఆఫ్ డూమ్ (Arrow Anti-Pattern) నివారించండి:

చాలామంది బిగినర్స్ 4-5 స్థాయిల వరకు నెస్టెడ్ if లని లోపలికి తోసుకుంటూ పోతారు. దీనివల్ల కోడ్ చదవడం నరకంగా మారుతుంది (Pyramid of Doom).

ప్రొడక్షన్ సొల్యూషన్ — గార్డ్ క్లాజులు (Guard Clauses / Return Early):
చెల్లని లేదా ఎర్రర్ పరిస్థితులను మొదట్లోనే చెక్ చేసి వెంటనే return లేదా raise చేయడం ద్వారా కోడ్‌ను ఫ్లాట్‌గా ఉంచవచ్చు!

7 సింగిల్-లైన్ టెర్నరీ ఆపరేటర్ (Conditional Expressions)

చిన్న చిన్న నిర్ణయాల కోసం 4 లైన్ల if-else బ్లాక్ రాయకుండా, ఒకే లైన్‌లో ఫలితాన్ని వేరియబుల్‌కు అసైన్ చేయడానికి పైథాన్‌లో కండిషనల్ ఎక్స్‌ప్రెషన్ (Ternary Operator) ఉంది:

variable = value_if_true if condition else value_if_false

C, C++, Java లేదా JavaScript లో condition ? val1 : val2 లాగా పనిచేస్తుంది. ఉదాహరణలు:

8 Modern Python 3.10+ Pattern Matching (match-case)

Python 3.10 లో ప్రవేశపెట్టబడిన అత్యంత శక్తివంతమైన ఆధునిక ఫీచర్ Structural Pattern Matching (PEP 634). ఇతర భాషల్లోని switch-case కంటే ఇది ఎన్నో రెట్లు ఉన్నతమైనది. ఎందుకంటే ఇది కేవలం సంఖ్యలను మాత్రమే కాకుండా డేటా స్ట్రక్చర్ల ఆకారాన్ని (Shapes, Tuples, Dictionaries) కూడా మ్యాచ్ చేస్తుంది!

match http_status:
    case 200:
        print("✅ విజయవంతమైంది (OK)")
    case 400 | 404:
        print("❌ క్లయింట్ ఎర్రర్ (Bad Request or Not Found)")
    case 500:
        print("🔥 సర్వర్ ఇంటర్నల్ ఎర్రర్")
    case _: # వైల్డ్‌కార్డ్ (ఇతర భాషల్లో default కేస్ లాంటిది)
        print(f"⚠️ తెలియని స్థితి కోడ్: {http_status}")

9 అడ్వాన్స్‌డ్ match-case: కేస్ గార్డ్స్ (if) & సీక్వెన్స్ అన్‌ప్యాకింగ్

match-case యొక్క అసలైన సూపర్-పవర్ ఏమిటంటే ప్యాటర్న్ మ్యాచ్‌తో పాటు అదనపు షరతులను (Guard Conditions) జోడించగలగడం:

10 కోడ్ డెమో 2: Structural Pattern Matching & API రెస్పాన్స్ హ్యాండ్లర్

ఆధునిక క్లౌడ్ మైక్రోసర్వీసెస్ API రెస్పాన్స్‌లను match-case ద్వారా ఎంత అందంగా మరియు క్లీన్‌గా హ్యాండిల్ చేయవచ్చో క్రింది కోడ్‌లో చూడండి:

02_structural_pattern_matching.py
# పైథాన్ 3.10+ Structural Pattern Matching డెమో

def handle_cloud_api_event(event: dict):
    """
    వివిధ రకాల API ఈవెంట్‌లను ప్యాటర్న్ మ్యాచింగ్ ద్వారా ప్రాసెస్ చేస్తుంది.
    """
    match event:
        # 1. సక్సెస్ రెస్పాన్స్ ప్యాటర్న్
        case {"status": 200, "data": payload}:
            print(f"✅ డేటా విజయవంతంగా అందింది: {payload}")

        # 2. రీడైరెక్ట్ ప్యాటర్న్
        case {"status": 301 | 302, "location": target_url}:
            print(f"🔀 కొత్త URL కు రీడైరెక్ట్ చేయబడుతోంది: {target_url}")

        # 3. రేట్ లిమిట్ గార్డ్ కండిషన్ (if retry_after)
        case {"status": 429, "retry_after": seconds} if seconds > 60:
            print(f"🛑 తీవ్రమైన రేట్ లిమిట్! {seconds} సెకన్ల పాటు సిస్టమ్ వేచి ఉంటుంది.")

        case {"status": 429, "retry_after": seconds}:
            print(f"⚠️ చిన్నపాటి వేచింపు: {seconds} సెకన్లలో మళ్లీ ప్రయత్నించండి.")

        # 4. సర్వర్ ఎర్రర్
        case {"status": 500 | 502 | 503, "error": err_msg}:
            print(f"🔥 సర్వర్ డౌన్ అయ్యింది! ఎర్రర్: {err_msg}")

        # 5. తెలియని ఏదైనా ఈవెంట్ (Default Wildcard)
        case _:
            print(f"❓ సరిపోలని గుర్తుతెలియని ఈవెంట్ ఫార్మాట్: {event}")

# టెస్ట్ ఈవెంట్స్ రన్
events = [
    {"status": 200, "data": {"user_id": 901, "name": "బాలాజీ"}},
    {"status": 429, "retry_after": 120},
    {"status": 429, "retry_after": 15},
    {"status": 500, "error": "Database connection timeout"}
]

for ev in events:
    handle_cloud_api_event(ev)

11 డెసిషన్ మేకింగ్ ఆప్టిమైజేషన్: if-elif vs Dictionary vs match-case

పెద్ద ఎంటర్‌ప్రైజ్ అప్లికేషన్లలో వేలాది కండిషన్లను తనిఖీ చేయాల్సి వచ్చినప్పుడు ఏ విధానాన్ని ఎంచుకోవాలి?

విధానం (Approach) టైమ్ కాంప్లెక్సిటీ ఉత్తమ ఉపయోగ సందర్భం ప్రయోజనాలు & పరిమితులు
if-elif-else లాడర్ $O(N)$ లీనియర్ రేంజెస్ (ఉదా: 80 <= score <= 100) మరియు విభిన్న వేరియబుల్స్ ఉన్నప్పుడు. చాలా సులభం, కానీ 20+ కంటే ఎక్కువ కండిషన్లు ఉంటే నెమ్మదిస్తుంది.
డిక్షనరీ డిస్పాచ్ (Dict Dispatch) $O(1)$ కాన్‌స్టాంట్ ఫిక్స్‌డ్ కమాండ్స్ లేదా కీస్ ఆధారంగా ఫంక్షన్లను పిలవడానికి. అత్యంత వేగవంతమైనది, కానీ కాంప్లెక్స్ రేంజ్ చెక్స్ చేయలేదు.
Modern match-case ఆప్టిమైజ్డ్ బైట్‌కోడ్ స్ట్రక్చర్డ్ డేటా (JSON, Tuples, Objects) ను అన్‌ప్యాక్ చేయడానికి. క్లీన్ రీడబిలిటీ మరియు టైప్-సేఫ్ గార్డ్స్ లభిస్తాయి.

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

13 రియల్-వరల్డ్ ప్రాజెక్ట్: "Automated Banking Loan Approval & KYC Risk Engine"

ఈ ఆరవ అధ్యాయంలో నేర్చుకున్న అన్ని కాన్సెప్ట్‌లను (కంట్రోల్ ఫ్లో, if-elif-else లాడర్, చైన్డ్ కంపారిజన్స్, టెర్నరీ ఆపరేటర్, Structural Pattern Matching, గార్డ్ క్లాజులు) కలగలిపి — బ్యాంకింగ్ రంగానికి చెందిన పూర్తి స్థాయి Automated Loan Eligibility & KYC Risk Engine ను నిర్మిద్దాం!

03_bank_loan_kyc_engine.py
# =====================================================================
# చాప్టర్ 06 మినీ ప్రాజెక్ట్: Automated Bank Loan Approval & KYC Engine
# కాన్సెప్ట్స్: if-elif-else Ladder, Chained Range Checks, Ternary Ops,
#             Modern match-case Pattern Matching & Risk Tiering
# =====================================================================

def evaluate_loan_application(
    applicant_name: str,
    age: int,
    monthly_income: float,
    cibil_score: int,
    requested_amount: float,
    loan_type: str,
    kyc_status: str
):
    print("=" * 68)
    print(f"{'🏦 MANA APEX BANK — AUTOMATED LOAN RISK ENGINE 2026':^68}")
    print("=" * 68)
    print(f"దరఖాస్తుదారుని పేరు : {applicant_name:<28} వయస్సు : {age} సం||")
    print(f"నెలవారీ స్థూల ఆదాయం  : ₹ {monthly_income:>12,.2f}  CIBIL  : {cibil_score}")
    print(f"కోరిన లోన్ మొత్తం   : ₹ {requested_amount:>12,.2f}  రకం    : {loan_type}")
    print("-" * 68)

    # 1. గార్డ్ క్లాజ్: వయస్సు మరియు KYC ప్రాథమిక ధృవీకరణ
    if not (21 <= age <= 60):
        print("❌ దరఖాస్తు తిరస్కరించబడింది: వయస్సు 21 నుండి 60 సంవత్సరాల మధ్య ఉండాలి.")
        print("=" * 68 + "\n")
        return

    if kyc_status.upper() != "VERIFIED":
        print(f"❌ దరఖాస్తు పెండింగ్‌లో ఉంది: KYC స్థితి '{kyc_status}' — ఆధార్/పాన్ వెరిఫికేషన్ అవసరం.")
        print("=" * 68 + "\n")
        return

    # 2. CIBIL స్కోర్ ఆధారంగా క్రెడిట్ రిస్క్ అసెస్‌మెంట్ (if-elif-else)
    if cibil_score >= 800:
        risk_tier = "TIER_A"
        risk_label = "చాలా తక్కువ రిస్క్ (Excellent Credit)"
        base_rate = 8.5 # 8.5% వడ్డీ రేటు
        approval_ratio = 1.0 # 100% కోరిన మొత్తం మంజూరు
    elif 720 <= cibil_score < 800:
        risk_tier = "TIER_B"
        risk_label = "మితమైన రిస్క్ (Good Credit)"
        base_rate = 9.8
        approval_ratio = 0.85 # 85% మంజూరు
    elif 650 <= cibil_score < 720:
        risk_tier = "TIER_C"
        risk_label = "అధిక రిస్క్ (Average Credit)"
        base_rate = 12.0
        approval_ratio = 0.60 # 60% మంజూరు
    else:
        print("❌ లోన్ తిరస్కరించబడింది: CIBIL స్కోర్ 650 కంటే తక్కువగా ఉంది.")
        print("=" * 68 + "\n")
        return

    # 3. match-case ద్వారా లోన్ రకం ఆధారంగా ప్రత్యేక నిబంధనలు
    match loan_type.lower():
        case "home" | "గృహ రుణం":
            tenure_years = 20
            interest_rate = base_rate - 0.5 # గృహ రుణాలకు 0.5% రాయితీ
            max_limit = monthly_income * 60

        case "car" | "వాహన రుణం":
            tenure_years = 7
            interest_rate = base_rate + 0.2
            max_limit = monthly_income * 24

        case "personal" | "వ్యక్తిగత రుణం":
            tenure_years = 5
            interest_rate = base_rate + 2.5 # అన్‌సెక్యూర్డ్ లోన్ కాబట్టి అధిక వడ్డీ
            max_limit = monthly_income * 12

        case _:
            print(f"⚠️ లోన్ రకం '{loan_type}' చెల్లదు. ప్రాసెస్ ఆపివేయబడింది.")
            print("=" * 68 + "\n")
            return

    # 4. అర్హత గల తుది మంజూరు మొత్తం గణన
    eligible_amount = min(requested_amount * approval_ratio, max_limit)

    # టెర్నరీ ఆపరేటర్ ద్వారా VIP ప్రాసెసింగ్ ఫీజు నిర్ణయం
    processing_fee = 0.0 if risk_tier == "TIER_A" else 2500.00
    fee_status = "ఉచితం (Zero Fee Promo)" if processing_fee == 0.0 else f"₹ {processing_fee:,.2f}"

    print(f"రిస్క్ కేటగిరీ        : [{risk_tier}] {risk_label}")
    print(f"వడ్డీ రేటు (ROI)      : {interest_rate:.2f}% p.a.")
    print(f"గరిష్ట కాలపరిమితి     : {tenure_years} సంవత్సరాలు")
    print(f"ప్రాసెసింగ్ ఛార్జీలు    : {fee_status}")
    print("-" * 68)
    print(f"✅ మంజూరైన లోన్ మొత్తం: ₹ {eligible_amount:>15,.2f}")
    print("=" * 68)
    print("🎉 అభినందనలు! సూత్రప్రాయంగా మీ లోన్ ఆమోదించబడింది! 🚀\n")

# లైవ్ రన్ టెస్ట్
evaluate_loan_application(
    applicant_name="రాజేశ్వరి దేవి",
    age=34,
    monthly_income=85000.00,
    cibil_score=780,
    requested_amount=1500000.00,
    loan_type="home",
    kyc_status="VERIFIED"
)

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

1. if-elif-else లాడర్‌లో ఏవైనా రెండు కండిషన్లు True అయితే ఏది రన్ అవుతుంది?
సమాధానం: పైనుండి క్రిందికి వచ్చే క్రమంలో మొట్టమొదటి True అయిన కండిషన్ మాత్రమే ఎగ్జిక్యూట్ అవుతుంది. ఆ తర్వాత ఉన్న మిగిలిన అన్ని elif మరియు else బ్లాక్‌లను పైథాన్ పూర్తిగా దాటవేసి లాడర్ నుండి బయటకు వచ్చేస్తుంది.
2. టెర్నరీ ఆపరేటర్ (Ternary Operator) సింటాక్స్ ఏమిటి? ఒక ఉదాహరణ ఇవ్వండి.
సమాధానం: సింటాక్స్: x = value_if_true if condition else value_if_false. ఉదాహరణ: fee = 0 if is_member else 100. షరతు నిజమైతే 0, లేకపోతే 100 వేరియబుల్ లోకి అసైన్ అవుతుంది.
3. గార్డ్ క్లాజ్ (Guard Clause) అంటే ఏమిటి? దీని వల్ల కలిగే ప్రయోజనం ఏమిటి?
సమాధానం: ఒక ఫంక్షన్ ప్రారంభంలోనే తప్పులు లేదా అసాధారణ పరిస్థితులను తనిఖీ చేసి తక్షణమే return లేదా raise చేయడాన్ని గార్డ్ క్లాజ్ అంటారు. ఇది 4-5 స్థాయిల నెస్టెడ్ if ల వల్ల కోడ్ పిరమిడ్ లాగా మారే సమస్యను నివారించి కోడ్‌ను ఫ్లాట్‌గా, క్లీన్‌గా ఉంచుతుంది.
4. match-case లో 'case _:' యొక్క ప్రాముఖ్యత ఏమిటి?
సమాధానం: అండర్‌స్కోర్ _ అనేది వైల్డ్‌కార్డ్ (Wildcard pattern). పైన పేర్కొన్న ఏ ఒక్క కేస్ కూడా మ్యాచ్ కానప్పుడు డిఫాల్ట్ ఫాల్‌బ్యాక్ లాగా ఇది ఎగ్జిక్యూట్ అవుతుంది. ఇది ఇతర భాషల్లోని default: లాంటిది.
5. Python match-case సాంప్రదాయ switch-case కంటే ఎందుకు ఉన్నతమైనది?
సమాధానం: సాధారణ switch కేవలం సంఖ్యలు లేదా స్ట్రింగ్స్‌ను మాత్రమే పోల్చగలదు. కానీ పైథాన్ యొక్క Structural Pattern Matching లిస్ట్‌లు, టపుల్స్, డిక్షనరీల అంతర్గత నిర్మాణాన్ని అన్‌ప్యాక్ చేయగలదు, టైప్‌లను ధృవీకరించగలదు, మరియు if గార్డ్ కండిషన్లను కూడా నేరుగా సపోర్ట్ చేస్తుంది.
← మునుపటి అధ్యాయం: 5. ఆపరేటర్లు & ఎక్స్‌ప్రెషన్స్ తర్వాతి అధ్యాయం: 7. లూప్స్ (while & for) →

ఈ Loan KYC & Risk Engine ను లైవ్‌గా మన కంపైలర్‌లో రన్ చేయండి!

ఎటువంటి లోకల్ సెటప్ లేకుండా, బ్రౌజర్‌లోనే Modern Python 3 కంపైలర్‌లో ఈ కోడ్‌ను ఎగ్జిక్యూట్ చేసి లైవ్ అవుట్‌పుట్‌ను తనిఖీ చేయండి.