ఫైల్ హ్యాండ్లింగ్, CSV & JSON ప్రాసెసింగ్

1 ఫైల్ హ్యాండ్లింగ్ ఎందుకు అవసరం? (Data Persistence)

కంప్యూటర్ మెమరీ రెండు రకాలుగా ఉంటుంది:

• వోలటైల్ మెమరీ (RAM): వేగవంతమైనది కానీ తాత్కాలికమైనది. విద్యుత్ పోయినా లేదా ప్రోగ్రామ్ ముగిసినా డేటా పూర్తిగా పోతుంది.
• నాన్-వోలటైల్ మెమరీ (Hard Disk / SSD): శాశ్వత నిల్వ. ఇక్కడే మనం ఫైళ్ల రూపంలో డేటాను భద్రపరుస్తాము. దీనినే డేటా పెర్సిస్టెన్స్ (Data Persistence) అంటారు.

పైథాన్‌లో ఫైల్ హ్యాండ్లింగ్ ద్వారా మనం టెక్స్ట్ ఫైల్స్ (.txt), కాన్ఫిగరేషన్ ఫైల్స్ (.ini, .env), డేటా రికార్డులు (.csv), మరియు వెబ్ పేలోడ్లను (.json) డిస్క్ నుండి చదవవచ్చు మరియు కొత్త డేటాను రాయవచ్చు.

2 open() ఫంక్షన్ & ఫైల్ యాక్సెస్ మోడ్స్ మ్యాట్రిక్స్

పైథాన్‌లో ఒక ఫైల్‌ను తెరవడానికి బిల్ట్-ఇన్ open(filename, mode, encoding) ఫంక్షన్‌ను ఉపయోగిస్తాము. ఫైల్‌ను ఏ ఉద్దేశంతో తెరుస్తున్నామో తెలిపేదే మోడ్ (Mode):

3 The with స్టేట్‌మెంట్ & కంటెక్స్ట్ మేనేజర్స్ (Zero Leaks)

సాంప్రదాయ పద్ధతిలో ఫైల్‌ను ఓపెన్ చేసిన తర్వాత తప్పనిసరిగా f.close() చేయాలి. కానీ కోడ్ మధ్యలో ఏదైనా ఎర్రర్ వస్తే close() లైన్ ఎగ్జిక్యూట్ కాక ఆపరేటింగ్ సిస్టమ్ యొక్క ఫైల్ డిస్క్రిప్టర్ లీక్ (File Descriptor Leak) అవుతుంది.

ఈ సమస్యకు పైథాన్ అందించే అంతిమ పరిష్కారమే with కంటెక్స్ట్ మేనేజర్:

తెరవెనుక పైథాన్ __enter__() మరియు __exit__() అనే స్పెషల్ మెథడ్స్ ద్వారా ఫైల్ హ్యాండిల్ స్వయంచాలకంగా విడుదలయ్యేలా హామీ ఇస్తుంది.

4 టెక్స్ట్ ఫైల్స్ రీడింగ్ టెక్నిక్స్ (Memory-Efficient Streaming)

ఫైల్ నుండి డేటాను చదవడానికి నాలుగు విధానాలు ఉన్నాయి:

• 1. f.read(): ఫైల్ మొత్తాన్ని ఒకే ఒక్క భారీ స్ట్రింగ్‌గా మెమరీలోకి లాగుతుంది. 10 GB ఫైల్‌పై ఇది వాడితే సర్వర్ రామ్ నిండిపోయి క్రాష్ అవుతుంది!
• 2. f.readline(): కేవలం ఒక్క లైన్‌ను మాత్రమే చదివి పాయింటర్‌ను తర్వాతి లైన్‌కు జరుపుతుంది.
• 3. f.readlines(): ఫైల్‌లోని అన్ని లైన్లను లిస్ట్ ఆఫ్ స్ట్రింగ్స్ (list[str]) గా అందిస్తుంది.
• 4. లైన్-బై-లైన్ ఇటరేషన్ (The Industry Gold Standard):
  with open("huge_data.log", "r", encoding="utf-8") as f:
      for line in f: # మెమరీలోకి కేవలం ఒకే ఒక్క లైన్ వస్తుంది! సూపర్ ఫాస్ట్!
          process_log_line(line)

5 టెక్స్ట్ ఫైల్స్ రైటింగ్ & flush() ఇంటర్నల్స్

ఫైల్‌లోకి డేటాను రాయడానికి f.write(text) లేదా బహుళ లైన్లను రాయడానికి f.writelines(list_of_lines) వాడతాము.

• write() స్వయంచాలకంగా న్యూలైన్ ( ) ను జోడించదు. మనమే స్పష్టంగా ఇవ్వాలి.
• OS బఫరింగ్ & flush(): మీరు write() కాల్ చేసిన వెంటనే డేటా హార్డ్ డిస్క్‌పై పడదు! వేగం కోసం ఆపరేటింగ్ సిస్టమ్ తన మెమరీ బఫర్‌లో ఉంచుకుంటుంది. తక్షణమే డిస్క్‌పై రాయాలంటే f.flush() కాల్ చేయాలి. with బ్లాక్ ముగియగానే ఆటో-ఫ్లష్ జరుగుతుంది.

6 ఫైల్ పాయింటర్ నావిగేషన్ (tell() & seek())

ఫైల్‌లో మనం ప్రస్తుతం ఎక్కడ చదువుతున్నామో తెలిపే కర్సర్ లేదా పాయింటర్‌ను నియంత్రించే మెథడ్స్:

• f.tell(): ఫైల్ ప్రారంభం నుండి ప్రస్తుత పాయింటర్ ఎన్ని బైట్ల దూరంలో ఉందో పూర్ణాంక సంఖ్యగా అందిస్తుంది.
• f.seek(offset, whence): పాయింటర్‌ను నిర్దిష్ట స్థానానికి తరలిస్తుంది. ఉదాహరణకు f.seek(0) అని రాస్తే పాయింటర్ మళ్లీ ఫైల్ ప్రారంభానికి వెళ్లిపోతుంది, తద్వారా ఫైల్‌ను మళ్లీ మొదటి నుండి చదవవచ్చు!

7 కోడ్ డెమో 1: లైవ్ సిస్టమ్ లాగ్ ఫైల్ జనరేటర్ & రీడర్

with open(), append మోడ్, మరియు లైన్-బై-లైన్ రీడింగ్ ద్వారా లైవ్ లాగర్ ఇంప్లిమెంటేషన్‌ను పరిశీలిద్దాం:

# =====================================================================
# చాప్టర్ 20 డెమో 1: ఫైల్ రైటింగ్ & మెమరీ-ఎఫిషియంట్ లైన్ స్ట్రీమింగ్
# =====================================================================
import os
from datetime import datetime

log_file_name = "app_runtime_audit.txt"

# 1. WRITE & APPEND: లాగ్ డేటాను ఫైల్‌లో నమోదు చేయడం
audit_events = [
    ("INFO", "డేటాబేస్ సర్వర్ కనెక్షన్ విజయవంతం"),
    ("WARNING", "మెమరీ వినియోగం 82% కి చేరింది"),
    ("CRITICAL", "పేమెంట్ గేట్‌వే రెస్పాన్స్ టైమౌట్!"),
    ("INFO", "ఆటోమేటిక్ బ్యాకప్ ప్రక్రియ పూర్తయింది")
]

with open(log_file_name, "w", encoding="utf-8") as f:
    for level, msg in audit_events:
        t_stamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        f.write(f"[{t_stamp}] [{level:<8}] {msg}\n")

print(f"✅ లాగ్ డేటా విజయవంతంగా '{log_file_name}' లో రాయబడింది!")

# 2. READ: లైన్-బై-లైన్ స్ట్రీమింగ్ ద్వారా ఫైల్‌ను చదవడం
print("\n=== ఫైల్ నుండి చదివిన లాగ్స్ (Line-by-Line Streaming) ===")
with open(log_file_name, "r", encoding="utf-8") as f:
    for line_num, line in enumerate(f, start=1):
        print(f"వరుస {line_num}: {line.strip()}")

# క్లీనప్ (టెస్ట్ ఫైల్ తొలగింపు)
if os.path.exists(log_file_name):
    os.remove(log_file_name)

8 csv మాడ్యూల్ — స్ప్రెడ్‌షీట్ డేటా రీడింగ్ & రైటింగ్

CSV (Comma-Separated Values) అనేది ఎక్సెల్ స్ప్రెడ్‌షీట్‌లు మరియు డేటాబేస్ టేబుల్స్ మధ్య సమాచారాన్ని ఇచ్చిపుచ్చుకోవడానికి వాడే అత్యంత ప్రసిద్ధ ఫార్మాట్.

పైథాన్ స్టాండర్డ్ csv మాడ్యూల్ దీనికి రెండు ఉన్నతమైన క్లాస్‌లను అందిస్తుంది:

• csv.DictReader(f): మొదటి లైన్‌ను హెడర్‌గా తీసుకుని, ప్రతి వరుసను స్వయంచాలకంగా ఒక డిక్షనరీ రూపంలో అందిస్తుంది (ఉదా: row['Name'], row['Salary']).
• csv.DictWriter(f, fieldnames): డిక్షనరీల లిస్ట్‌ను నేరుగా CSV ఫార్మాట్‌లోకి రాస్తుంది.
• ⚠️ The Windows Newline Pitfall: CSV ఫైల్‌ను రాసేటప్పుడు ఎల్లప్పుడూ open('file.csv', 'w', newline='', encoding='utf-8') అని newline='' ఇవ్వాలి! లేకపోతే విండోస్‌లో ప్రతి వరుస తర్వాత అనవసరంగా ఒక ఖాళీ లైన్ వస్తుంది.

9 json మాడ్యూల్ — వెబ్ API డేటా సీరియలైజేషన్

JSON (JavaScript Object Notation) అనేది వెబ్ APIలు, క్లౌడ్ సర్వీసులు మరియు కాన్ఫిగరేషన్లలో వాడే గ్లోబల్ స్టాండర్డ్.

పైథాన్ అంతర్నిర్మిత json మాడ్యూల్‌లోని 4 ప్రధాన మెథడ్స్ మధ్య వ్యత్యాసం:

10 కోడ్ డెమో 2: తెలుగు యూనికోడ్ సపోర్ట్‌తో JSON ప్రాసెసింగ్

డిఫాల్ట్‌గా json.dumps() తెలుగు అక్షరాలను తె వంటి ఎస్కేప్ కోడ్స్‌గా మారుస్తుంది. స్పష్టమైన తెలుగు అక్షరాలు కనిపించాలంటే ensure_ascii=False అని పేర్కొనాలి:

# JSON సీరియలైజేషన్ & తెలుగు యూనికోడ్ డెమో
import json

app_config = {
    "app_name": "మన కంపైలర్ పోర్టల్",
    "version": "3.12.2",
    "supported_languages": ["పైథాన్", "జావా", "సి++", "సి#"],
    "settings": {
        "theme": "లైట్ మోడ్",
        "auto_save": True,
        "max_timeout_sec": 15
    }
}

# ensure_ascii=False ద్వారా స్పష్టమైన తెలుగు ప్రింటింగ్
json_output = json.dumps(app_config, indent=2, ensure_ascii=False)
print("=== ఫార్మాట్ చేయబడిన JSON అవుట్‌పుట్ ===")
print(json_output)

11 బైనరీ ఫైల్స్ హ్యాండ్లింగ్ (rb & wb)

చిత్రాలు (PNG/JPG), ఆడియో ఫైల్స్, లేదా PDFలను టెక్స్ట్ మోడ్‌లో చదివితే కరప్ట్ అయిపోతాయి. వాటిని బైనరీ మోడ్ ('rb', 'wb') లో మాత్రమే చదవాలి.

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

• The Encoding Trap (UnicodeDecodeError): విండోస్‌లో డిఫాల్ట్‌గా 'charmap' లేదా 'cp1252' ఎన్‌కోడింగ్ ఉంటుంది. దీనివల్ల తెలుగు లేదా ఎమోజీలు ఉన్న ఫైల్‌ను చదివినప్పుడు క్రాష్ అవుతుంది! పరిష్కారం: ప్రతి open() కాల్‌లోనూ తప్పనిసరిగా encoding="utf-8" అని రాయడం అలవాటు చేసుకోవాలి.
• 'w' మోడ్‌తో డేటా కోల్పోవడం: పాత ఫైల్‌కు డేటా జోడించాలనుకున్నప్పుడు పొరపాటున 'w' మోడ్ వాడితే క్షణంలో మొత్తం పాత డేటా శాశ్వతంగా తుడిచిపెట్టుకుపోతుంది! ఎల్లప్పుడూ 'a' (Append) మోడ్ వాడండి.
• with స్టేట్‌మెంట్ లేకుండా ఫైల్స్ ఓపెన్ చేయడం: సర్వర్లలో వేలాది రిక్వెస్ట్‌లు వచ్చేటప్పుడు ఫైల్స్ క్లోజ్ కాకపోతే OS Too many open files ఎర్రర్ ఇచ్చి సర్వర్‌ను ఆపేస్తుంది.
• CSV లో newline='' మర్చిపోవడం: విండోస్ ఎక్సెల్ షీట్లలో ప్రతి వరుస మధ్య ఒక ఖాళీ లైన్ రాకుండా newline='' తప్పనిసరి.

13 రియల్-వరల్డ్ ప్రాజెక్ట్: "Enterprise ETL Data Ingestion & Customer Audit Pipeline"

ఈ ఇరవైయవ అధ్యాయంలో నేర్చుకున్న అన్ని అంశాలను (ఫైల్ I/O, with open(), CSV DictReader, JSON serialization, UTF-8 ఎన్‌కోడింగ్, డేటా ట్రాన్స్‌ఫార్మేషన్) మిళితం చేస్తూ — ఒక రా CSV కస్టమర్ ట్రాన్సాక్షన్ డేటాను వెలికితీసి (Extract), క్లీన్ చేసి (Transform), మరియు ఆడిట్ అయిన JSON డేటాబేస్‌గా లోడ్ చేసే (Load) పూర్తి స్థాయి Enterprise ETL Data Ingestion Pipeline ను నిర్మిద్దాం!

# =====================================================================
# చాప్టర్ 20 మినీ ప్రాజెక్ట్: Enterprise ETL Data Ingestion Pipeline
# కాన్సెప్ట్స్: File I/O, csv.DictReader, json.dump, UTF-8 Encoding,
#             Data Transformation, Error Resilience, Audit Persistence
# =====================================================================
import csv
import json
import os

CSV_SOURCE_FILE = "raw_customer_transactions.csv"
JSON_AUDIT_DEST = "clean_customer_audit.json"

# 1. రా CSV డేటాను ఫైల్‌లో సిమ్యులేట్ చేయడం (Extract Phase)
raw_csv_content = """cust_id,cust_name,city,plan,amount_paid,status
C101,సురేష్ వర్మ,హైదరాబాద్,Enterprise,45000.0,SUCCESS
C102,కవిత రాణి,విజయవాడ,Professional,18500.0,SUCCESS
C103,అశోక్ కుమార్,విశాఖపట్నం,Basic,4999.0,PENDING
C104,మనోజ్ కృష్ణ,వరంగల్,Enterprise,45000.0,SUCCESS
C105,దివ్య శర్మ,తిరుపతి,Professional,18500.0,FAILED
"""

with open(CSV_SOURCE_FILE, "w", encoding="utf-8", newline="") as f:
    f.write(raw_csv_content.strip())

def execute_enterprise_etl_pipeline():
    """రా CSV నుండి డేటాను చదివి, ట్రాన్స్‌ఫార్మ్ చేసి, JSON లోకి లోడ్ చేస్తుంది."""
    print("\n" + "=" * 74)
    print(f"{'🔄 మన ఎంటర్‌ప్రైజ్ — ETL డేటా ప్రాసెసింగ్ & ఆడిట్ పైప్‌లైన్ 2026':^74}")
    print("=" * 74)

    extracted_records = []
    total_revenue_inr = 0.0

    # 1. EXTRACT: csv.DictReader ద్వారా చదవడం
    with open(CSV_SOURCE_FILE, "r", encoding="utf-8") as f:
        reader = csv.DictReader(f)
        for row in reader:
            # 2. TRANSFORM: డేటా క్లీనింగ్ & బిజినెస్ లాజిక్
            status = row["status"].strip().upper()
            amount = float(row["amount_paid"])

            is_verified = (status == "SUCCESS")
            if is_verified:
                total_revenue_inr += amount

            transformed_cust = {
                "customer_id": row["cust_id"],
                "full_name": row["cust_name"],
                "location": row["city"],
                "subscription_tier": row["plan"],
                "payment": {
                    "amount_inr": amount,
                    "payment_status": status,
                    "verified": is_verified
                }
            }
            extracted_records.append(transformed_cust)

    # ఆడిట్ సమ్మరీ కంటైనర్
    final_audit_payload = {
        "pipeline_version": "2026.1",
        "total_records_ingested": len(extracted_records),
        "total_revenue_cleared_inr": total_revenue_inr,
        "customers": extracted_records
    }

    # 3. LOAD: json.dump ద్వారా శాశ్వత డిస్క్ ఫైల్‌లోకి భద్రపరచడం
    with open(JSON_AUDIT_DEST, "w", encoding="utf-8") as f:
        json.dump(final_audit_payload, f, indent=2, ensure_ascii=False)

    print(f"✅ మొత్తం సేకరించిన రికార్డులు  : {len(extracted_records)}")
    print(f"✅ క్లియర్ అయిన మొత్తం రాబడి   : ₹{total_revenue_inr:,.2f}")
    print(f"📁 డేటా విజయవంతంగా భద్రపరచబడింది: '{JSON_AUDIT_DEST}'")
    print("-" * 74)

    # ధృవీకరణ కోసం JSON నుండి తిరిగి చదవడం (Verification)
    with open(JSON_AUDIT_DEST, "r", encoding="utf-8") as f:
        saved_audit = json.load(f)

    print(f"{'కస్టమర్ ID':<12} {'పేరు':<18} {'నగరం':<14} {'ప్లాన్':<14} {'చెల్లింపు స్థితి':^12}")
    print("-" * 74)
    for c in saved_audit["customers"]:
        p_status = c["payment"]["payment_status"]
        status_icon = "🟢 సక్సెస్" if p_status == "SUCCESS" else ("🟡 పెండింగ్" if p_status == "PENDING" else "🔴 విఫలం")
        print(f"{c['customer_id']:<12} {c['full_name']:<18} {c['location']:<14} {c['subscription_tier']:<14} {status_icon:^12}")

    print("=" * 74)
    print(f"{'🎉 Phase 04 ముగింపు ETL పైప్‌లైన్ విజయవంతంగా పూర్తయింది!':^74}")
    print("=" * 74 + "\n")

    # క్లీనప్
    if os.path.exists(CSV_SOURCE_FILE): os.remove(CSV_SOURCE_FILE)
    if os.path.exists(JSON_AUDIT_DEST): os.remove(JSON_AUDIT_DEST)

execute_enterprise_etl_pipeline()

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