లూప్స్ — while & for లూప్స్

1 లూపింగ్ ఆర్కిటెక్చర్ అంటే ఏమిటి? (Iteration, Iterables & Iterators)

సాఫ్ట్‌వేర్ అభివృద్ధిలో అత్యంత ముఖ్యమైన సూత్రం DRY (Don't Repeat Yourself). మీరు 10 మంది యూజర్ల పేర్లను ప్రింట్ చేయాలంటే 10 సార్లు print() రాయకూడదు; ఒకే ఒక లూప్ ద్వారా ఆ పనిని సాధించాలి.

2 while లూప్ — కండిషన్ ఆధారిత పునరావృతం (Condition-Controlled Loops)

ఒక పని ఎన్నిసార్లు జరగాలో ముందుగా తెలియనప్పుడు, ఒక నిర్దిష్ట షరతు నిజంగా (True) ఉన్నంతవరకు నడవడానికి while లూప్‌ను ఉపయోగిస్తాము:

while లూప్ విజయవంతంగా పనిచేయడానికి 3 దశలు తప్పనిసరి:

1. 1. ఇనిషియలైజేషన్ (Initialization): లూప్ ప్రారంభానికి ముందు వేరియబుల్‌ను సృష్టించడం (ఉదా: counter = 1).
2. 2. కండిషన్ చెక్ (Condition Evaluation): ప్రతి రౌండ్ ప్రారంభంలో షరతును పరీక్షించడం (ఉదా: while counter <= 5:).
3. 3. అప్‌డేట్ / ఇంక్రిమెంట్ (Update Step): లూప్ లోపల వేరియబుల్‌ను మార్చడం (ఉదా: counter += 1).

3 ఇన్ఫినైట్ లూప్స్ (Infinite Loops) — సమస్యలు & ఉద్దేశపూర్వక వినియోగం

ఒకవేళ మీరు అప్‌డేట్ స్టెప్ (counter += 1) రాయడం మర్చిపోతే, కండిషన్ ఎప్పటికీ True గానే ఉండిపోయి లూప్ ఎప్పటికీ ఆగదు! దీనినే ఇన్ఫినైట్ లూప్ (Infinite Loop) అంటారు.

అయితే వాస్తవ ప్రపంచంలో కొన్ని సందర్భాలలో ఉద్దేశపూర్వకంగానే ఇన్ఫినైట్ లూప్స్ వాడతారు:

• వెబ్ సర్వర్లు & క్లౌడ్ లిజనర్లు: క్లయింట్ల నుండి రిక్వెస్ట్‌ల కోసం 24/7 ఎదురుచూసే సర్వర్ సాకెట్లు (while True: client = server.accept()).
• ATM మరియు కన్సోల్ మెనూలు: యూజర్ "Exit" ఆప్షన్ ఎంచుకునే వరకు మెనూని చూపిస్తూనే ఉండటానికి.
• గేమ్ ఇంజిన్స్: గేమ్ స్క్రీన్ ప్రతి సెకనుకు 60 సార్లు రీ-రెండర్ అవ్వడానికి (Game Loop).

4 కోడ్ డెమో 1: while లూప్ కౌంట్‌డౌన్ & టెలిమెట్రీ సిమ్యులేషన్

స్పేస్ రాకెట్ లాంచ్ కౌంట్‌డౌన్ మరియు ఇన్-ప్లేస్ టెలిమెట్రీ డేటాను while లూప్ ద్వారా ఎలా సిమ్యులేట్ చేయవచ్చో పరిశీలించండి:

# ISRO తరహా రాకెట్ లాంచ్ కౌంట్‌డౌన్ డెమో

countdown = 5
fuel_pressure_psi = 2800

print("=" * 55)
print("     🚀 ISRO మిషన్ కంట్రోల్ — ఫైనల్ కౌంట్‌డౌన్")
print("=" * 55)

# while లూప్ ద్వారా కౌంట్‌డౌన్ రన్
while countdown > 0:
    print(f"T-మైనస్ {countdown} సెకన్లు | ఇంధన పీడనం: {fuel_pressure_psi} PSI")
    countdown -= 1  # అప్‌డేట్ స్టెప్ (లేకపోతే ఇన్ఫినైట్ లూప్ అవుతుంది!)
    fuel_pressure_psi += 50

print("-" * 55)
print("🔥 ఇగ్నిషన్ ప్రారంభమైంది! 🚀 రాకెట్ నింగిలోకి దూసుకెళ్లింది!")
print("=" * 55)

# 2. అక్యుమ్యులేటర్ ప్యాటర్న్ (1 నుండి 100 వరకు సంఖ్యల కూడిక)
total_sum = 0
current_num = 1
while current_num <= 100:
    total_sum += current_num
    current_num += 1

print(f"\n1 నుండి 100 వరకు అన్ని సంఖ్యల మొత్తం: {total_sum}")

5 for లూప్ — సీక్వెన్స్ ఆధారిత పునరావృతం (Collection-Controlled Loops)

C, C++ లేదా Java లలో for లూప్ అంటే సాధారణంగా for(int i = 0; i < n; i++) అని ఇండెక్స్ ఆధారంగా రాస్తారు. కానీ పైథాన్‌లో for లూప్ పూర్తిగా భిన్నమైనది మరియు అద్భుతమైనది!

పైథాన్‌లో for లూప్ అనేది ఒక "For-Each" లూప్ లాగా పనిచేస్తుంది. ఇది నేరుగా ఇచ్చిన లిస్ట్, స్ట్రింగ్ లేదా కలెక్షన్‌లోని ప్రతి ఎలిమెంట్‌ను ఒక్కొక్కటిగా బయటకు తీసి వేరియబుల్‌కు అందజేస్తుంది:

ఉదాహరణకు నగరాల పేర్లను ప్రింట్ చేయడానికి ఎటువంటి i = 0, len(), i++ లు అవసరం లేదు:
for city in ["హైదరాబాద్", "విజయవాడ", "విశాఖపట్నం", "తిరుపతి"]:
    print(f"నగరం: {city}")

6 range() ఫంక్షన్ డీప్ డైవ్ — start, stop & step పారామీటర్లు

ఒక పనిని నిర్దిష్ట సంఖ్యలో (ఉదాహరణకు 10 సార్లు లేదా 100 సార్లు) చేయవలసి వచ్చినప్పుడు పైథాన్‌లోని range() బిల్ట్-ఇన్ ఫంక్షన్‌ను ఉపయోగిస్తాము:

7 కోడ్ డెమో 2: range() మల్టిప్లికేషన్ టేబుల్స్ & అర్థమెటిక్ సిరీస్

క్రింది కోడ్‌లో range() ను ఉపయోగించి ఎక్కాలు (Multiplication Tables) మరియు బేసి/సరి సంఖ్యల సిరీస్‌లను రూపొందించడం చూద్దాం:

# range() ఫంక్షన్ మాస్టరీ డెమో

# 1. 7వ ఎక్కం (Multiplication Table for 7)
table_num = 7
print(f"=== {table_num} వ ఎక్కం (1 నుండి 10 వరకు) ===")
for i in range(1, 11):
    print(f"{table_num} x {i:>2} = {table_num * i:>2}")

# 2. స్టెప్ పారామీటర్ ద్వారా సరి సంఖ్యలు (Even numbers)
print("\n1 నుండి 20 మధ్య గల సరి సంఖ్యలు:")
even_nums = []
for n in range(2, 21, 2):
    even_nums.append(n)
print(*even_nums, sep=" ──▶ ")

# 3. రివర్స్ ఆర్డర్ లెక్కింపు
print("\nరివర్స్ కౌంట్ (10 నుండి 1):")
for r in range(10, 0, -2):
    print(f"{r}..", end=" ")
print("ముగిసింది!")

8 స్ట్రింగ్స్ & డిక్షనరీలపై for లూపింగ్ (Iterating Strings & Dicts)

పైథాన్‌లో for లూప్ ఏ ఇటరబుల్ ఆబ్జెక్ట్‌పైనైనా సులభంగా నడుస్తుంది:

• స్ట్రింగ్స్‌పై లూపింగ్: అక్షరాల వారీగా ప్రాసెస్ చేస్తుంది:
  for char in "PYTHON": print(char)
• డిక్షనరీలపై లూపింగ్ (మూడు విధానాలు):
  1. for key in user_dict: (కేవలం కీలను మాత్రమే ఇస్తుంది).
  2. for val in user_dict.values(): (విలువలను మాత్రమే ఇస్తుంది).
  3. for key, val in user_dict.items(): (కీ మరియు విలువ జంటను టపుల్ అన్‌ప్యాకింగ్ ద్వారా ఒకేసారి ఇస్తుంది!).

9 నెస్టెడ్ లూప్స్ (Nested Loops — 2D Matrix Grid Traversal)

ఒక లూప్ లోపల మరొక లూప్‌ను ఉంచడాన్ని నెస్టెడ్ లూప్ (Nested Loop) అంటారు. బయటి లూప్ (Outer Loop) ఒక్కసారి తిరిగిన ప్రతిసారీ, లోపలి లూప్ (Inner Loop) ప్రారంభం నుండి చివరి వరకు పూర్తిగా తిరుగుతుంది.

బాహ్య లూప్ $N$ సార్లు, అంతర్గత లూప్ $M$ సార్లు తిరిగితే మొత్తం ఎగ్జిక్యూషన్లు $N imes M$ అవుతాయి ($O(N^2)$ టైమ్ కాంప్లెక్సిటీ). 2D మ్యాట్రిక్స్ గ్రిడ్స్, ఎక్సెల్ షీట్ రోస్ & కాలమ్స్, మరియు ఇమేజ్ పిక్సెల్స్ ప్రాసెసింగ్ కోసం ఇది అత్యంత అవసరం.

10 కోడ్ డెమో 3: 2D మ్యాట్రిక్స్ గ్రిడ్ ట్రావర్సల్ & ప్యాటర్న్స్

నెస్టెడ్ లూప్స్ ఉపయోగించి కోఆర్డినేట్ గ్రిడ్ మరియు అందమైన పిరమిడ్ ప్యాటర్న్‌ను ఎలా నిర్మించవచ్చో చూడండి:

# నెస్టెడ్ లూప్స్ & 2D మ్యాట్రిక్స్ గ్రిడ్ డెమో

print("1. 3x3 కోఆర్డినేట్ గ్రిడ్ సిస్టమ్:")
for row in range(1, 4):
    for col in range(1, 4):
        print(f"({row},{col})", end="  ")
    print() # ప్రతి అడ్డు వరుస తర్వాత కొత్త లైన్

print("\n2. డైనమిక్ స్టార్ ప్యాటర్న్ (Right-angled Triangle):")
rows = 5
for i in range(1, rows + 1):
    # పైథాన్ స్ట్రింగ్ గుణకారం ద్వారా సులభమైన ప్యాటర్న్
    print("★ " * i)

11 enumerate() & zip() — పైథానిక్ లూపింగ్ టూల్స్

సాంప్రదాయ భాషల నుండి వచ్చిన ప్రోగ్రామర్లు పైథాన్‌లో కూడా i = 0 అని పెట్టి మాన్యువల్‌గా ఇండెక్స్ పెంచుకుంటూ ఉంటారు. కానీ పైథాన్ దీని కోసం రెండు అద్భుతమైన ఇన్-బిల్ట్ ఫంక్షన్లను అందిస్తుంది:

12 కామన్ బిగినర్స్ మిస్టేక్స్ & లూప్ ఆప్టిమైజేషన్ టెక్నిక్స్

• Mistake 1: ఇటరేట్ అవుతున్న లిస్ట్‌ను లూప్ లోపల మోడిఫై చేయడం: for x in my_list: my_list.remove(x) అని రాస్తే పైథాన్ ఇండెక్స్ షిఫ్ట్ అయి కొన్ని అంశాలు దాటవేయబడతాయి! ఎల్లప్పుడూ కాపీపై లూప్ చేయాలి (my_list.copy()) లేదా లిస్ట్ కాంప్రహెన్షన్ వాడాలి.
• Mistake 2: range(len(items)) అనవసరంగా వాడటం: కేవలం అంశాలను చూడటానికి for i in range(len(items)): print(items[i]) రాయడం unpythonic. నేరుగా for item in items: print(item) అని రాయాలి.
• Mistake 3: while లూప్‌లో అప్‌డేట్ మర్చిపోవడం: i += 1 మర్చిపోవడం వల్ల ఇన్ఫినైట్ లూప్ ఏర్పడి బ్రౌజర్ లేదా సర్వర్ ఫ్రీజ్ అవుతుంది.
• Optimization Tip: లూప్‌ల లోపల డాట్ లుకప్స్ (Dot Lookups) తగ్గించండి: లూప్‌లో పదే పదే math.sqrt() పిలిచే బదులు లూప్ బయట sqrt = math.sqrt అని లోకల్ వేరియబుల్‌కు బైండ్ చేసుకుంటే లూప్ దాదాపు 15-20% వేగంగా తిరుగుతుంది!

13 రియల్-వరల్డ్ ప్రాజెక్ట్: "Automated Enterprise Payroll Salary & Tax Processing Engine"

ఈ ఏడవ అధ్యాయంలో నేర్చుకున్న అన్ని అంశాలను (while లూప్స్, for లూప్స్, range, enumerate, zip, డిక్షనరీ ట్రావర్సల్, నెస్టెడ్ ఫార్మాటింగ్) కలగలిపి — ఒక ఎంటర్‌ప్రైజ్ సంస్థలో పనిచేసే ఉద్యోగులందరి వేతనాలు, PF, బోనస్‌లు, ఆదాయ పన్నును ఆటోమేటిక్‌గా లెక్కించే Automated Enterprise Payroll & Tax Engine ప్రాజెక్ట్‌ను నిర్మిద్దాం!

# =====================================================================
# చాప్టర్ 07 మినీ ప్రాజెక్ట్: Automated Enterprise Payroll & Tax Engine
# కాన్సెప్ట్స్: for Loops, while Loops, enumerate(), zip(), Formatted Tables,
#             Overtime Calculations, Tax Slabs & Department Summaries
# =====================================================================

def process_company_payroll(employee_roster: list):
    """
    ఉద్యోగుల డేటాను లూప్ ద్వారా ప్రాసెస్ చేసి పేరోల్ లెడ్జర్ ముద్రిస్తుంది.
    """
    print("\n" + "=" * 76)
    print(f"{'💼 టెక్ ఇన్నోవేషన్స్ ప్రైవేట్ లిమిటెడ్ — అధికారిక జీతాల పట్టిక (PAYROLL 2026)':^76}")
    print("=" * 76)
    print(f"{'క్ర.సం':<6} {'ఉద్యోగి పేరు':<18} {'ప్రాథమిక వేతనం':>14} {'ఓవర్‌టైమ్':>10} {'PF/పన్ను':>12} {'నికర వేతనం (₹)':>14}")
    print("-" * 76)

    total_gross_payroll = 0.0
    total_tax_deductions = 0.0
    total_net_payout = 0.0

    # enumerate() ద్వారా 1 నుండి ఆటోమేటిక్ సీరియల్ నంబర్
    for sno, emp in enumerate(employee_roster, start=1):
        emp_id = emp["id"]
        name = emp["name"]
        base_salary = emp["base"]
        ot_hours = emp["ot_hrs"]
        ot_rate = 350.0 # గంటకు రూ. 350/-

        # 1. ఓవర్‌టైమ్ గణన
        ot_pay = ot_hours * ot_rate
        gross_salary = base_salary + ot_pay

        # 2. పన్ను & ప్రావిడెంట్ ఫండ్ (PF 12%)
        pf_deduction = base_salary * 0.12
        income_tax = (gross_salary * 0.10) if gross_salary > 60000 else (gross_salary * 0.05)
        total_deduction = pf_deduction + income_tax

        # 3. నికర వేతనం (Net Take-home Pay)
        net_pay = gross_salary - total_deduction

        # కంపెనీ మొత్తం లెక్కలు కూడటం
        total_gross_payroll += gross_salary
        total_tax_deductions += total_deduction
        total_net_payout += net_pay

        print(f"{sno:<6} {name:<18} {base_salary:>14,.2f} {ot_pay:>10,.2f} {total_deduction:>12,.2f} {net_pay:>14,.2f}")

    print("=" * 76)
    print(f"{'కంపెనీ మొత్తం స్థూల వ్యయం (Total Gross):':<45} ₹ {total_gross_payroll:>28,.2f}")
    print(f"{'మొత్తం PF & ప్రభుత్వ పన్ను మినహాయింపులు :':<45} ₹ {total_tax_deductions:>28,.2f}")
    print(f"{'ఉద్యోగుల ఖాతాల్లో జమ అయ్యే మొత్తం (Net Payout):':<45} ₹ {total_net_payout:>28,.2f}")
    print("=" * 76)
    print(f"{'✅ నవంబర్ 2026 పేరోల్ విజయవంతంగా ప్రాసెస్ చేయబడింది!':^76}")
    print("=" * 76 + "\n")

# ఉద్యోగుల సమాచారం (Data List)
company_employees = [
    {"id": "EMP101", "name": "సురేష్ వర్మ", "base": 75000.00, "ot_hrs": 12},
    {"id": "EMP102", "name": "లావణ్య రెడ్డి", "base": 92000.00, "ot_hrs": 5},
    {"id": "EMP103", "name": "కార్తీక్ నాయుడు", "base": 48000.00, "ot_hrs": 20},
    {"id": "EMP104", "name": "భవాని ప్రసాద్", "base": 115000.00, "ot_hrs": 0},
    {"id": "EMP105", "name": "స్నిగ్ధ శర్మ", "base": 54000.00, "ot_hrs": 15}
]

process_company_payroll(company_employees)

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