🗂️ File Handling in Python (Text File)

🗂️ Give Your Program a Permanent Memory!

Imagine writing brilliant answers in your head during an exam — and forgetting everything the moment you step out! That's exactly what happens to Python variables when a program ends. Files are your program's permanent memory — data that survives power cuts, reboots, and program crashes!

🌟 5.1 Introduction — Why Do We Need Files?

Every time your Python program runs, it creates variables, lists, dictionaries — all stored in RAM (Random Access Memory). RAM is fast but temporary. The instant your program ends:

ALL DATA IS GONE. 💨

This is a massive problem for real-world applications. Imagine:

• A school management system that forgets all student names every evening 😱
• A game that resets your score every time you restart 🎮
• A bank that loses all account balances after closing time 💸

Files solve this problem! They store data permanently on the hard disk (secondary storage), which keeps data even without power.

What Can Files Do for Us?

• 💾 Persist data — Save program output for future use
• 📖 Read stored data — Load previously saved information
• 🔄 Share data — One program writes, another reads
• 📊 Handle huge data — Process data too large to fit in RAM (databases, logs, etc.)

🗂️ 5.2 Data Files — Two Flavours!

Python supports two main types of data files. Choosing the right type matters!

• 📄 Text Files

  • Stores data as human-readable characters (ASCII or Unicode encoding)
  • Each line is separated by a newline character \n (Python adds/reads this automatically)
  • Can be opened and read in Notepad, VS Code, any text editor
  • Common extensions: .txt, .csv, .py, .html, .json
  • Example: Your Python source code .py file is itself a text file!

• 🔒 Binary Files

  • Stores data as raw bytes — exactly as it exists in RAM
  • Not human-readable; opening in Notepad shows garbage characters
  • No special newline handling — data is read/written byte by byte
  • Common extensions: .jpg, .mp3, .exe, .pkl, .db
  • Example: A .jpg photo, an .mp3 song, a compiled .exe program

📂 5.3 Opening and Closing Files

🔑 The open() Function — Your Master Key!

Before you can do anything with a file — reading, writing, appending — you must first open it using Python's built-in open() function. It returns a file object (also called a file handle) that you use for all subsequent operations.

file_object = open(filename, mode)

🎭 5.3.1 Opening Files — File Modes Explained

The mode parameter is the most important argument to open(). It tells Python whether you want to read, write, or append — and whether to create a new file or use an existing one.

• 'r' — Read Mode (Default) 📖

  • Opens file for reading only — cannot write
  • File must already exist — raises FileNotFoundError if not found
  • File pointer is placed at the beginning of the file
  • Example: f = open("notes.txt", "r")

• 'w' — Write Mode (Dangerous!) ✍️

  • Opens file for writing only — cannot read
  • Creates a new file if it doesn't exist
  • ⚠️ DESTROYS existing content if the file already exists — no warning!
  • File pointer placed at the beginning (of the now-empty file)
  • Example: f = open("output.txt", "w")

• 'a' — Append Mode (Safe Writing) ➕

  • Opens file for writing at the end — adds new content after existing content
  • Creates a new file if it doesn't exist
  • Preserves existing content — safe for adding new records
  • File pointer placed at the end of the file
  • Example: f = open("diary.txt", "a")

• 'r+' — Read + Write Mode 🔀

  • Opens file for both reading AND writing
  • File must already exist — raises FileNotFoundError if not
  • File pointer placed at the beginning — can overwrite existing content
  • Example: f = open("data.txt", "r+")

• 'w+' — Write + Read Mode 🆕

  • Opens file for both reading AND writing
  • Creates file if not found; overwrites content if file exists
  • Example: f = open("data.txt", "w+")

• 'a+' — Append + Read Mode 📎

  • Opens file for both reading AND appending
  • Creates file if not found; preserves existing content
  • Write pointer always at end; can seek to read from anywhere
  • Example: f = open("log.txt", "a+")

🗺️ The File Lifecycle — Open → Use → Close

flowchart TD
    A["🚀 START\nProgram needs file access"]
    B["open(filename, mode)\nSpecify what and how"]
    C["File Object Created ✅\nPointer positioned at start/end"]
    D["Perform Operations\nread() / write() / append()"]
    E["close()\nFlush buffer & release file"]
    F["🏁 END\nData safely saved to disk"]
    ERR["⚠️ FileNotFoundError!\nHandle with try-except"]

    A --> B
    B -->|"File found /\nFile created"| C
    B -->|"File missing\n(in r / r+ mode)"| ERR
    C --> D
    D --> E
    E --> F
    ERR -->|"Fix path or\ncreate file first"| A

    classDef normalNode fill:none;
    classDef tryNode fill:none;
    classDef exceptNode fill:none;
    classDef elseNode fill:none;

    class A normalNode;
    class B normalNode;
    class C elseNode;
    class D tryNode;
    class E normalNode;
    class F normalNode;
    class ERR exceptNode;

🔒 5.3.2 Closing Files — close()

After all file operations, always close the file! Leaving a file open is like leaving your exam paper on the desk without submitting it. Closing ensures:

• ✅ All buffered data is flushed (written) to the actual disk file
• ✅ The file is released — other programs or users can now access it
• ✅ System resources (file handles) are freed — important in large programs
• ✅ Data integrity is maintained — no corruption from abrupt termination

file_object.close()

# Standard open → use → close pattern
f = open("story.txt", "r")
content = f.read()
print(content)
f.close()      # 🔒 Always close!

# 🌟 BEST PRACTICE — The 'with' Statement (Context Manager)
# Automatically closes the file, even if an error occurs inside!
with open("story.txt", "r") as f:
    content = f.read()
    print(content)
# File is automatically closed here — no f.close() needed!
print("File is now closed:", f.closed)   # True

📖 5.4 Working with Text Files

Now the real fun begins! 🎉 Let's explore all the operations you can perform on text files.

🔍 5.4.1 Reading from Text Files

Python gives you three distinct methods to read from a text file. Each suits a different situation.

Assume our file poem.txt contains:

Roses are red,
Violets are blue,
Python is awesome,
And so are you!

• read() — Devour the Entire File at Once 📜

  • f.read() → Reads the complete file content as a single string
  • f.read(n) → Reads exactly n characters from current position
  • Returns an empty string "" when the end of file is reached
  • ⚠️ Careful with very large files — loads everything into RAM!

• readline() — One Line at a Time 📃

  • Reads and returns one line, including its \n at the end
  • Returns an empty string "" when end of file is reached (not None!)
  • Memory efficient — great for processing huge files line by line
  • Each call automatically advances the pointer to the next line

• readlines() — All Lines as a Python List 📋

  • Returns a list of strings — each element is one complete line
  • Each string in the list includes its \n character
  • Access specific lines by index: lines[0], lines[2], etc.
  • Great when you need random access to specific line numbers

# ── Method 1: read() ──────────────────────────────────
f = open("poem.txt", "r")
content = f.read()          # One big string
print(content)
f.close()
# Output:
# Roses are red,
# Violets are blue,
# Python is awesome,
# And so are you!

# ── Method 1b: read(n) — Read only n characters ───────
f = open("poem.txt", "r")
first5 = f.read(5)          # Read first 5 chars
print(repr(first5))         # 'Roses'
next5 = f.read(5)           # Read next 5 chars
print(repr(next5))          # ' are '
f.close()

# ── Method 2: readline() — One line at a time ─────────
f = open("poem.txt", "r")
line1 = f.readline()
line2 = f.readline()
print(repr(line1))   # 'Roses are red,\n'
print(repr(line2))   # 'Violets are blue,\n'
f.close()

# ── Method 3: readlines() — Full list ─────────────────
f = open("poem.txt", "r")
all_lines = f.readlines()
print(all_lines)
# ['Roses are red,\n', 'Violets are blue,\n',
#  'Python is awesome,\n', 'And so are you!']
print("Line 3:", all_lines[2].strip())   # Python is awesome,
f.close()

# ── 🌟 GOLD METHOD: Loop directly over file ────────────
# Most Pythonic! Memory efficient. No need for readlines()
f = open("poem.txt", "r")
for line in f:
    print(line, end="")    # end="" prevents double newline
f.close()

✍️ 5.4.2 Writing onto Text Files

Two methods for writing content into text files:

• write(string) — Write a Single String ✏️

  • Takes exactly one string argument
  • Does NOT add newline automatically — you must include \n yourself!
  • Returns an integer — the number of characters written
  • Writes from the current file pointer position

• writelines(list) — Write a Sequence of Strings 📝

  • Accepts a list (or any iterable) of strings
  • Writes all strings one after another — no separators added!
  • Does NOT add newlines between items — include \n in each string!
  • Returns None

# ── write() — Manual newlines ─────────────────────────
f = open("results.txt", "w")
f.write("Class 12 Computer Science\n")
f.write("Chapter 6: File Handling\n")
chars = f.write("Topic: Writing to Files")   # No \n at end
print("Characters written:", chars)          # 23
f.close()
# File content:
# Class 12 Computer Science
# Chapter 6: File Handling
# Topic: Writing to Files

# ── writelines() — Write a list ───────────────────────
f = open("students.txt", "w")
students = [
    "Aman Sharma\n",      # \n included in each string!
    "Priya Singh\n",
    "Rohan Gupta\n",
    "Sneha Joshi\n"
]
f.writelines(students)
f.close()
# File content:
# Aman Sharma
# Priya Singh
# Rohan Gupta
# Sneha Joshi

# ── Append Mode — Adding without losing data ──────────
f = open("students.txt", "a")     # 'a' = safe append!
f.write("Kavya Reddy\n")          # Added at the END
f.write("Arjun Mehta\n")
f.close()
# Existing names preserved; two new names added at bottom

# ❌ WRONG — Everything on one line!
f.writelines(["Math", "Physics", "CS"])
# File: MathPhysicsCS  ← disaster!

# ✅ CORRECT — Each item on its own line
f.writelines(["Math\n", "Physics\n", "CS\n"])
# File:
# Math
# Physics
# CS

💧 5.4.3 The flush() Function

Here is something that surprises many beginners:

Python does NOT write to disk immediately! Instead, it uses an invisible I/O Buffer — a small chunk of RAM that collects data before writing it all to disk in one go. This is much faster (fewer disk operations), but there's a risk:

If the program crashes before the buffer is flushed, the data is lost forever! 💀

flush() forces Python to immediately write all buffered data to the actual disk file — without closing it.

file_object.flush()

import time

# Simulating a log writer / server
f = open("server_log.txt", "w")

f.write("🟢 Server started at 09:00\n")
f.flush()    # ← Written to disk RIGHT NOW
# Even if the program crashes after this line,
# this log entry is safely saved!

print("Waiting for requests...")
time.sleep(3)

f.write("📥 Request received from 192.168.1.5\n")
f.flush()    # ← Saved immediately again!

f.write("✅ Request processed successfully\n")
# No flush here — this might be lost if crash happens now

f.close()    # close() always flushes automatically

🧹 5.4.4 Removing Whitespaces After Reading from File

When you read lines from a file, each line carries unwanted baggage — especially the trailing newline character \n. This invisible character causes nasty bugs when you compare strings or display data!

f = open("names.txt", "r")
line = f.readline()
print(line)          # Aman
                     # ← Extra blank line! Because line = "Aman\n"
                     #   and print() adds another \n
print(repr(line))    # 'Aman\n'  ← See the hidden \n!
f.close()

Python's three strip methods to the rescue:

• ✂️ strip() — Removes whitespace (\n, spaces, tabs) from BOTH ends

  • Most thorough — cleans both left and right sides
  • Use when you don't care about leading spaces either

• ✂️ lstrip() — Removes whitespace from the LEFT side only

  • Removes leading spaces/tabs/newlines

• ✂️ rstrip() — Removes whitespace from the RIGHT side only

  • Most common for file reading — removes trailing \n
  • Can specify exactly what to remove: rstrip('\n')

line = "   Hello World!   \n"

print(repr(line.strip()))    # 'Hello World!'  ← both sides cleaned
print(repr(line.lstrip()))   # 'Hello World!   \n'  ← only left
print(repr(line.rstrip()))   # '   Hello World!'  ← only right (incl. \n)
print(repr(line.rstrip('\n')))  # '   Hello World!   '  ← ONLY \n removed

# 🧪 Real-world example: Read student names cleanly
f = open("students.txt", "r")
students = []
for line in f:
    name = line.strip()     # Remove \n and any extra spaces
    if name:                # Skip blank lines (empty strings are falsy)
        students.append(name)
f.close()
print(students)
# ['Aman Sharma', 'Priya Singh', 'Rohan Gupta', 'Sneha Joshi'] ✅

f = open("data.txt", "r")
for line in f:
    # line = "Python\n" from file

    if line == "Python":      # ❌ ALWAYS FALSE! \n is hiding!
        print("Found!")

    if line.strip() == "Python":   # ✅ CORRECT!
        print("Found!")
f.close()

data = f.readline().strip()      # Read AND strip in one line!
lines = [l.strip() for l in f]   # List comprehension magic!

🗺️ 5.4.5 Significance of File Pointer in File Handling

Imagine you're reading a thick novel 📚. You place a bookmark to remember where you stopped. When you come back, you don't re-read from page 1 — you jump to the bookmark!

Python's file pointer (also called file position indicator) is exactly like that bookmark:

• It's a number representing the current position in the file (measured in bytes from the start)
• It moves automatically as you read or write
• It can be queried with tell()
• It can be moved with seek()

📍 The tell() Function — "Where am I?"

position = file_object.tell()

# File "hello.txt" contains: "Hello World"
#  Positions:                  0123456789A
#  (A = 10)

f = open("hello.txt", "r")
print(f.tell())      # 0  → At the very beginning

f.read(5)            # Read "Hello" → pointer advances 5 bytes
print(f.tell())      # 5  → Now pointing at the space before "World"

f.read(1)            # Read " " (space)
print(f.tell())      # 6  → Now pointing at 'W'

f.read()             # Read "World" (remaining)
print(f.tell())      # 11 → End of file

f.close()

🧭 The seek() Function — "Take me there!"

file_object.seek(offset, from_where)

# File "hello.txt" contains: "Hello World"

f = open("hello.txt", "r")

# Jump to position 6 from beginning
f.seek(6)
print(f.read())       # "World"

# Go back to the very start
f.seek(0)
print(f.read(5))      # "Hello"

# Jump to position 0 again and check
f.seek(0)
print(f.tell())       # 0 → Back to start ✅

f.close()

# Practical Example: Re-reading a file
f = open("scores.txt", "r")

# First pass: Find the highest score
lines = f.readlines()
scores = [int(line.strip()) for line in lines]
print("Max Score:", max(scores))

# Go back to beginning for a second pass!
f.seek(0)

# Second pass: Print all scores
for line in f:
    print("Score:", line.strip())

f.close()

🧭 File Pointer Flow — Visual Guide

flowchart LR
    START["📍 Position: 0\nStart of File"]
    AFTER_READ5["📍 Position: 5\nAfter read(5)"]
    AFTER_LINE["📍 Next line\nAfter readline()"]
    BACK_START["📍 Position: 0\nAfter seek(0)"]
    EOF["📍 End of File\ntell() = file size"]

    START -->|"f.read(5)\nreads 5 chars"| AFTER_READ5
    AFTER_READ5 -->|"f.readline()\nreads rest of line"| AFTER_LINE
    AFTER_LINE -->|"f.seek(0)\njump back!"| BACK_START
    BACK_START -->|"Same as START"| START
    AFTER_LINE -->|"f.read()\nreads everything left"| EOF

    classDef normalNode fill:none;
    classDef elseNode fill:none;
    classDef tryNode fill:none;

    class START normalNode;
    class AFTER_READ5 elseNode;
    class AFTER_LINE elseNode;
    class BACK_START tryNode;
    class EOF normalNode;

🎯 Complete Text File Program — All Concepts Together!

# 🏫 Student Marks Manager — Complete File Handling Demo
# Covers: write, writelines, flush, read, readline, readlines,
#         strip, seek, tell

FILENAME = "marks.txt"

# ── STEP 1: Create the file and write data ────────────
print("=== Step 1: Writing Data ===")
f = open(FILENAME, "w")
f.write("Aman Sharma - 95\n")
f.write("Priya Singh - 88\n")
f.writelines(["Rohan Gupta - 76\n", "Sneha Joshi - 92\n"])
f.flush()    # Force save to disk immediately!
print(f"Data written! Pointer at position: {f.tell()}")
f.close()

# ── STEP 2: Read entire file ──────────────────────────
print("\n=== Step 2: Full File Content ===")
f = open(FILENAME, "r")
content = f.read()
print(content)
f.close()

# ── STEP 3: Read line by line with strip ─────────────
print("\n=== Step 3: Cleaned Lines ===")
f = open(FILENAME, "r")
for line in f:
    clean = line.strip()       # Remove \n
    print(f"  > {clean}")
f.close()

# ── STEP 4: seek() and tell() demo ───────────────────
print("\n=== Step 4: Pointer Navigation ===")
f = open(FILENAME, "r")
print(f"Start position: {f.tell()}")     # 0
first_line = f.readline().strip()
print(f"After readline: position = {f.tell()}")
print(f"First student: {first_line}")

f.seek(0)    # Go back to beginning!
print(f"After seek(0): position = {f.tell()}")  # 0 again

all_lines = f.readlines()
print(f"Total students: {len(all_lines)}")
print(f"Third student: {all_lines[2].strip()}")
f.close()

# ── STEP 5: Append new record ─────────────────────────
print("\n=== Step 5: Adding New Student ===")
f = open(FILENAME, "a")         # Safe append!
f.write("Kavya Reddy - 98\n")
f.close()
print("New student added! ✅")

📡 5.5 Standard Input, Output and Error Streams

Every Python program has three data channels automatically available — even before you open a single file. These are called Standard Streams, and they're accessible through the sys module.

• 🎤 sys.stdin — Standard Input Stream

  • By default, reads from the keyboard
  • The input() function is just a convenient wrapper around sys.stdin
  • Can be redirected to read from a file instead of keyboard!

• 🖥️ sys.stdout — Standard Output Stream

  • By default, writes to the console/screen
  • The print() function internally uses sys.stdout
  • Can be redirected to write to a file instead of screen!

• 🚨 sys.stderr — Standard Error Stream

  • By default, writes error/warning messages to the screen
  • Separate from stdout — even if stdout is redirected, errors still appear on screen
  • Python's own error messages (tracebacks) go to stderr

import sys

# Direct usage of standard streams
sys.stdout.write("Hello from stdout!\n")     # Same as print()
sys.stderr.write("⚠️ Warning: Low memory!\n")  # Error channel

# Reading from stdin (same as input())
sys.stdout.write("Enter your name: ")
name = sys.stdin.readline().strip()
print(f"Hello, {name}!")

import sys

# 🌟 Stream Redirection — Powerful Technique!
print("This goes to SCREEN (normal)")

# Redirect stdout to a file
original_stdout = sys.stdout      # Save the original
log_file = open("output_log.txt", "w")
sys.stdout = log_file             # All print() now goes to file!

print("This line goes to the FILE, not screen! 📁")
print("Magic of stream redirection! 🎩")

sys.stdout = original_stdout      # Restore normal output
log_file.close()

print("We're back on SCREEN! ✅")

f = open("poem.txt", "r")
print(f.read(5))
print(f.tell())
print(f.readline(), end="")
print(len(f.readlines()))
f.close()

Roses
5
 are red,
1

🏆 Chapter Revision

🧩 CBSE Practice Programs

# ✏️ Program 1: Count Lines, Words & Characters in a File
f = open("essay.txt", "r")
lines = words = chars = 0
for line in f:
    lines += 1
    words += len(line.split())
    chars += len(line)
f.close()
print(f"Lines : {lines}")
print(f"Words : {words}")
print(f"Chars : {chars}")

# ✏️ Program 2: Copy One File to Another
src = open("source.txt", "r")
dst = open("destination.txt", "w")
for line in src:
    dst.write(line)
src.close()
dst.close()
print("File copied successfully! ✅")

# ✏️ Program 3: Search for a Keyword in a File
def search_keyword(filename, keyword):
    try:
        f = open(filename, "r")
        count = 0
        line_no = 0
        for line in f:
            line_no += 1
            if keyword.lower() in line.lower():
                print(f"Line {line_no}: {line.rstrip()}")
                count += 1
        f.close()
        print(f"\n'{keyword}' found in {count} line(s).")
    except FileNotFoundError:
        print(f"Error: '{filename}' not found!")

search_keyword("notes.txt", "Python")

# ✏️ Program 4: Display Lines Starting with a Vowel (CBSE Favourite!)
f = open("words.txt", "r")
vowels = "AEIOUaeiou"
for line in f:
    line = line.strip()
    if line and line[0] in vowels:     # Check first character
        print(line)
f.close()

# ✏️ Program 5: Using seek() to Read File Twice
f = open("data.txt", "r")

# First read
print("=== First Read ===")
print(f.read())

# Use seek(0) to go back to beginning!
f.seek(0)

# Second read
print("=== Second Read (after seek) ===")
for line in f:
    print(line.rstrip())

f.close()