Python File Handling Exercises: 30+ Coding Problems with Solutions

name = input("Enter your name: ")

with open("user.txt", "w") as f:
    f.write(name)

print("Name written to user.txt")Code language: Python (python)

Explanation:

• input("Enter your name: "): Prompts the user to type their name and stores it in the variable name.
• open("user.txt", "w"): Opens (or creates) user.txt in write mode. If the file already exists, its contents are overwritten.
• with statement: Ensures the file is properly closed after the block exits, even if an error occurs. This is the preferred pattern for file operations.
• f.write(name): Writes the string value of name into the file without adding a newline automatically.

with open("data.txt", "r") as f:
    content = f.read()

print(content)Code language: Python (python)

Explanation:

• open("data.txt", "r"): Opens the file in read mode. Python raises a FileNotFoundError if the file does not exist.
• f.read(): Reads the entire file as a single string, including newline characters. This is suitable for small files where loading all content at once is not a memory concern.
• print(content): Outputs the string to the console. Because read() preserves newlines, the output mirrors the original file layout.

with open("lines.txt", "r") as f:
    for line in f:
        print(line, end="")Code language: Python (python)

Explanation:

• for line in f: Iterates over the file object line by line. Python reads each line lazily, making this approach memory-efficient for very large files.
• line: Each iteration yields a string that includes the trailing newline character \n from the file.
• print(line, end=""): Prints the line without adding an extra newline, since the line already contains one. This prevents double-spacing in the output.
• Alternative: Use line.strip() and a regular print(line.strip()) to remove the trailing newline explicitly before printing.

with open("items.txt", "r") as f:
    lines = f.readlines()

print(lines)Code language: Python (python)

Explanation:

• f.readlines(): Reads all lines from the file and returns them as a list of strings. Each string corresponds to one line and retains the \n newline character at the end.
• lines: Stores the resulting list, which you can index, slice, or iterate over just like any Python list.
• Alternative: Use [line.strip() for line in f.readlines()] to get a clean list without newline characters, which is more convenient for most downstream processing.

with open("notes.txt", "a") as f:
    f.write("\nThis is a new line.")

print("Sentence appended successfully.")Code language: Python (python)

Explanation:

• open("notes.txt", "a"): Opens the file in append mode. If the file does not exist, Python creates it. Existing content is never overwritten.
• f.write("\nThis is a new line."): The leading \n ensures the new sentence begins on a fresh line rather than being joined to the last character of the existing content.
• Key distinction: "a" (append) vs "w" (write) – using "w" here would erase all existing content before writing, which is a common and hard-to-notice mistake.

with open("temp.txt", "w") as f:
    pass

print("File content cleared.")Code language: Python (python)

Explanation:

• open("temp.txt", "w"): Opening a file in write mode immediately truncates it to zero length. This happens before any write() call is made.
• pass: A no-operation placeholder that makes the with block syntactically valid. No data is written, so the file ends up empty.
• Alternative: open("temp.txt", "w").close() achieves the same result in a single line, though the with pattern is safer and more explicit.

lines = ["First line\n", "Second line\n", "Third line\n"]

with open("output.txt", "w") as f:
    f.writelines(lines)

print("Text written to output.txt")Code language: Python (python)

Explanation:

• lines: A list of strings where each item represents one line. The \n at the end of each string is required because writelines() does not add newlines automatically.
• f.writelines(lines): Writes all strings in the list to the file in sequence. It is equivalent to calling f.write() once per item but more concise.
• Alternative: Use three separate f.write("First line\n") calls for clarity, or use print("First line", file=f) which adds the newline automatically.

import os

if os.path.exists("data.txt"):
    print("File exists.")
else:
    print("File does not exist.")Code language: Python (python)

Explanation:

• import os: Imports Python’s built-in os module, which provides functions for interacting with the operating system, including the filesystem.
• os.path.exists("data.txt"): Checks whether the given path points to an existing file or directory. Returns a boolean: True if found, False if not.
• Practical use: Always check for file existence before attempting to open a file in read mode. Without this check, your program will raise a FileNotFoundError if the file is missing.
• Modern alternative: from pathlib import Path followed by Path("data.txt").exists() achieves the same result with a more object-oriented and readable syntax, preferred in Python 3.4+.

try:
    with open("missing.txt", "r") as f:
        content = f.read()
        print(content)
except FileNotFoundError:
    print("Error: The file was not found.")Code language: Python (python)

Explanation:

• try block: Contains the code that might raise an exception. Python attempts to execute it, and if an error occurs, execution jumps immediately to the matching except clause.
• FileNotFoundError: A built-in Python exception raised specifically when a file or directory is requested but cannot be found at the given path.
• except FileNotFoundError: Catches only this specific error type, allowing other unexpected exceptions to still surface. This is more precise than using a bare except clause.
• Alternative: Add except PermissionError as a second clause to also handle cases where the file exists but the user lacks read permission.

with open("data.txt", "r") as f:
    lines = f.readlines()

print("Total lines:", len(lines))Code language: Python (python)

Explanation:

• f.readlines(): Reads all lines from the file and returns them as a list of strings. Each element corresponds to one line, including its trailing \n character.
• len(lines): Returns the number of elements in the list, which equals the number of lines in the file.
• Edge case: If the last line of the file does not end with a newline, it is still counted as a line. readlines() handles this correctly.
• Memory-efficient alternative: sum(1 for line in f) iterates lazily and is preferable for very large files where loading all lines into a list at once would be wasteful.

with open("data.txt", "r") as f:
    content = f.read()

words = content.split()
print("Total words:", len(words))Code language: Python (python)

Explanation:

• f.read(): Reads the entire file into a single string, including newline characters between lines. This allows split() to work across all lines at once.
• content.split(): Splits the string at every whitespace boundary (spaces, tabs, and newlines) and returns a list of word tokens. It ignores leading, trailing, and consecutive whitespace automatically.
• len(words): Counts the total number of tokens in the list, which corresponds to the total word count in the file.
• Note: This approach counts punctuation attached to words (e.g., great,) as a single token. For more precise word counting, consider stripping punctuation with the string module or a regular expression.

with open("data.txt", "r") as f:
    content = f.read()

print("Total characters:", len(content))Code language: Python (python)

Explanation:

• f.read(): Loads the complete file content into a string variable. Every character in the file, including spaces, punctuation, and newline characters, is included.
• len(content): Returns the total number of characters in the string. In Python 3, this counts Unicode characters (code points), not raw bytes, which matters for files containing non-ASCII characters.
• Newlines count: Each \n at the end of a line is counted as one character. On Windows, files may use \r\n (two characters per line ending) unless opened in text mode, which Python normalises to \n by default.
• Alternative: Use len(content.replace("\n", "")) to exclude newline characters from the count, or len(content.replace(" ", "").replace("\n", "")) to count only non-whitespace characters.

word_to_find = "Python"

with open("data.txt", "r") as f:
    content = f.read()

count = content.count(word_to_find)
print(f"Occurrences of '{word_to_find}':", count)Code language: Python (python)

Explanation:

• word_to_find = "Python": Stores the target word in a variable so it can be reused in both the search and the output message without repetition.
• content.count(word_to_find): Returns the number of non-overlapping occurrences of the substring within the full file content string. It is case-sensitive by default.
• Case-insensitive variant: Use content.lower().count(word_to_find.lower()) to match regardless of capitalisation, so python, Python, and PYTHON would all be counted.
• Note on substring matching: .count() matches any occurrence, including within larger words. For example, searching for on would also match inside Python. Use content.split().count(word) or the re module with word boundary markers \b for whole-word-only matching.

n = 3

with open("data.txt", "r") as f:
    for i, line in enumerate(f):
        if i >= n:
            break
        print(line, end="")Code language: Python (python)

Explanation:

• n = 3: Defines how many lines to read. Storing this in a variable makes the program easy to adapt without hunting through the code for hardcoded numbers.
• enumerate(f): Iterates over the file while providing a line index i starting at 0, allowing you to track how many lines have been read so far.
• if i >= n: break: Stops reading as soon as the index reaches n. Because the file object is lazy, Python never reads the remaining lines from disk after the break.
• Slice alternative: f.readlines()[:n] is more concise but loads the entire file into memory first before slicing, which is inefficient for large files.

n = 3

with open("data.txt", "r") as f:
    lines = f.readlines()

for line in lines[-n:]:
    print(line, end="")Code language: Python (python)

Explanation:

• f.readlines(): Reads all lines into a list. While this loads the whole file, it is necessary here because you need access to the end of the file, which requires knowing where the end is.
• lines[-n:]: Python’s negative slicing returns the last n elements of the list. If n is larger than the total number of lines, this safely returns all lines without raising an error.
• print(line, end=""): Prints each line as-is without appending an extra newline, since lines from readlines() already contain their trailing \n.
• Memory-efficient alternative: from collections import deque followed by deque(f, maxlen=n) keeps only the last n lines in memory as it streams through the file, ideal for very large files.

target_lines = {1, 3, 5}

with open("data.txt", "r") as f:
    for line_num, line in enumerate(f, start=1):
        if line_num in target_lines:
            print(line, end="")Code language: Python (python)

Explanation:

• target_lines = {1, 3, 5}: A Python set containing the 1-based line numbers to print. Using a set makes membership checks fast and the intent clear, and it is easy to update with different line numbers.
• enumerate(f, start=1): Iterates over the file object while providing a line counter that starts at 1 rather than the default 0, matching natural 1-based line numbering.
• if line_num in target_lines: Checks membership in the set for each line. Only lines whose number appears in the set are printed; all others are skipped.
• Early exit optimisation: If your target lines are all near the top of a very large file, you can add if line_num > max(target_lines): break to stop reading once the last target line has been reached.

with open("words.txt", "r") as f:
    words = f.read().split()

longest = ""
for word in words:
    if len(word) > len(longest):
        longest = word

print("Longest word:", longest)Code language: Python (python)

Explanation:

• f.read().split(): Reads the full file content as a string and splits it into a list of words using whitespace as the delimiter.
• longest = "": Initializes an empty string to hold the current longest word found during iteration.
• if len(word) > len(longest): Compares each word’s length against the current longest and updates it when a longer word is found.
• Alternative: max(words, key=len) achieves the same result in one line, but the loop makes the comparison logic explicit and easier to follow.

freq = {}

with open("sample.txt", "r") as f:
    content = f.read().lower()

for char in content:
    if char.isalpha():
        freq[char] = freq.get(char, 0) + 1

for letter, count in freq.items():
    print(f"{letter}: {count}")Code language: Python (python)

Explanation:

• f.read().lower(): Reads the entire file and converts it to lowercase so that H and h are counted as the same letter.
• char.isalpha(): Filters out non-letter characters such as spaces, digits, and punctuation before counting.
• freq.get(char, 0) + 1: Retrieves the existing count for a letter (defaulting to 0 if absent) and increments it by 1, avoiding a KeyError.
• freq.items(): Iterates over key-value pairs in the dictionary to print each letter alongside its frequency.

search_word = "Python"

with open("notes.txt", "r") as f:
    for line_num, line in enumerate(f, start=1):
        if search_word.lower() in line.lower():
            print(f'"{search_word}" found on line {line_num}')Code language: Python (python)

Explanation:

• enumerate(f, start=1): Iterates over the file object line by line while providing a counter that starts at 1, giving you the line number and content in each iteration.
• search_word.lower() in line.lower(): Converts both the search term and the current line to lowercase before comparison, making the search case-insensitive.
• f'"{search_word}" found on line {line_num}': Uses an f-string to format the output clearly, displaying both the word searched for and the line it was found on.

with open("messy.txt", "r") as infile, open("clean.txt", "w") as outfile:
    for line in infile:
        cleaned_line = line.strip()
        outfile.write(cleaned_line + "\n")Code language: Python (python)

Explanation:

• open("messy.txt", "r") as infile, open("clean.txt", "w") as outfile: Opens both files in a single with statement, ensuring both are properly closed after the block finishes.
• line.strip(): Removes all leading and trailing whitespace characters, including spaces, tabs, and the newline character at the end of each line.
• outfile.write(cleaned_line + "\n"): Writes the cleaned line to the output file and manually appends a newline character, since .strip() has already removed the original one.

with open("input.txt", "r") as infile:
    content = infile.read()

swapped = content.swapcase()

with open("swapped.txt", "w") as outfile:
    outfile.write(swapped)Code language: Python (python)

Explanation:

• infile.read(): Reads the entire file content into a single string, making it straightforward to apply a transformation to the whole text at once.
• content.swapcase(): Returns a new string where every uppercase letter is converted to lowercase and every lowercase letter is converted to uppercase. Non-letter characters remain unchanged.
• outfile.write(swapped): Writes the fully transformed string to the output file. Since the original newlines are preserved in the string, no manual \n is needed here.

old_word = "Java"
new_word = "Python"

with open("story.txt", "r") as f:
    content = f.read()

updated_content = content.replace(old_word, new_word)

with open("story.txt", "w") as f:
    f.write(updated_content)Code language: Python (python)

Explanation:

• content = f.read(): Reads the entire file into memory as a string so all replacements can be made before any writing occurs.
• content.replace(old_word, new_word): Replaces every occurrence of the old word with the new word throughout the string. This method is case-sensitive, so Java and java would be treated as different words.
• open("story.txt", "w"): Reopens the same file in write mode, which truncates (clears) the existing content before writing the updated string back.
• Note: Reading and writing are done in two separate with blocks intentionally. Opening a file in "r" and "w" at the same time can lead to data loss on some systems.

import os

filename = "data.txt"
size_bytes = os.path.getsize(filename)
size_kb = size_bytes / 1024

print(f"File size: {size_kb} KB")Code language: Python (python)

Explanation:

• import os: Imports Python’s built-in os module, which provides functions for interacting with the operating system, including file and directory operations.
• os.path.getsize(filename): Returns the size of the specified file in bytes. It raises an OSError if the file does not exist or is inaccessible.
• size_bytes / 1024: Converts the size from bytes to kilobytes. Since Python 3 uses true division by default, this returns a float (e.g., 2.0), giving a precise result even for non-round values.
• Note: For larger files, you can chain the conversion further: divide by 1024 again to get megabytes, or use 1024 ** 2 directly.

with open("source.txt", "rb") as src, open("destination.txt", "wb") as dst:
    data = src.read()
    dst.write(data)

print("File copied successfully.")Code language: Python (python)

Explanation:

• open("source.txt", "rb"): Opens the source file in binary read mode. The b flag tells Python to treat the file as raw bytes rather than decoded text, preventing any newline or encoding translations.
• open("destination.txt", "wb"): Opens (or creates) the destination file in binary write mode. If the file already exists, its content is overwritten.
• src.read(): Reads the entire file as a bytes object. This works for any file type since no decoding is applied.
• dst.write(data): Writes the raw bytes directly to the destination file, producing an exact byte-for-byte copy of the original.
• Note: For very large files, reading in chunks (e.g., src.read(4096) in a loop) is more memory-efficient than reading everything at once.

import os

old_name = "old_name.txt"
new_name = "new_name.txt"

try:
    os.rename(old_name, new_name)
    print("File renamed successfully.")
except FileNotFoundError:
    print(f"Error: '{old_name}' not found.")Code language: Python (python)

Explanation:

• import os: Loads Python’s built-in os module, which provides an interface to operating system file and directory operations.
• os.rename(old_name, new_name): Renames the file at the path given by the first argument to the path given by the second. If both paths are on the same filesystem, this is an atomic operation on most systems.
• except FileNotFoundError: Catches the error raised when the source file does not exist, preventing the program from crashing and giving the user a clear message instead.
• Note: os.rename() can also move a file to a different directory by providing a full destination path, not just a new filename.

import os

directory = "."
prefix = "2024_"

for filename in os.listdir(directory):
    if filename.endswith(".txt"):
        old_path = os.path.join(directory, filename)
        new_path = os.path.join(directory, prefix + filename)
        os.rename(old_path, new_path)
        print(f"Renamed: {filename} -> {prefix + filename}")Code language: Python (python)

Explanation:

• os.listdir(directory): Returns a list of all entry names (files and subdirectories) inside the specified directory. Using "." targets the current working directory.
• filename.endswith(".txt"): Filters the directory listing so that only files with a .txt extension are processed, leaving other file types untouched.
• os.path.join(directory, filename): Constructs a proper file path by joining the directory and filename with the correct separator for the operating system, making the code portable across Windows and Unix systems.
• prefix + filename: Concatenates the prefix string directly onto the original filename to form the new name, e.g., "notes.txt" becomes "2024_notes.txt".

import os

filename = "temp.txt"

if os.path.exists(filename):
    os.remove(filename)
    print(f"{filename} has been deleted.")
else:
    print(f"{filename} does not exist.")Code language: Python (python)

Explanation:

• os.path.exists(filename): Returns True if the given path points to an existing file or directory, and False otherwise. This guards against a FileNotFoundError when the file is missing.
• os.remove(filename): Permanently deletes the specified file from disk. Unlike moving to a recycle bin, this operation cannot be undone through normal means, so the existence check beforehand is good practice.
• else branch: Provides a clear, user-friendly message when the file is not found, making the program more robust and easier to debug in automated environments.
• Note: os.remove() only works on files. To delete an empty directory, use os.rmdir(). For a non-empty directory, use shutil.rmtree().

input_files = ["file1.txt", "file2.txt"]
output_file = "merged.txt"

with open(output_file, "w") as outfile:
    for filename in input_files:
        with open(filename, "r") as infile:
            outfile.write(infile.read())
            outfile.write("\n")

print(f"Files merged into {output_file}")Code language: Python (python)

Explanation:

• input_files = ["file1.txt", "file2.txt"]: Stores the source filenames in a list, making it easy to extend the program to merge more files by simply adding entries to the list.
• open(output_file, "w"): Opens the merged output file once in write mode before the loop starts, so all content is written to the same file handle in a single session.
• outfile.write(infile.read()): Reads the entire content of each source file and writes it directly into the output file, appending one file’s content after the other.
• outfile.write("\n"): Inserts a newline between the contents of each file so that the last line of one file does not run directly into the first line of the next.

with open("original.txt", "r") as f:
    lines = f.readlines()

reversed_lines = lines[::-1]

with open("reversed.txt", "w") as f:
    f.writelines(reversed_lines)

print("Lines reversed and saved to reversed.txt")Code language: Python (python)

Explanation:

• f.readlines(): Reads every line from the file into a Python list, with each element being one line including its trailing newline character. This loads the full structure needed for reordering.
• lines[::-1]: Creates a new list that is a reversed copy of the original using Python’s slice notation. The -1 step iterates from the last element to the first without modifying the original list.
• f.writelines(reversed_lines): Writes a list of strings to the file in one call. Unlike write(), it does not add any separators between items, so the existing newline characters within each element handle the line breaks correctly.

import os

directory = "my_folder"
output_file = "file_list.txt"

with open(output_file, "w") as outfile:
    for entry in os.listdir(directory):
        full_path = os.path.join(directory, entry)
        if os.path.isfile(full_path):
            outfile.write(entry + "\n")

print(f"File list saved to {output_file}")Code language: Python (python)

Explanation:

• os.listdir(directory): Returns a list of all entries in the specified directory, including both files and subdirectories. The order of entries is not guaranteed and varies by operating system.
• os.path.join(directory, entry): Builds the full path for each entry by joining the directory path and the entry name, which is required for os.path.isfile() to work correctly regardless of the current working directory.
• os.path.isfile(full_path): Returns True only for regular files, excluding subdirectories, symbolic links to directories, and other non-file entries from the output.
• outfile.write(entry + "\n"): Writes just the filename (not the full path) to the output file, with a newline after each entry so every name appears on its own line.

source = "photo.jpg"
destination = "photo_copy.jpg"
chunk_size = 4096

with open(source, "rb") as src, open(destination, "wb") as dst:
    while True:
        chunk = src.read(chunk_size)
        if not chunk:
            break
        dst.write(chunk)

print(f"Image copied to {destination}")Code language: Python (python)

Explanation:

• "rb" and "wb": The b flag opens the file in binary mode, instructing Python to read and write raw bytes without any newline translation or character encoding. This is essential for non-text file formats like JPEG images.
• src.read(chunk_size): Reads up to 4096 bytes at a time from the source file rather than loading the entire file into memory. This approach keeps memory usage low and works well even for very large files.
• if not chunk: break: When read() reaches the end of the file, it returns an empty bytes object (b""), which is falsy. This condition exits the loop cleanly once all data has been copied.
• dst.write(chunk): Writes each chunk of bytes directly to the destination file, building the copy incrementally until the entire source has been transferred.

import string

with open("paragraph.txt", "r") as f:
    content = f.read().lower()

words = content.translate(str.maketrans("", "", string.punctuation)).split()
unique_sorted = sorted(set(words))

for word in unique_sorted:
    print(word)Code language: Python (python)

Explanation:

• content.lower(): Converts all text to lowercase before processing so that The and the are treated as the same word during deduplication.
• str.maketrans("", "", string.punctuation): Creates a translation table that maps every punctuation character to nothing, effectively stripping commas, periods, apostrophes, and other symbols from the text before splitting.
• set(words): Converts the word list to a set, which automatically discards duplicate entries since sets only store unique values.
• sorted(set(words)): Returns a new list of the unique words arranged in ascending alphabetical order. Sorting a set directly is not stable, so wrapping it in sorted() guarantees a consistent order.

keyword = "ERROR"

with open("app.log", "r") as f:
    for line in f:
        if keyword in line:
            print(line.strip())Code language: Python (python)

Explanation:

• for line in f: Iterates over the file object one line at a time. This approach is memory-efficient because Python reads each line on demand rather than loading the entire file into memory, which is important for large log files.
• if keyword in line: Uses Python’s in membership operator to check whether the substring "ERROR" exists anywhere within the current line. This is case-sensitive, so "error" or "Error" would not match.
• line.strip(): Removes the trailing newline character (\n) that readlines-style iteration preserves, so the printed output does not have blank lines between each result.
• Extension: To save matching lines to a file instead of printing them, open an output file alongside the log file and use outfile.write(line) for each match – no .strip() needed in that case since the newline helps separate entries.

chunk_size = 10

with open("large_file.txt", "r") as f:
    lines = f.readlines()

total_lines = len(lines)

for i, start in enumerate(range(0, total_lines, chunk_size), start=1):
    chunk = lines[start:start + chunk_size]
    output_filename = f"part_{i}.txt"
    with open(output_filename, "w") as out:
        out.writelines(chunk)
    print(f"Created: {output_filename} ({len(chunk)} lines)")Code language: Python (python)

Explanation:

• f.readlines(): Reads all lines from the large file into a list at once. Each element is one line including its newline character, preserving the structure needed for writing to part files.
• range(0, total_lines, chunk_size): Generates starting indices at intervals of 10 (e.g., 0, 10, 20), allowing the loop to step through the full line list in non-overlapping chunks of the specified size.
• lines[start:start + chunk_size]: Slices exactly 10 lines from the full list for each iteration. When fewer than 10 lines remain (such as the final chunk), Python’s slice safely returns only the remaining lines without raising an error.
• enumerate(..., start=1): Pairs each chunk’s starting index with a 1-based part number, which is used to build descriptive output filenames like part_1.txt, part_2.txt, and so on.
• out.writelines(chunk): Writes the list of lines for each chunk directly to the part file. Since each line already contains its trailing newline from readlines(), no manual \n is needed.