డెసిషన్ మేకింగ్ (if, elif, else & match-case)
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) అంటారు.
పైథాన్లో if condition: అని రాసినప్పుడు, ఆ కండిషన్ కేవలం బూలియన్ (True/False) మాత్రమే కానవసరం లేదు!
ఏదైనా ఆబ్జెక్ట్ Falsy (0, "", [], {}, None, False) అయితే ఫాల్స్ బ్రాంచ్కు వెళ్తుంది; ఏవైనా విలువలు ఉన్న ఆబ్జెక్ట్ Truthy అయి ట్రూ బ్రాంచ్కు వెళ్తుంది.
2 సింపుల్ if స్టేట్మెంట్ — సింటాక్స్ & ఇండెంటేషన్ నియమాలు
ఒక నిర్దిష్ట షరతు నిజమైనప్పుడు మాత్రమే ఒక పని జరగాలి అనుకున్నప్పుడు సింపుల్ if స్టేట్మెంట్ను ఉపయోగిస్తాము:
# కండిషన్ True అయినప్పుడు మాత్రమే రన్ అయ్యే కోడ్ (4 spaces indentation)
statement_1
statement_2
ముఖ్యమైన నియమాలు:
- షరతు చివరలో తప్పనిసరిగా కోలన్
:పెట్టాలి. - C/C++/Java లలో లాగా కర్లీ బ్రేసెస్
{}ఉండవు; లోపలి కోడ్ బ్లాక్ను గుర్తించడానికి కచ్చితంగా 4 స్పేస్ల ఇండెంటేషన్ ఉండాలి. - ఒకవేళ కండిషన్ False అయితే, ఆ ఇండెంటెడ్ బ్లాక్ మొత్తం దాటవేయబడి ప్రోగ్రామ్ తర్వాతి లైన్కు వెళ్లిపోతుంది.
3 if-else స్టేట్మెంట్ — ద్వంద్వ మార్గాల నియంత్రణ (Two-Way Branching)
ఒక షరతు నిజమైతే ఒక పని, అబద్ధమైతే మరొక పని చేయవలసి వచ్చినప్పుడు if-else జంటను వాడతాము:
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), చివరలో ఒక్కటే ఉండాలి. |
పైథాన్ పైనుండి క్రిందికి ఒక్కొక్క కండిషన్ను మాత్రమే పరీక్షిస్తుంది. మొదటి ఏ కండిషన్ అయితే True అవుతుందో, ఆ బ్లాక్ను రన్ చేసి వెంటనే మొత్తం if-elif-else లాడర్ నుండి బయటకు వచ్చేస్తుంది!
కింద ఉన్న మిగిలిన elif కండిషన్లు True అయినప్పటికీ వాటిని పైథాన్ అస్సలు పరీక్షించదు. కాబట్టి ఎల్లప్పుడూ అత్యంత నిర్దిష్టమైన (Most specific) షరతులను పైన, సాధారణ షరతులను క్రింద రాయాలి.
5 కోడ్ డెమో 1: if-elif-else ఆధారిత స్టూడెంట్ గ్రేడింగ్ & స్కాలర్షిప్
విద్యార్థి మార్కుల ఆధారంగా గ్రేడ్ కేటాయించడం మరియు స్కాలర్షిప్ అర్హతను నిర్ణయించే పూర్తి కోడ్ను పరిశీలించండి:
# స్టూడెంట్ గ్రేడింగ్ & స్కాలర్షిప్ కాలిక్యులేటర్ డెమో
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) అంటారు.
ఉదాహరణకు యూజర్ లాగిన్ అయ్యాడా? లాగిన్ అయితే అడ్మిన్ రోల్ ఉందా? అడ్మిన్ అయితే సూపర్-అడ్మిన్ పర్మిషన్స్ ఉన్నాయా? లాంటి సందర్భాలలో ఇది అవసరం అవుతుంది.
చాలామంది బిగినర్స్ 4-5 స్థాయిల వరకు నెస్టెడ్ if లని లోపలికి తోసుకుంటూ పోతారు. దీనివల్ల కోడ్ చదవడం నరకంగా మారుతుంది (Pyramid of Doom).
ప్రొడక్షన్ సొల్యూషన్ — గార్డ్ క్లాజులు (Guard Clauses / Return Early):
చెల్లని లేదా ఎర్రర్ పరిస్థితులను మొదట్లోనే చెక్ చేసి వెంటనే return లేదా raise చేయడం ద్వారా కోడ్ను ఫ్లాట్గా ఉంచవచ్చు!
7 సింగిల్-లైన్ టెర్నరీ ఆపరేటర్ (Conditional Expressions)
చిన్న చిన్న నిర్ణయాల కోసం 4 లైన్ల if-else బ్లాక్ రాయకుండా, ఒకే లైన్లో ఫలితాన్ని వేరియబుల్కు అసైన్ చేయడానికి పైథాన్లో కండిషనల్ ఎక్స్ప్రెషన్ (Ternary Operator) ఉంది:
C, C++, Java లేదా JavaScript లో condition ? val1 : val2 లాగా పనిచేస్తుంది.
ఉదాహరణలు:
status = "మేజర్" if age >= 18 else "మైనర్"shipping_fee = 0.0 if cart_total >= 500 else 40.0user_badge = "👑 VIP" if is_premium else "🌱 Standard"
8 Modern Python 3.10+ Pattern Matching (match-case)
Python 3.10 లో ప్రవేశపెట్టబడిన అత్యంత శక్తివంతమైన ఆధునిక ఫీచర్ Structural Pattern Matching (PEP 634).
ఇతర భాషల్లోని switch-case కంటే ఇది ఎన్నో రెట్లు ఉన్నతమైనది. ఎందుకంటే ఇది కేవలం సంఖ్యలను మాత్రమే కాకుండా డేటా స్ట్రక్చర్ల ఆకారాన్ని (Shapes, Tuples, Dictionaries) కూడా మ్యాచ్ చేస్తుంది!
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) జోడించగలగడం:
- పైప్ ఆపరేటర్ (
|- Multiple matches): ఒకే పని కోసం బహుళ విలువలను కలపవచ్చు (ఉదా:case "GET" | "POST":). - కేస్ గార్డ్స్ (
case ... if condition:): మ్యాచ్ అయిన వేరియబుల్పై షరతు పెట్టడం:case [x, y] if x == y: print("రెండు కోఆర్డినేట్స్ సమానం!") - సీక్వెన్స్ అన్ప్యాకింగ్: కమాండ్ లెంత్ మరియు డేటాను ఒకేసారి విడగొట్టడం:
case ["move", direction, steps]: print(f"{direction} వైపు {steps} అడుగులు వెళ్లు") - డిక్షనరీ ప్యాటర్న్ మ్యాచింగ్: నిర్దిష్ట కీస్ ఉన్నాయా లేదా అని తనిఖీ చేయడం:
case {"role": "admin", "active": True}: grant_root_access()
10 కోడ్ డెమో 2: Structural Pattern Matching & API రెస్పాన్స్ హ్యాండ్లర్
ఆధునిక క్లౌడ్ మైక్రోసర్వీసెస్ API రెస్పాన్స్లను match-case ద్వారా ఎంత అందంగా మరియు క్లీన్గా హ్యాండిల్ చేయవచ్చో క్రింది కోడ్లో చూడండి:
# పైథాన్ 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 కామన్ బిగినర్స్ మిస్టేక్స్ & ప్రొడక్షన్ బెస్ట్ ప్రాక్టీసెస్
- Mistake 1:
if x == True:అని అనవసరంగా రాయడం: పైథాన్లో బూలియన్లను సరిపోల్చడానికి== Trueరాయకూడదు. నేరుగాif x:అని రాయడమే సరైన శైలి. - Mistake 2: కోలన్
:మరియు ఇండెంటేషన్ మర్చిపోవడం:if,elif,else,caseల చివర కోలన్ మర్చిపోతేSyntaxError: expected ':'వస్తుంది. - Mistake 3: కండిషన్ల క్రమం తారుమారు చేయడం: మార్కుల లాడర్లో ముందుగానే
if marks >= 35: print("పాస్")అని పెడితే, 95 మార్కులు వచ్చిన విద్యార్థికి కూడా కేవలం "పాస్" మాత్రమే ప్రింట్ అవుతుంది; కింద ఉన్న 90+ గ్రేడ్ ఎప్పటికీ రన్ అవ్వదు! - Mistake 4:
match-caseలోcase _:మర్చిపోవడం: అనుకోని డేటా వచ్చినప్పుడు క్రాష్ అవ్వకుండా ఎల్లప్పుడూ ఒక డిఫాల్ట్ వైల్డ్కార్డ్case _:ను రాయడం ఉత్తమ ప్రాక్టీస్.
13 రియల్-వరల్డ్ ప్రాజెక్ట్: "Automated Banking Loan Approval & KYC Risk Engine"
ఈ ఆరవ అధ్యాయంలో నేర్చుకున్న అన్ని కాన్సెప్ట్లను (కంట్రోల్ ఫ్లో, if-elif-else లాడర్, చైన్డ్ కంపారిజన్స్, టెర్నరీ ఆపరేటర్, Structural Pattern Matching, గార్డ్ క్లాజులు) కలగలిపి — బ్యాంకింగ్ రంగానికి చెందిన పూర్తి స్థాయి Automated Loan Eligibility & KYC Risk Engine ను నిర్మిద్దాం!
# =====================================================================
# చాప్టర్ 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 అయితే ఏది రన్ అవుతుంది?
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 గార్డ్ కండిషన్లను కూడా నేరుగా సపోర్ట్ చేస్తుంది.
ఈ Loan KYC & Risk Engine ను లైవ్గా మన కంపైలర్లో రన్ చేయండి!
ఎటువంటి లోకల్ సెటప్ లేకుండా, బ్రౌజర్లోనే Modern Python 3 కంపైలర్లో ఈ కోడ్ను ఎగ్జిక్యూట్ చేసి లైవ్ అవుట్పుట్ను తనిఖీ చేయండి.