లూప్ కంట్రోల్ — break, continue, pass & else

1 లూప్ కంట్రోల్ స్టేట్‌మెంట్స్ పరిచయం (Loop Flow Interruption)

పైథాన్‌లో లూప్ నడుస్తున్నప్పుడు దాని సాధారణ ప్రవర్తనను మార్చడానికి 4 ప్రధాన కంట్రోల్ స్టేట్‌మెంట్స్ ఉన్నాయి:

2 break స్టేట్‌మెంట్ — లూప్‌ను తక్షణమే నిలిపివేయడం (Immediate Loop Exit)

break స్టేట్‌మెంట్ కనిపించిన క్షణంలోనే, లూప్ యొక్క కండిషన్ ఇంకా True గా ఉన్నప్పటికీ లేదా లిస్ట్‌లో ఇంకా ఎన్నో అంశాలు మిగిలి ఉన్నప్పటికీ — పైథాన్ ఆ లూప్‌ను తక్షణమే ముగించి బయటకు వచ్చేస్తుంది.

3 కోడ్ డెమో 1: break ఆధారిత బ్యాంక్ ATM పిన్ వెరిఫికేషన్

యూజర్‌కు కేవలం 3 అవకాశాలు మాత్రమే ఇచ్చి, సరైన పిన్ కొట్టినప్పుడు వెంటనే లూప్ బ్రేక్ అయ్యే లాజిక్‌ను పరిశీలించండి:

# ATM సెక్యూరిటీ పిన్ వెరిఫికేషన్ (గరిష్టంగా 3 ప్రయత్నాలు)

CORRECT_PIN = "5432"
MAX_ATTEMPTS = 3
attempt = 1

# సిమ్యులేటెడ్ యూజర్ ఎంట్రీలు (టెస్టింగ్ కోసం)
user_inputs = ["1111", "5432", "9999"]

print("=" * 55)
print("     🏧 మన బ్యాంక్ ATM — పిన్ వెరిఫికేషన్ సిస్టమ్")
print("=" * 55)

for entered_pin in user_inputs:
    print(f"ప్రయత్నం {attempt} of {MAX_ATTEMPTS}: పిన్ '{entered_pin}' నమోదు చేయబడింది...")

    if entered_pin == CORRECT_PIN:
        print("✅ పిన్ ధృవీకరించబడింది! లాగిన్ విజయవంతమైంది.")
        print("➡️ ప్రధాన బ్యాంకింగ్ మెనూకి మళ్లించబడుతోంది...")
        break  # పిన్ సరైనది కాబట్టి లూప్‌ను వెంటనే ఆపివేస్తున్నాము!

    print(f"❌ తప్పుడు పిన్! మిగిలిన ప్రయత్నాలు: {MAX_ATTEMPTS - attempt}")
    attempt += 1

    if attempt > MAX_ATTEMPTS:
        print("🛑 హెచ్చరిక: 3 సార్లు తప్పుడు పిన్! మీ డెబిట్ కార్డ్ 24 గంటలు బ్లాక్ చేయబడింది.")
        break

print("=" * 55)

4 continue స్టేట్‌మెంట్ — ప్రస్తుత రౌండ్‌ను దాటవేయడం (Skipping)

continue స్టేట్‌మెంట్ కనిపించినప్పుడు, ఆ రౌండ్‌లో దాని కింద ఉన్న కోడ్ లైన్లను దాటవేసి, లూప్ యొక్క తర్వాతి రౌండ్‌కు (Next Iteration) వెంటనే వెళ్లిపోతుంది. ఇది డేటా ప్రాసెసింగ్ పైప్‌లైన్‌లలో చెల్లని అంశాలను ఫిల్టర్ చేయడానికి ఎక్కువగా ఉపయోగపడుతుంది.

5 కోడ్ డెమో 2: continue ఆధారిత డేటా శానిటైజేషన్

ఒక ఈ-కామర్స్ ఆర్డర్ల లిస్ట్‌లో నెగటివ్ విలువలు లేదా చెల్లని రికార్డులు ఉన్నప్పుడు వాటిని continue ద్వారా దాటవేసి సరైన ఆర్డర్ల మొత్తాన్ని మాత్రమే లెక్కించే కోడ్ చూడండి:

# చెల్లని రికార్డులను దాటవేసే continue డెమో

raw_transactions = [
    {"txn_id": "T101", "amount": 1499.00, "status": "COMPLETED"},
    {"txn_id": "T102", "amount": -50.00,  "status": "CORRUPT"},   # బ్యాడ్ డేటా
    {"txn_id": "T103", "amount": 2899.50, "status": "COMPLETED"},
    {"txn_id": "T104", "amount": 0.00,    "status": "FAILED"},    # ఫెయిల్ అయిన లావాదేవీ
    {"txn_id": "T105", "amount": 750.00,  "status": "COMPLETED"}
]

valid_total = 0.0
processed_count = 0

print("=" * 60)
print(f"{'లావాదేవీ ID':<15} {'స్థితి':<15} {'మొత్తం (₹)':>15}")
print("=" * 60)

for txn in raw_transactions:
    # 1. చెల్లని లావాదేవీలను continue ద్వారా దాటవేస్తున్నాము
    if txn["status"] != "COMPLETED" or txn["amount"] <= 0:
        print(f"⚠️ స్కిప్ చేయబడింది: [{txn['txn_id']}] స్థితి: {txn['status']}")
        continue

    # కేవలం సరైన లావాదేవీలకే ఈ కోడ్ రన్ అవుతుంది
    valid_total += txn["amount"]
    processed_count += 1
    print(f"✅ ప్రాసెస్ అయ్యింది: {txn['txn_id']:<10} {txn['status']:<15} {txn['amount']:>15,.2f}")

print("-" * 60)
print(f"విజయవంతమైన లావాదేవీలు : {processed_count} of {len(raw_transactions)}")
print(f"మొత్తం సేకరించిన మొత్తం : ₹ {valid_total:,.2f}")
print("=" * 60)

6 pass స్టేట్‌మెంట్ — ది నో-ఆప్ ప్లేస్‌హోల్డర్ (The No-Op Null Statement)

పైథాన్‌లో ఇతర భాషల్లో లాగా ఖాళీ కర్లీ బ్రేసెస్ {} లేదా సెమికోలన్ ; పెట్టి బ్లాక్‌ను ఖాళీగా వదిలేయలేము. ఒక if లేదా for కింద ఏమీ రాయకపోతే పైథాన్ IndentationError: expected an indented block ఎర్రర్‌ను విసురుతుంది!

అందుకే సింటాక్స్ నియమాలను సంతృప్తి పరుస్తూ, ప్రస్తుతానికి ఏ పనీ చేయకుండా ఉండేందుకు pass అనే శూన్య స్టేట్‌మెంట్‌ను (No-Op) ఉపయోగిస్తాము:

7 పైథాన్ స్పెషల్ ఫీచర్: for-else & while-else లూప్స్!

చాలామంది డెవలపర్లు పైథాన్‌కు కొత్తగా వచ్చినప్పుడు ఆశ్చర్యపోయే అత్యంత అద్భుతమైన ఫీచర్: లూప్‌లకు కూడా else బ్లాక్ ఉండటం!

సాధారణంగా ఏదైనా ఐటెమ్ దొరికిందో లేదో చూడటానికి ఇతర భాషల్లో found = False అని ఫ్లాగ్ వేరియబుల్ వాడాల్సి వస్తుంది. కానీ పైథాన్‌లో ఎటువంటి ఫ్లాగ్ వేరియబుల్స్ అవసరం లేకుండా for-else తో నేరుగా రాయవచ్చు!

8 కోడ్ డెమో 3: for-else ద్వారా ప్రైమ్ నంబర్ డిటెక్టర్

ఫ్లాగ్ వేరియబుల్స్ లేకుండా for-else ఎంత సొగసైన కోడ్‌ను అందిస్తుందో ఈ క్రింది ప్రధాన సంఖ్యల (Prime Numbers) డిటెక్టర్‌లో చూడండి:

# for-else ద్వారా ప్రైమ్ నంబర్ చెకర్

def check_prime(number: int):
    """
    ఒక సంఖ్య ప్రధాన సంఖ్య (Prime) అవునో కాదో ఫ్లాగ్స్ లేకుండా తేలుస్తుంది.
    """
    if number <= 1:
        print(f"సంఖ్య {number} ప్రధాన సంఖ్య కాదు.")
        return

    # 2 నుండి వర్గమూలం (sqrt) వరకు భాగిస్తున్నాము
    for divisor in range(2, int(number ** 0.5) + 1):
        if number % divisor == 0:
            print(f"❌ {number} ప్రధాన సంఖ్య కాదు (ఇది {divisor} చే నిశ్శేషంగా భాగించబడింది).")
            break # శేషం 0 కాగానే లూప్ ఆగిపోతుంది! else రన్ అవ్వదు!
    else:
        # లూప్ మొత్తం తిరిగి ఏ ఒక్క break రన్ కానప్పుడు మాత్రమే else రన్ అవుతుంది!
        print(f"🌟 {number} ఒక సంపూర్ణ ప్రధాన సంఖ్య (Prime Number)!")

print("=== PRIME NUMBER CHECKER DEMO ===")
check_prime(29)
check_prime(35)
check_prime(97)

9 నెస్టెడ్ లూప్స్ నుండి బయటపడటం (Multi-Level Nested Break)

పైథాన్‌లో C++ లేదా Java లలో లాగా లేబుల్డ్ బ్రేక్ (break outer;) సింటాక్స్ లేదు. మరి 2-3 స్థాయిల నెస్టెడ్ లూప్‌ల నుండి ఒకేసారి బయటపడాలంటే ప్రొడక్షన్‌లో పాటించే 3 వ్యూహాలు:

• 1. ఫంక్షన్‌లో పెట్టి return చేయడం (అత్యంత పైథానిక్ & క్లీన్ సొల్యూషన్): మొత్తం నెస్టెడ్ లూప్‌ను ఒక ఫంక్షన్‌లో ఉంచి, ఫలితం దొరకగానే return చేస్తే అన్ని స్థాయిల లూప్‌ల నుండి తక్షణమే బయటకు వచ్చేస్తుంది.
• 2. ఫ్లాగ్ వేరియబుల్స్ ఉపయోగించడం: found = True చేసి బయటి లూప్‌లో కూడా if found: break రాయడం.
• 3. కస్టమ్ ఎక్సెప్షన్ రైజ్ చేయడం: చాలా లోతైన లూప్‌లలో raise ItemFoundException() ద్వారా డైరెక్ట్‌గా జంప్ చేయడం.

10 కోడ్ డెమో 4: 2D మ్యాట్రిక్స్‌లో ఎలిమెంట్ సెర్చ్ & క్లీన్ రిటర్న్

2D గ్రిడ్‌లో ఒక నిర్దిష్ట కోఆర్డినేట్‌ను కనుగొని నెస్టెడ్ లూప్‌ల నుండి తక్షణమే బయటపడే విధానాన్ని క్రింది స్క్రిప్ట్‌లో చూడండి:

# 2D మ్యాట్రిక్స్ లో సెర్చ్ & ఫంక్షన్ రిటర్న్ బ్రేక్ ప్యాటర్న్

warehouse_grid = [
    ["ఖాళీ", "ఖాళీ", "టెలివిజన్", "ఖాళీ"],
    ["ఖాళీ", "ల్యాప్‌టాప్", "ఖాళీ", "ఖాళీ"],
    ["స్మార్ట్‌వాచ్", "ఖాళీ", "ఖాళీ", "ఐఫోన్"]
]

def locate_product_in_warehouse(grid, target_item):
    """
    2D గ్రిడ్‌లో వస్తువును వెతికి దాని అడ్డు, నిలువు వరుసలను రిటర్న్ చేస్తుంది.
    """
    for row_idx, row in enumerate(grid):
        for col_idx, item in enumerate(row):
            if item == target_item:
                # return రాయడం వల్ల రెండు లూప్‌లు వెంటనే ముగుస్తాయి!
                return f"✅ '{target_item}' గిడ్డంగిలో వరుస {row_idx + 1}, అర {col_idx + 1} లో దొరికింది."
    return f"❌ '{target_item}' స్టాక్‌లో లభించలేదు."

print(locate_product_in_warehouse(warehouse_grid, "ల్యాప్‌టాప్"))
print(locate_product_in_warehouse(warehouse_grid, "డ్రోన్ కెమెరా"))

11 లూప్ కంట్రోల్ పెర్ఫార్మెన్స్ & ఎర్లీ ఎగ్జిట్ (Early Exit Pattern)

లూప్‌లలో break మరియు continue లను సరిగ్గా వాడటం వల్ల సాఫ్ట్‌వేర్ వేగం అసాధారణంగా పెరుగుతుంది. ఉదాహరణకు $1,000,000$ రికార్డులు ఉన్న డేటాబేస్‌లో ఒక ఐటెమ్ కోసం వెతుకుతున్నప్పుడు, అది 50వ స్థానంలోనే దొరికినప్పుడు break రాస్తే మిగిలిన $999,950$ అనవసరమైన ఆపరేషన్లు ఆగిపోతాయి! దీనినే ఎర్లీ ఎగ్జిట్ ప్యాటర్న్ (Early Exit Pattern) అంటారు.

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

• Mistake 1: while లూప్‌లో continue కి ముందు ఇంక్రిమెంట్ మర్చిపోవడం: while i < 10: if i == 5: continue; i += 1 అని రాస్తే i = 5 వద్ద అనంతమైన లూప్‌లో చిక్కుకుపోతుంది! continue పిలవడానికి ముందే వేరియబుల్‌ను అప్‌డేట్ చేయాలి.
• Mistake 2: for-else ను if-else అనుకోవడం: for-else లో else ప్రతి లూప్ రౌండ్‌లోనూ రన్ అవ్వదు; లూప్ మొత్తం break లేకుండా పూర్తయినప్పుడు మాత్రమే చివరగా ఒక్కసారి రన్ అవుతుంది.
• Mistake 3: నెస్టెడ్ లూప్‌లో break ప్రవర్తనను తప్పుగా అర్థం చేసుకోవడం: break కేవలం తనను చుట్టుముట్టిన ఒకే ఒక్క లూప్‌ను మాత్రమే ఆపుతుంది.

13 రియల్-వరల్డ్ ప్రాజెక్ట్: "Automated Cyber Security Log Analyzer & Intrusion Detection System"

ఈ ఎనిమిదవ అధ్యాయంలో నేర్చుకున్న అన్ని అంశాలను (break, continue, pass, for-else, nested search, early exit) కలగలిపి — వెబ్ సర్వర్‌కు వచ్చే వేలాది నెట్‌వర్క్ రిక్వెస్ట్‌లను స్కాన్ చేసి హ్యాకర్ల దాడులను (DDoS, SQL Injection, Brute Force) తక్షణమే గుర్తించి బ్లాక్ చేసే Automated Cyber Security Intrusion Detection System ప్రాజెక్ట్‌ను నిర్మిద్దాం!

# =====================================================================
# చాప్టర్ 08 మినీ ప్రాజెక్ట్: Cyber Security Intrusion Detection System
# కాన్సెప్ట్స్: break, continue, pass, for-else, Threat Detection,
#             Log Sanitization, IP Blocking & Security Audit Reports
# =====================================================================

MALICIOUS_SIGNATURES = ["' OR '1'='1", "", "status": 200}, # XSS Attack
    {"ip": "192.168.1.10", "method": "GET",  "url": "/favicon.ico", "payload": "",             "status": 200}
]

scan_server_access_logs(server_logs)

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