Get the Preplance app for a seamless learning experience. Practice offline, get daily streaks, and stay ahead with real-time interview updates.
Get it on
Google Play
4.9/5 Rating on Store
Python · Question Set
File Handling & Modules interview questions for placements and exams.
Questions
15
Included in this set
Subject
Python
Explore more sets
Difficulty
Mixed
Level of this set
Go through each question and its explanation. Use this set as a focused practice pack for Python.
The with statement uses a context manager. It ensures setup and teardown happen reliably. The file handle is closed even when exceptions are raised. This reduces resource leaks and keeps code short compared to try and finally patterns.
with open('data.txt', 'r', encoding='utf-8') as f:
for line in f:
process(line)For complete preparation, combine this set with full subject-wise practice for Python. You can also explore other subjects and sets from the links below.
Mode x is exclusive creation. It succeeds only if the file does not exist. This is useful when you want to avoid accidental overwrites. Mode w truncates existing files. Mode a appends if the file exists, or creates it if not. Mode r+ reads and writes without truncation.
with open('report.txt', 'x', encoding='utf-8') as f:
f.write('first run only')Iterating over the file object streams one line at a time. Memory stays small even for gigabyte files. Calling read or readlines pulls the entire content or many lines into memory and can cause spikes.
with open('big.log','r',encoding='utf-8') as f:
for line in f:
handle(line)Defaults vary by system and locale. Declaring UTF eight makes behavior predictable across machines and containers. It also avoids subtle bugs with special characters, especially when moving code between Windows, Mac, and Linux.
with open('notes.txt','r',encoding='utf-8') as f:
txt=f.read()The csv module expects newline empty string to manage newlines correctly on Windows. Without it, you can get extra blank rows. This setting lets the csv writer handle line endings consistently across platforms.
import csv
with open('out.csv','w',newline='',encoding='utf-8') as f:
w=csv.writer(f)
w.writerow(['id','name'])JSON is a text format supported across many languages and is safe to load from untrusted sources when using standard parsers. pickle can execute arbitrary code during loading. Never unpickle data you do not trust.
import json
with open('cfg.json') as f:
cfg=json.load(f)A single dot means the current package. This form keeps package internals flexible if you reorganize directories. Absolute imports are clearer for public APIs. Relative imports suit private, within-package usage.
# inside package module from .utils import helper helper.run()
__init__.py runs on package import. You can import and re-export symbols there to present a clean interface. In modern Python, implicit namespace packages can work without it, but __init__.py still helps for explicit control and side effects.
# mypkg/__init__.py from .core import run __all__=['run']
sys.path is a list of directories that the import system searches in order. You can inspect or modify it at runtime for advanced cases. A better practice is to use packages and editable installs rather than mutating sys.path in production code.
import sys print(sys.path[0])
Binary mode reads and writes raw bytes. Use it for non-text data like images, archives, or custom binary protocols. Text mode decodes bytes to strings using an encoding and may translate newlines. That is ideal for human-readable text.
with open('photo.jpg','rb') as f:
buf=f.read(1024)pathlib provides object-oriented paths with clear operators and methods. Code becomes more readable, such as path slash 'file.txt' instead of string joins. It also handles Windows and POSIX differences for you. Paths expose high-level actions like read_text, read_bytes, iterdir, and rename. This reduces boilerplate and avoids mistakes with separators and encodings.
from pathlib import Path
p = Path('logs')/'app.log'
text = p.read_text(encoding='utf-8')Imports are cached in sys.modules. Later imports reuse the already loaded module object, which speeds up startup and avoids duplicate singletons. This also means code changes are not seen until a restart. To reload during development, use importlib.reload on the module object. Be careful: existing references keep pointing to old objects. In production, prefer a fresh process or a clean import path.
import importlib, mymod # edit mymod on disk mymod = importlib.reload(mymod)
Organize code by feature: keep internals in submodules and re-export stable names in the package’s __init__.py. This gives users short imports while letting you refactor internals later. Use __all__ to declare what is public. Document the public surface and keep breaking changes behind the package boundary. Internals can change, but the top-level API should remain stable for consumers.
mypkg/ __init__.py # from .core import run; __all__=['run'] core.py utils.py
A context manager defines enter and exit steps around a code block. Python calls the enter method before the block starts and exit after it ends, even when exceptions happen. This pattern centralizes resource handling and prevents leaks. You can implement one by defining __enter__ and __exit__ methods or by using contextlib.contextmanager. Common uses include file handles, locks, temporary directories, and timing utilities.
class Locker:
def __enter__(self): print('acquire'); return self
def __exit__(self, exc_type, exc, tb): print('release')
with Locker() as l:
do_work()Stream data instead of loading it all. Iterate line by line, or read fixed-size chunks in binary for parsing. Keep memory usage stable and perform work incrementally. Use generators to pipe data through steps. Tune buffering, avoid per-line string concatenation, and batch writes. If I O is the bottleneck, consider gzip streams, multiprocessing for CPU-bound parsing, or external tools for pre-filtering.
def chunks(f, size=1024*1024):
while True:
b=f.read(size)
if not b: break
yield b
with open('big.bin','rb') as f:
for c in chunks(f):
process(c)