## 🗂️ 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! 💾
---
::: grid
::: card 5.1 | Introduction | Why programs need files — temporary RAM vs permanent disk storage | Persistence, Storage
::: card 5.2 | Data Files | Text files vs Binary files — what's the difference? | Text, Binary, ASCII
::: card 5.3 | Open & Close | The open() and close() functions — the lifecycle of a file | open(), close(), modes
::: card 5.4 | Text File Operations | read, readline, readlines, write, writelines, flush, seek, tell | All text file methods
::: card 5.5 | Standard Streams | stdin, stdout, stderr — the three invisible data channels | sys module, redirection
:::
---
## 🌟 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.
> [!NOTE]
> **Memory Trick:** Think of **RAM as a whiteboard** in your classroom — easy to write on, but erased at the end of class. Think of **Files as your notebook** — permanent, portable, always there when you need it! 📓
### 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
> [!IMPORTANT]
> **Board Exam Hotspot:** CBSE loves asking — *"Differentiate between text and binary files."* Key differences:
> - Text files store data as **characters**; binary files store data as **bytes**
> - Text files are **human-readable**; binary files are **not**
> - Text files use `\n` as **line separator**; binary files have no such concept
> - Text files may undergo **newline translation** by the OS; binary files are read/written **as-is**
---
## 📂 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.
> [!RULE]
> **Syntax:**
> ```
> file_object = open(filename, mode)
> ```
> - **`filename`** → Name (or full path) of the file as a **string**
> - **`mode`** → A string specifying *how* you want to open the file
> - Returns a **file object** for performing read/write operations
---
### 🎭 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+")`
> [!WARNING]
> **Common Mistake:** The difference between `'w'` and `'a'` trips up almost every student! Use `'w'` only when you want to **start fresh** (it erases everything!). Use `'a'` when you want to **add new content** to an existing file without losing old data. 🚨
> [!TIP]
> **Study Strategy:** Use this rhyme to remember:
> - **`r`** = **R**ead what's there (file must exist!)
> - **`w`** = **W**ipe clean, then Write (dangerous — erases!)
> - **`a`** = **A**dd to the end (always safe!)
---
### 🗺️ The File Lifecycle — Open → Use → Close
```mermaid
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
> [!RULE]
> **Syntax:**
> ```
> file_object.close()
> ```
```python
# Standard open → use → close pattern
f = open("story.txt", "r")
content = f.read()
print(content)
f.close() # 🔒 Always close!
```
```python
# 🌟 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
```
> [!IMPORTANT]
> **Board Exam Hotspot:** The `with` statement is increasingly appearing in CBSE sample papers. It's the **preferred, professional way** to handle files because it guarantees the file is closed even if an exception occurs inside the block. The `as f` part gives the file object the name `f`.
---
## 📖 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 has its own superpower!
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
```python
# ── 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!
```
```python
# ── 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()
```
```python
# ── 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()
```
```python
# ── 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()
```
```python
# ── 🌟 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()
```
> [!IMPORTANT]
> **Board Exam Hotspot — The Classic Comparison Question:**
> | Method | Returns | Reads |
> |--------|---------|-------|
> | `read()` | One **string** | Entire file |
> | `read(n)` | One **string** | `n` characters |
> | `readline()` | One **string** | One line |
> | `readlines()` | A **list** of strings | All lines |
> [!WARNING]
> **Common Mistake:** When printing lines from a file, each line already ends with `\n`. Using `print(line)` adds another `\n` (since `print` itself adds one), resulting in **double spacing**. Fix this with `print(line, end="")` or `print(line.strip())`.
---
### ✍️ 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**
```python
# ── 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
```
```python
# ── 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
```
```python
# ── 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
```
> [!WARNING]
> **Common Mistake — Top Exam Trap!** `writelines()` does NOT add newlines! If you forget `\n`, all content gets jammed onto one line:
> ```python
> # ❌ 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
> ```
> [!IMPORTANT]
> **Board Exam Hotspot:** `write()` vs `writelines()` difference table:
> | Feature | `write()` | `writelines()` |
> |---------|-----------|---------------|
> | Argument | Single **string** | **List** of strings |
> | Returns | **Integer** (char count) | **None** |
> | Newline | Must add `\n` manually | Must add `\n` in each string |
---
### 💧 5.4.3 The `flush()` Function
Here's a secret Python doesn't tell 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**.
> [!RULE]
> **Syntax:**
> ```
> file_object.flush()
> ```
> Immediately empties the write buffer to disk. The file stays open for further operations.
```python
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
```
> [!TIP]
> **Study Strategy:** Think of `flush()` like pressing **Ctrl+S** while writing an important document. Without it, your data lives in the buffer (unsaved). With it, it's safely written to disk. Always use `flush()` in logging or real-time monitoring programs! 💾
> [!NOTE]
> **Memory Trick:** **`flush()`** = **F**orce **L**ose the buffer **U**RGENTLY, **S**ave to disk **H**ere! 🚿
> Just like flushing a toilet pushes everything out immediately — `flush()` pushes all buffered data out to the file right now!
---
### 🧹 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!
```python
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')`
```python
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
```
```python
# 🧪 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'] ✅
```
> [!WARNING]
> **Common Mistake — Sneaky Bug in Comparisons!**
> ```python
> 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()
> ```
> This is one of the **most common bugs** in student programs. Always strip before comparing!
> [!TIP]
> **Study Strategy:** Make stripping a **habit**. Whenever you read from a file, immediately chain `.strip()`:
> ```python
> 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?"
> [!RULE]
> **Syntax:**
> ```
> position = file_object.tell()
> ```
> Returns the **current byte position** of the file pointer as an integer.
```python
# 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!"
> [!RULE]
> **Syntax:**
> ```
> file_object.seek(offset, from_where)
> ```
> - **`offset`** → Number of bytes to move (can be 0 or positive)
> - **`from_where`** → The starting reference point:
> - **`0`** → From the **beginning** of the file (default)
> - **`1`** → From the **current** position
> - **`2`** → From the **end** of the file
> - In **text mode**, only `seek(0)` and `seek(n, 0)` (from beginning) are reliably supported
```python
# 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()
```
```python
# 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()
```
> [!NOTE]
> **Memory Trick:**
> - **`tell()`** = "Tell me where you are right now!" 🗣️
> - **`seek()`** = "Seek (go to) this position!" 🔍
> Together they're like **GPS for your file** — you can always know your position and jump anywhere! 🗺️
> [!IMPORTANT]
> **Board Exam Hotspot:** For text files in Python:
> - `seek(0)` → Go to **beginning** ✅ (fully supported)
> - `seek(n, 0)` → Go to **byte n from start** ✅ (supported)
> - `seek(n, 1)` or `seek(n, 2)` → **Not reliably supported in text mode** ⚠️
>
> For full random access using `seek(n, 1)` and `seek(n, 2)`, you need **binary mode** (`'rb'`).
---
### 🧭 File Pointer Flow — Visual Guide
```mermaid
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!
```python
# 🏫 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`
```python
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}!")
```
```python
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! ✅")
```
> [!IMPORTANT]
> **Board Exam Hotspot:** The three standard streams are:
> - `sys.stdin` → **Standard input** (keyboard by default)
> - `sys.stdout` → **Standard output** (screen by default)
> - `sys.stderr` → **Standard error** (screen by default — separate from stdout!)
>
> All three can be **redirected** to files for powerful I/O control!
> [!NOTE]
> **Memory Trick:** Think of the three streams like a classroom lecture:
> - `sys.stdin` = **Students asking questions** 🙋 (input coming IN)
> - `sys.stdout` = **Teacher writing on the board** 📝 (output going OUT)
> - `sys.stderr` = **Principal's urgent announcement** 📢 (critical alerts that bypass normal flow!)
---
## 🏆 Chapter Revision — Board Exam Ready!
> [!IMPORTANT]
> **Board Exam Hotspot — Complete Quick Reference:**
>
> | Function | Purpose | Returns |
> |----------|---------|---------|
> | `open(file, mode)` | Open a file | File object |
> | `close()` | Close and save the file | None |
> | `read()` | Read entire file as string | String |
> | `read(n)` | Read next `n` characters | String |
> | `readline()` | Read one line (with `\n`) | String |
> | `readlines()` | Read all lines | List of strings |
> | `write(s)` | Write string `s` to file | Int (char count) |
> | `writelines(L)` | Write list `L` of strings | None |
> | `flush()` | Force buffer to disk immediately | None |
> | `tell()` | Get current pointer position | Integer (bytes) |
> | `seek(n)` | Move pointer to byte `n` | None |
> | `strip()` | Remove whitespace both ends | String |
> | `rstrip()` | Remove right-side whitespace | String |
> | `lstrip()` | Remove left-side whitespace | String |
> [!TIP]
> **Study Strategy — 6 Most Common CBSE Questions:**
> 1. 🖊️ "Difference between `read()`, `readline()`, `readlines()`"
> 2. 🖊️ "Difference between `'w'` and `'a'` file opening mode"
> 3. 🖊️ "Write a program to count lines / words / characters in a file"
> 4. 🖊️ "Write a program to copy content of one file to another"
> 5. 🖊️ "Explain `seek()` and `tell()` with an example"
> 6. 🖊️ "What is `flush()`? When and why is it used?"
---
### 🧩 CBSE Practice Programs
```python
# ✏️ 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}")
```
```python
# ✏️ 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! ✅")
```
```python
# ✏️ 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")
```
```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()
```
```python
# ✏️ 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()
```
> [!WARNING]
> **Common Mistake — Top 5 File Handling Traps in Exams:**
> 1. ❌ Forgetting `f.close()` — always close your files!
> 2. ❌ Using `'w'` instead of `'a'` — accidentally erasing all existing data
> 3. ❌ Not adding `\n` in `write()` or `writelines()` — everything on one line
> 4. ❌ Not using `.strip()` when comparing file content to strings
> 5. ❌ Opening a non-existent file in `'r'` mode without a try-except block
Back to List
Calculating...