Differentiate between: a) text file and binary file b) readline() and readlines() c) write() and writelines()

Exercises · Q1

Q. Differentiate between:

a) text file and binary file

b) readline() and readlines()

c) write() and writelines()

Uttar Pradesh UpmspTextbookSubjective· 3mImportance★★★★★

23% · 5/22 Questions

✓ Free question

Concept understanding — File Handling Methods

File Handling Methods: A First Look

Think about the last time you saved a document on your computer. You clicked "Save," gave it a name, and later opened it again to continue working. That simple act—storing information so you can retrieve it later—is the entire reason file handling exists. Every time you work with a file, whether it's a Word document, a PDF, or even a photo, you are performing file handling.

At its core, file handling is the process of creating, reading, updating, and deleting files through a computer program. It is how a program talks to the storage on your machine—the hard drive or SSD—rather than just working with data that disappears when you close the program.

The Two Fundamental Modes

When a program wants to work with a file, it must first open that file. Opening a file is like unlocking a drawer: you decide what you want to do with it before you start. There are two basic intentions:

Reading – You want to look at the contents of the file without changing anything. The file stays exactly as it is.
Writing – You want to put new content into the file, either by starting fresh (overwriting everything) or by adding to what is already there (appending).

These two intentions define the mode in which you open the file. A file opened for reading cannot be written to, and a file opened for writing cannot be read from—at least not in the simplest approach. This separation exists to prevent accidents: you do not want a program that is supposed to only display your data to accidentally erase it.

Note

In many programming languages, you can open a file in "read and write" mode, but that is a more advanced technique. For a beginner, think of reading and writing as two separate keys that open different locks on the same drawer.

The Lifecycle of a File Operation

Every file handling operation follows a fixed sequence. You cannot skip a step without causing trouble.

Open the file – You tell the program which file you want and what you intend to do with it (read or write). The program checks whether the file exists (for reading) or whether it can create a new one (for writing).
Perform the operation – You either read the data from the file into your program's memory, or you write data from your program into the file. This step can happen many times—you might read one line, then another, then another.
Close the file – You tell the program you are done. This step is crucial. Closing a file saves any changes you made and frees up the file so other programs can use it.

Important

Forgetting to close a file is like leaving a tap running. The file may remain locked, data might not be saved properly, and your program could waste memory. Always close what you open.

Why This Matters for a Commerce or Humanities Student

You might wonder why a student of commerce or humanities needs to understand file handling. The answer is simple: almost every modern business, government office, and research project deals with data stored in files.

A commerce student analyzing sales records will need to read data from a spreadsheet file, process it, and write the results to a new file.
A humanities student working with historical documents might need to read text files containing old letters, clean up the formatting, and save the cleaned version.
Anyone managing a database or a website will encounter file handling when uploading images, generating reports, or backing up information.

File handling is not about writing complex code. It is about understanding how information moves between permanent storage (your hard drive) and temporary memory (your program). Once you grasp that flow, you can work with any kind of data—numbers, text, images, or audio—because the principles are the same.

Common File Operations at a Glance

Operation	What It Does	When You Use It
Open	Prepares the file for reading or writing	Before any other operation
Read	Copies data from the file into the program	When you need to process existing information
Write	Copies data from the program into the file	When you need to save new information
Append	Adds data to the end of an existing file	When you want to add to a log or record without erasing old data
Close	Ends the connection to the file	After you finish reading or writing

A Simple Mental Model

Imagine a notebook on your desk. Opening the file is like opening the notebook to a specific page. Reading is like looking at what is already written there. Writing is like adding your own notes. Appending is like writing on the next blank line after the last entry. Closing the file is like shutting the notebook and putting it back in the drawer.

If you leave the notebook open on your desk, someone else might accidentally scribble on it, or you might lose your place. That is why closing is important. If you try to read from a page that has nothing written on it, you get nothing back—that is an empty file. If you try to write on a page that is already full, you either overwrite everything (if you are writing from the start) or you add to the end (if you are appending).

File handling is just that: a structured way of managing the notebook that is your computer's storage. Once you see it that way, the technical details become much easier to understand.

File Handling Methods — Class 12 Computing

This is a plain theory question asking for three separate comparisons. Each part requires a clear, exam-ready distinction with the underlying concept explained first.

(a) Text File vs Binary File

Concept first: The fundamental difference lies in how data is stored and interpreted. A text file stores data as a sequence of characters (each byte represents one character using an encoding like ASCII or UTF-8), while a binary file stores data as raw bytes — the exact sequence of bits as they exist in memory.

Feature	Text File	Binary File
Data representation	Human-readable characters	Raw bytes (0s and 1s)
Line endings	Has line terminators (`\n`, `\r\n`)	No concept of lines
Encoding	Uses character encoding (ASCII, UTF-8)	No encoding — stores data as-is
File extension examples	`.txt`, `.csv`, `.html`	`.dat`, `.bin`, `.jpg`, `.exe`
Read/Write mode in Python	`'r'`, `'w'`, `'a'` (text mode)	`'rb'`, `'wb'`, `'ab'` (binary mode)
Error handling	May raise `UnicodeDecodeError` if binary data is read as text	No encoding errors
Portability	Portable across platforms (with encoding care)	Platform-dependent (endianness, etc.)

Watch out

A common mistake is trying to open a binary file (like an image) in text mode — this will either raise an error or corrupt the data. Always use 'rb' for binary files.

(b) `readline()` vs `readlines()`

Concept first: Both methods read from a file object, but they differ in what they return and how much they read at once.

Feature	`readline()`	`readlines()`
Return type	A single string (one line)	A list of strings (all lines)
Memory usage	Low — reads one line at a time	High — loads entire file into memory
Includes newline `\n`	Yes, the trailing `\n` is included	Yes, each line retains its `\n`
Use case	Processing large files line-by-line	Small files where you need all lines at once
Optional argument	`readline(size)` — reads at most `size` bytes	No size parameter

# Example demonstrating both
with open('data.txt', 'r') as f:
    line = f.readline()      # Reads first line: "Hello\n"
    print(repr(line))        # Output: 'Hello\n'

with open('data.txt', 'r') as f:
    lines = f.readlines()    # Reads all lines: ["Hello\n", "World\n"]
    print(lines)             # Output: ['Hello\n', 'World\n']

Tip

For large files, always prefer readline() in a loop — it processes one line at a time without exhausting memory. readlines() is convenient but dangerous for files larger than available RAM.

(c) `write()` vs `writelines()`

Concept first: Both methods write data to a file, but write() takes a single string, while writelines() takes an iterable of strings (typically a list). Neither method automatically adds newline characters.

Feature	`write()`	`writelines()`
Argument	A single string	An iterable (list, tuple) of strings
Return value	Number of characters written	`None`
Newline handling	Does NOT add `\n` automatically	Does NOT add `\n` automatically
Typical use	Writing one piece of text	Writing multiple lines from a list

# write() example
with open('output.txt', 'w') as f:
    f.write("First line\n")      # Must add \n explicitly
    f.write("Second line\n")

# writelines() example
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open('output.txt', 'w') as f:
    f.writelines(lines)          # Writes all three lines

Watch out

A very common error: students expect writelines() to add newlines automatically. It does not. You must include \n in each string yourself. The name "writelines" is misleading — it writes strings, not lines with newlines.

Important

There is no writeline() (singular) method in Python. Only write() and writelines() exist. If you need to write a single line, use write() with an explicit \n.

✓Final answer

(a) Text files store human-readable characters with encoding, while binary files store raw bytes without encoding. (b) readline() returns one line as a string (memory-efficient for large files), whereas readlines() returns all lines as a list of strings (loads entire file into memory). (c) write() takes a single string and returns the number of characters written, while writelines() takes an iterable of strings and returns None — neither method adds newlines automatically.

This question tests your understanding of Python file handling methods — specifically the differences between file types (text vs binary) and between reading/writing methods (readline() vs readlines(), write() vs writelines()). Each comparison highlights a different aspect: data representation, return type, or argument handling.

This is a plain theory question — three separate comparisons, each requiring a clear conceptual distinction. Let's take them one at a time.

(a) Text file vs Binary file

The fundamental difference lies in how data is stored and interpreted.

A text file stores data as a sequence of characters (human-readable). When you open it, Python decodes the bytes into strings using a character encoding (usually UTF-8). Every character — including newline \n — is treated as a text element. Examples: .txt, .py, .csv, .html.

A binary file stores data as raw bytes — no encoding, no character interpretation. The file contains the exact sequence of bytes as they exist in memory. When you open it, you read and write bytes objects, not strings. Examples: .jpg, .mp3, .exe, .dat.

Watch out

A common mistake is to open a binary file in text mode (or vice versa). Opening a binary file in text mode will corrupt the data because Python will try to decode arbitrary bytes as text, often raising a UnicodeDecodeError. Always use 'b' in the mode string for binary files: open('image.jpg', 'rb').

Feature	Text file	Binary file
Data representation	Characters (strings)	Raw bytes
Open mode	`'r'`, `'w'`, `'a'`	`'rb'`, `'wb'`, `'ab'`
Read/write type	`str`	`bytes`
Encoding	Required (default UTF-8)	Not applicable
Human-readable	Yes	No
Newline handling	`\n` translated per OS	No translation

(b) `readline()` vs `readlines()`

Both methods read from a text file opened in read mode, but they differ in what they return.

readline() reads one line at a time, including the trailing newline character. It returns a single string. If the file is empty or you've reached the end, it returns an empty string ''. You typically use it in a loop when you want to process each line individually without loading the entire file into memory.

with open('data.txt', 'r') as f:
    line = f.readline()
    while line:
        print(line.strip())  # strip() removes the \n
        line = f.readline()

readlines() reads all lines at once and returns a list of strings, where each string is one line (including its newline). This is convenient when you need random access to lines or want to process the entire file quickly, but it loads the whole file into memory — problematic for very large files.

with open('data.txt', 'r') as f:
    lines = f.readlines()
    for i, line in enumerate(lines):
        print(f"Line {i+1}: {line.strip()}")

Tip

For most cases, you can simply iterate over the file object directly: for line in f: — this is memory-efficient like readline() but cleaner in syntax. Use readlines() only when you genuinely need a list (e.g., to index lines or pass to a function expecting a list).

Method	Return type	Reads	Memory usage
`readline()`	Single `str`	One line at a time	Low (one line)
`readlines()`	`list` of `str`	All lines at once	High (entire file)

(c) `write()` vs `writelines()`

Both methods write to a file opened in write or append mode, but they differ in what arguments they accept.

write() takes a single string (or bytes, for binary mode) and writes it to the file. It returns the number of characters written. You must explicitly add newline characters if you want line breaks.

with open('output.txt', 'w') as f:
    f.write("First line\n")
    f.write("Second line\n")

writelines() takes an iterable of strings (typically a list or tuple) and writes each string to the file without adding any separators or newlines. This is a common point of confusion: despite the name, writelines() does not automatically append newlines. You must ensure each string in the iterable already contains the newline character if you want line breaks.

lines = ["First line\n", "Second line\n", "Third line\n"]
with open('output.txt', 'w') as f:
    f.writelines(lines)

Watch out

The most frequent mistake with writelines() is expecting it to add newlines automatically. It does not. If your list elements don't end with \n, everything will be written on one line. Always check your data before calling writelines().

Method	Argument	Adds newlines?	Returns
`write()`	Single `str`	No (you add them)	Number of chars written
`writelines()`	Iterable of `str`	No (you add them)	`None`

✓Final answer

(a) Text files store human-readable characters with encoding; binary files store raw bytes without encoding. (b) readline() returns one line as a string; readlines() returns all lines as a list of strings. (c) write() writes a single string; writelines() writes an iterable of strings (no automatic newlines).

←Previous section · summarySummary →Next questionQ2 — Write the use and syntax for the following methods: a) open() b) read(…

Q.Differentiate between:

(a) Text file vs Binary file

(b) readline() vs readlines()

(c) write() vs writelines()

🎓Unlock everything free for 14 days

(b) `readline()` vs `readlines()`

(c) `write()` vs `writelines()`

Unlock everything free for 14 days