ఇన్‌పుట్ & అవుట్‌పుట్ ఫార్మాటింగ్ (print, input & f-strings)

1 పైథాన్ I/O ఆర్కిటెక్చర్ అంటే ఏమిటి? (Standard Streams: stdin, stdout, stderr)

పైథాన్ ప్రోగ్రామ్ రన్ అవుతున్నప్పుడు ఆపరేటింగ్ సిస్టమ్ దానికి మూడు ప్రామాణిక కమ్యూనికేషన్ చానెల్స్ (Standard Streams) ను కేటాయిస్తుంది. ఇవి sys మాడ్యూల్ ద్వారా లభిస్తాయి:

2 print() ఫంక్షన్ ఇంటర్నల్స్ — sep, end, file & flush పారామీటర్లు

చాలామంది బిగినర్స్ print("Hello World") అని మాత్రమే రాస్తారు. కానీ పైథాన్ అఫీషియల్ డాక్యుమెంటేషన్‌లో print() ఫంక్షన్ యొక్క పూర్తి సిగ్నేచర్ ఇలా ఉంటుంది:

ఈ 4 ఐచ్ఛిక పారామీటర్లు ప్రొడక్షన్ కోడింగ్‌లో ఎంతో శక్తివంతమైనవి:

• 1. *objects: మీరు ఎన్ని విలువలనైనా కామాతో వేరు చేసి ఇవ్వవచ్చు (ఉదా: print("పేరు:", name, "వయస్సు:", age)).
• 2. sep (Separator - డిఫాల్ట్: సింగిల్ స్పేస్ ' '): ఇచ్చిన ఆబ్జెక్టుల మధ్య ఏ అక్షరం లేదా చిహ్నం రావాలో నిర్ణయిస్తుంది.
  ఉదాహరణ: print("2026", "11", "02", sep="-") ప్రింట్ చేసేది: 2026-11-02.
• 3. end (End Character - డిఫాల్ట్: న్యూలైన్ '\n'): అన్నీ ప్రింట్ అయిన తర్వాత చివరగా ఏ అక్షరం రావాలో చెబుతుంది. బై-డిఫాల్ట్ కర్సర్ తర్వాతి లైన్‌కు వెళ్తుంది. కానీ end=" " అని ఇస్తే కర్సర్ అదే లైన్‌లో ఆగుతుంది!
• 4. flush (డిఫాల్ట్: False): బఫర్ నిండే వరకు వేచి ఉండకుండా వెంటనే డేటాను స్క్రీన్‌పైకి పంపించాలా లేదా అని నిర్ణయిస్తుంది. లైవ్ కౌంట్‌డౌన్ టైమర్లు, డౌన్‌లోడ్ ప్రోగ్రెస్ బార్లలో flush=True తప్పనిసరి!
• 5. file (డిఫాల్ట్: sys.stdout): కన్సోల్‌కు కాకుండా నేరుగా ఒక ఫైల్‌లోకి ప్రింట్ చేయాలంటే file=f ఉపయోగించవచ్చు.

3 కోడ్ డెమో 1: అడ్వాన్స్‌డ్ print() ఫీచర్లు & క్యారేజ్ రిటర్న్ (\r)

క్రింది కోడ్‌ను గమనించండి. ఇందులో sep, end మరియు క్యారేజ్ రిటర్న్ (\r) ఉపయోగించి ఒకే లైన్‌లో అప్‌డేట్ అయ్యే లైవ్ ప్రోగ్రెస్ ఎఫెక్ట్‌ను చూద్దాం:

# అడ్వాన్స్‌డ్ print() పారామీటర్ల డెమో
import time

print("=" * 50)
print("     1. కస్టమ్ సెపరేటర్లు (Custom Separators)")
print("=" * 50)

# URL నిర్మాణం
protocol = "https"
domain = "www.ourcompiler.com"
path = "blog-python"
print(protocol, "://", domain, "/", path, sep="")

# తేదీ మరియు సమయం ఫార్మాటింగ్
day, month, year = 2, 11, 2026
print("నేటి తేదీ:", day, month, year, sep="/")

# బహుళ విలువల మధ్య బాణం గుర్తులు
steps = ["ఇన్‌పుట్ తీసుకోండి", "డేటాను ప్రాసెస్ చేయండి", "ఫలితాన్ని ప్రింట్ చేయండి"]
print(*steps, sep=" ──▶ ")

print("\n" + "=" * 50)
print("     2. లైన్ బ్రేక్ నియంత్రణ (end parameter)")
print("=" * 50)

# ఒకే లైన్‌లో ప్రింట్ చేయడం
print("కౌంట్‌డౌన్ మొదలైంది: ", end="")
for i in [3, 2, 1]:
    print(f"{i}.. ", end="", flush=True)
print("🚀 BLAST OFF!")

# క్యారేజ్ రిటర్న్ (\r) తో ఇన్-ప్లేస్ అప్‌డేట్
print("\nడౌన్‌లోడ్ సిమ్యులేషన్:")
for percent in [25, 50, 75, 100]:
    # \r కర్సర్‌ను లైన్ ప్రారంభానికి తెస్తుంది
    print(f"\rడౌన్‌లోడ్ అవుతోంది: [{percent}%]", end="", flush=True)
print("  ✅ పూర్తి అయ్యింది!")

4 input() ఫంక్షన్ — యూజర్ డేటా సేకరణ & టైప్ సేఫ్టీ

పైథాన్‌లో యూజర్ నుండి కీబోర్డ్ ద్వారా డేటాను స్వీకరించడానికి input() ఫంక్షన్‌ను ఉపయోగిస్తాము.

అలాగే యూజర్ పొరపాటున చివరలో కొట్టే అనవసరమైన ఖాళీలను తొలగించడానికి .strip() వాడటం ప్రొడక్షన్ బెస్ట్ ప్రాక్టీస్:
email = input("ఈమెయిల్ ఎంటర్ చేయండి: ").strip().lower()

5 మల్టిపుల్ ఇన్‌పుట్స్ ఒకే లైన్‌లో తీసుకోవడం (split() & map())

కాంపిటేటివ్ ప్రోగ్రామింగ్ (LeetCode, HackerRank) లేదా ఫాస్ట్ డేటా ఎంట్రీలో యూజర్లు ఒకే లైన్‌లో స్పేస్ ఇచ్చి బహుళ విలువలను టైప్ చేస్తారు (ఉదా: 10 20 30). వీటిని వేర్వేరు వేరియబుల్స్‌లోకి ఎలా విడగొట్టాలో చూద్దాం:

• 1. స్ట్రింగ్స్ కోసం split():
  first_name, last_name = input("మీ పూర్తి పేరు ఇవ్వండి: ").split()
split() డిఫాల్ట్‌గా స్పేస్‌ల ఆధారంగా ముక్కలు చేసి లిస్ట్‌గా ఇస్తుంది.
• 2. సంఖ్యల కోసం map() ఫంక్షన్:
  x, y = map(int, input("రెండు సంఖ్యలు స్పేస్ ఇచ్చి ఎంటర్ చేయండి: ").split())
map(int, ...) ప్రతి ముక్కపై int() ఫంక్షన్‌ను అప్లై చేస్తుంది.
• 3. తెలియని సంఖ్యలో ఇన్‌పుట్స్ ఉన్నప్పుడు (List Unpacking):
  marks = list(map(int, input("మార్కులు ఇవ్వండి: ").split()))

6 కోడ్ డెమో 2: మల్టీ-ఇన్‌పుట్ రీడింగ్ & డేటా శానిటైజేషన్

ఒకే లైన్‌లో బహుళ ఇన్‌పుట్స్‌ను చదవడం, ఖాళీలను శుభ్రం చేయడం మరియు భద్రంగా టైప్ కాస్టింగ్ చేసే విధానాన్ని క్రింది స్క్రిప్ట్‌లో పరిశీలించండి:

# మల్టిపుల్ ఇన్‌పుట్ పద్ధతులు & డేటా క్లీనింగ్ డెమో

# 1. ఒకే లైన్‌లో రెండు పేర్లు తీసుకోవడం
raw_input_data = "  రమేష్    కుమార్  "
first_name, last_name = raw_input_data.split()
print(f"మొదటి పేరు: [{first_name}], ఇంటిపేరు: [{last_name}]")

# 2. ఒకే లైన్‌లో బహుళ సంఖ్యలను చదివి కూడిక చేయడం
numbers_str = "10 25 40 85 100"
# map(int, ...) ద్వారా అన్నింటినీ పూర్ణాంకాలుగా మారుస్తున్నాము
num_list = list(map(int, numbers_str.split()))

print(f"\nస్వీకరించిన సంఖ్యలు: {num_list}")
print(f"మొత్తం సంఖ్యల కూడిక (Sum): {sum(num_list)}")
print(f"గరిష్ట సంఖ్య (Max): {max(num_list)}")
print(f"కనిష్ట సంఖ్య (Min): {min(num_list)}")

# 3. సేఫ్ న్యూమరిక్ ఇన్‌పుట్ ఫంక్షన్ (Exception Handling)
def safe_read_integer(val_str):
    clean_val = val_str.strip()
    if clean_val.isdigit():
        return int(clean_val)
    return 0

test_val = " 4500 "
result = safe_read_integer(test_val)
print(f"\nశానిటైజ్ చేయబడిన పూర్ణాంకం: {result} (Type: {type(result).__name__})")

7 స్ట్రింగ్ ఫార్మాటింగ్ చరిత్ర: % ఆపరేటర్ నుండి str.format() వరకు

పైథాన్‌లో స్ట్రింగ్స్‌లో వేరియబుల్స్‌ను పొందుపరచడానికి కాలక్రమేణా మూడు పద్ధతులు అభివృద్ధి చెందాయి:

8 Modern Python f-strings — సింటాక్స్ & ఎక్స్‌ప్రెషన్ ఇవాల్యుయేషన్

Python 3.6 లో ప్రవేశపెట్టబడిన f-strings (Formatted String Literals) పైథాన్ చరిత్రలోనే అత్యంత ప్రజాదరణ పొందిన ఫీచర్లలో ఒకటి. స్ట్రింగ్ ముందు చిన్న లేదా పెద్ద అక్షరం f లేదా F పెట్టి, కర్లీ బ్రేసెస్ {...} లోపల వేరియబుల్స్ లేదా ఏ పైథాన్ ఎక్స్‌ప్రెషన్‌నైనా నేరుగా ఉంచవచ్చు:

• నేరుగా గణిత లెక్కలు: f"మొత్తం: {price * quantity}"
• ఫంక్షన్ లేదా మెథడ్ కాల్స్: f"స్వాగతం {user_name.strip().title()} గారూ!"
• కండిషనల్ ఆపరేటర్లు (Ternary): f"స్థితి: {'యాక్టివ్' if is_active else 'బ్లాక్ చేయబడింది'}"
• పైథాన్ 3.8+ డీబగ్గింగ్ మ్యాజిక్ (f"{var=}"): డీబగ్గింగ్ కోసం వేరియబుల్ పేరు మరియు దాని విలువ రెండింటినీ ఆటోమేటిక్‌గా ప్రింట్ చేస్తుంది!
  x = 42; print(f"{x=}") అవుట్‌పుట్: x=42.

9 f-strings ఫార్మాట్ స్పెసిఫైయర్స్ — నంబర్స్, అలైన్‌మెంట్, ప్యాడింగ్ & కరెన్సీ

కర్లీ బ్రేసెస్ లోపల వేరియబుల్ పక్కన కోలన్ : పెట్టి ఫార్మాటింగ్ నియమాలను (Format Specifiers) నిర్దేశించవచ్చు:

10 కోడ్ డెమో 3: f-strings ఫార్మాటింగ్ మాస్టరీ & ప్రొఫెషనల్ టేబుల్

అలైన్‌మెంట్, డెసిమల్ ప్రెసిషన్ మరియు కామా సెపరేటర్లు వాడి అందమైన బిజినెస్ రిపోర్ట్ టేబుల్‌ను ఎలా తయారుచేయాలో క్రింది కోడ్ ద్వారా చూద్దాం:

# ప్రొఫెషనల్ f-strings ఫార్మాటింగ్ & టేబుల్ జనరేషన్ డెమో

products = [
    ("సోనీ హెడ్‌ఫోన్స్", 2, 4999.00),
    ("లాజిటెక్ వైర్‌లెస్ మౌస్", 5, 849.50),
    ("శామ్‌సంగ్ 4K మానిటర్", 1, 28990.00),
    ("మెకానికల్ కీబోర్డ్", 3, 3450.00)
]

print("=" * 66)
print(f"{'వస్తువు పేరు':<24} {'పరిమాణం':^10} {'ధర (₹)':>12} {'మొత్తం (₹)':>16}")
print("=" * 66)

grand_total = 0.0

for title, qty, price in products:
    total = qty * price
    grand_total += total
    # అలైన్‌మెంట్ మరియు నంబర్ ఫార్మాటింగ్
    print(f"{title:<22} {qty:^10} {price:>12,.2f} {total:>16,.2f}")

print("-" * 66)
print(f"{'మొత్తం చెల్లించవలసిన మొత్తం:':<44} {grand_total:>20,.2f}")
print("=" * 66)

# Python 3.8+ Debugging syntax demo
status = "SUCCESS"
latency_ms = 14.825
print(f"\nడెబగ్ అవుట్‌పుట్: {status=} | {latency_ms=:.2f}ms")

11 Competitive Programming Fast I/O — sys.stdin.readline vs input()

మీరు CodeChef, LeetCode, Codeforces వంటి ప్లాట్‌ఫామ్‌లలో కోడింగ్ చేస్తున్నప్పుడు పెద్ద సంఖ్యలో టెస్ట్ కేసులు (ఉదా: $10^5$ లేదా $10^6$ లైన్లు) ఉన్నప్పుడు సాధారణ input() వాడితే TLE (Time Limit Exceeded) ఎర్రర్ వస్తుంది!

దీనికి కారణం: input() ఫంక్షన్ ప్రతి లైన్ రీడ్ చేయడానికి ముందు ప్రాంప్ట్ చెక్ చేయడం, చివర ఉన్న న్యూలైన్ \n ను తొలగించడం వంటి అంతర్గత ఓవర్‌హెడ్‌ను కలిగి ఉంటుంది.

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

• Mistake 1: f-strings లో బ్యాక్‌స్లాష్ (\) వాడటం: Python 3.11 వరకు f"{'\n'.join(items)}" రాస్తే SyntaxError వచ్చేది. (Python 3.12 లో PEP 701 ద్వారా దీనిని సడలించారు). అయినప్పటికీ బ్యాక్‌స్లాష్ ఉండే ఎక్స్‌ప్రెషన్‌లను ముందుగానే వేరియబుల్‌లో సేవ్ చేసి f-string లో పెట్టడం మంచిది.
• Mistake 2: int(input()) లో నేకెడ్ క్రాష్‌లు: యూజర్ సంఖ్యకు బదులుగా అక్షరాలు కొట్టినప్పుడు ప్రోగ్రామ్ క్రాష్ అవ్వకుండా ఎల్లప్పుడూ try...except ValueError హ్యాండ్లింగ్ ఉండాలి.
• Mistake 3: లూప్‌లలో flush=True మర్చిపోవడం: ఎక్కువ సమయం పట్టే లాంగ్ టాస్కులలో end='' పెట్టి flush=True ఇవ్వకపోతే, ప్రోగ్రామ్ మొత్తం పూర్తయ్యే వరకు స్క్రీన్‌పై ఏమీ కనిపించదు.
• Mistake 4: str.format() లో ఇండెక్స్ మిస్‌మ్యాచ్: "{0} {1} {2}".format(x, y) అని రాస్తే IndexError: Replacement index 2 out of range వస్తుంది. ఆధునిక కోడ్‌లో ఎల్లప్పుడూ f-strings వాడండి.

13 రియల్-వరల్డ్ ప్రాజెక్ట్: "Bank ATM Mini-Statement & Dynamic Passbook Printer"

ఈ నాల్గవ అధ్యాయంలో నేర్చుకున్న అన్ని కాన్సెప్ట్‌లను (కస్టమ్ సెపరేటర్లు, లైవ్ ప్రోగ్రెస్ ఎఫెక్ట్స్, f-strings అలైన్‌మెంట్, ప్యాడింగ్, వేల స్థానాల్లో కామాలు, కరెన్సీ రౌండింగ్) కలగలిపి — ఒక పూర్తి స్థాయి Bank ATM Mini-Statement & Passbook Printer ప్రాజెక్ట్‌ను నిర్మిద్దాం!

# =====================================================================
# చాప్టర్ 04 మినీ ప్రాజెక్ట్: Bank ATM Mini-Statement & Passbook Engine
# కాన్సెప్ట్స్: f-strings Alignment, Currency Formatting, Zero-Padding,
#             Multi-column Ledger, Date Stamps & Account Masking
# =====================================================================

def print_atm_mini_statement(account_holder: str, acc_number: str, raw_transactions: list):
    """
    ఖాతాదారుని వివరాలు మరియు లావాదేవీలను స్వీకరించి అందమైన ATM రసీదును ముద్రిస్తుంది.
    """
    masked_acc = "XXXX-XXXX-" + acc_number[-4:] # చివరి 4 అంకెలు మాత్రమే
    header_title = "మన బ్యాంక్ ఆఫ్ ఇండియా — ATM డిజిటల్ పాస్‌బుక్"

    print("\n" + "=" * 68)
    print(f"{header_title:^68}")
    print("=" * 68)
    print(f"ఖాతాదారుని పేరు : {account_holder:<28} తేదీ : 2026-11-02")
    print(f"ఖాతా నంబరు      : {masked_acc:<28} సమయం : 10:30:15 AM")
    print("-" * 68)
    print(f"{'Txn ID':<10} {'వివరణ':<22} {'రకం':^8} {'మొత్తం (₹)':>12} {'నిల్వ (₹)':>12}")
    print("-" * 68)

    running_balance = 50000.00 # ప్రారంభ నిల్వ (Opening Balance)

    for txn_id, desc, txn_type, amount in raw_transactions:
        if txn_type == "CR": # Credit (జమ)
            running_balance += amount
            type_label = "[+CR]"
        else: # Debit (ఖర్చు)
            running_balance -= amount
            type_label = "[-DR]"

        formatted_id = f"TXN{txn_id:04d}"
        print(f"{formatted_id:<10} {desc:<20} {type_label:^8} {amount:>12,.2f} {running_balance:>12,.2f}")

    print("=" * 68)
    print(f"{'తుది ఖాతా నిల్వ (Available Balance):':<42} ₹ {running_balance:>20,.2f}")
    print("=" * 68)
    print(f"{'మన బ్యాంక్ ఎంచుకున్నందుకు ధన్యవాదాలు! భద్రంగా ఉండండి.':^68}")
    print("=" * 68 + "\n")

# లైవ్ రన్ డెమో
sample_txns = [
    (1, "జీతం డిపాజిట్", "CR", 45000.00),
    (2, "ఫ్లిప్‌కార్ట్ షాపింగ్", "DR", 4599.50),
    (3, "కరెంట్ బిల్లు చెల్లింపు", "DR", 1250.00),
    (4, "UPI ద్వారా స్నేహితుని జమ", "CR", 2000.00),
    (5, "పెట్రోల్ బంక్ ఖర్చు", "DR", 500.00)
]

print_atm_mini_statement("బాలాజీ రావు", "987654321098", sample_txns)

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