Python OS and Sys Module Exercises: 30 Coding Problems with Solutions

This article presents 30 coding exercises that teach you to work with Python’s os and sys modules — the foundation of any practical scripting or automation work. Topics covered include file and directory operations such as creating, renaming, deleting, and traversing directory trees; reading and setting environment variables; handling command-line arguments with sys.argv; platform detection; managing the module search path with sys.path; and controlling interpreter behaviour through recursion limits and exit codes.

Each coding challenge includes a Practice Problem, Hint, Solution code, and detailed Explanation, ensuring you don’t just copy code, but genuinely practice and understand how and why it works.

• All solutions have been fully tested on Python 3.
• Use our Online Code Editor to solve these exercises in real time.
• Also, Solve Python Exercises: 29 topic-wise exercises with over 800+ coding questions

Let us know if you have any alternative solutions. It will help other developers.

Exercise 1: Print Current Directory

Problem Statement: Write a Python program that prints the current working directory to the console.

Purpose: This exercise introduces the os module and its most fundamental function. Knowing how to retrieve the current working directory is a foundational skill for file I/O operations, path construction, and building scripts that need to locate resources relative to where they run.

Given Input: No input required. The function reads the environment directly.

Expected Output: /home/user/projects (the actual path will vary based on your system)

import os

cwd = os.getcwd()
print("Current Directory:", cwd)Code language: Python (python)

Exercise 2: List Directory Contents

Problem Statement: Write a Python program that lists all files and folders in a given directory path.

Purpose: This exercise teaches you to inspect a directory’s contents programmatically. It is a core skill for building file managers, automation scripts, batch processors, and any tool that needs to discover what files are available at runtime.

Given Input: path = "." (the current directory)

Expected Output: A printed list of all file and folder names in the specified directory (output varies by system).

import os

path = "."
contents = os.listdir(path)

for item in contents:
    print(item)Code language: Python (python)

Exercise 3: Create a Directory

Problem Statement: Write a Python program that creates a new folder called test_folder in the current working directory, only if it does not already exist.

Purpose: Creating directories programmatically is essential for setting up output folders, organising generated files, and building scripts that prepare a workspace before writing data. Checking for existence first prevents crashes from duplicate creation.

Given Input: folder_name = "test_folder"

Expected Output: Folder 'test_folder' created successfully. or Folder 'test_folder' already exists.

import os

folder_name = "test_folder"

if not os.path.exists(folder_name):
    os.mkdir(folder_name)
    print(f"Folder '{folder_name}' created successfully.")
else:
    print(f"Folder '{folder_name}' already exists.")Code language: Python (python)

Exercise 4: Create Nested Directories

Problem Statement: Write a Python program that creates a nested directory structure a/b/c in the current working directory, even if some or all of the parent directories do not yet exist.

Purpose: Real-world scripts frequently need to create deep folder hierarchies in a single step – for example, when organising output by date (logs/2025/06/10) or project structure. os.makedirs() handles this without requiring manual creation of each level.

Given Input: nested_path = "a/b/c"

Expected Output: Nested directories 'a/b/c' created successfully.

import os

nested_path = os.path.join("a", "b", "c")

os.makedirs(nested_path, exist_ok=True)
print(f"Nested directories '{nested_path}' created successfully.")Code language: Python (python)

Exercise 5: Rename a File

Problem Statement: Write a Python program that renames a file called old.txt to new.txt in the current directory, with a check to confirm the source file exists before attempting the rename.

Purpose: Renaming files is a common task in file management scripts, data pipelines, and backup utilities. This exercise reinforces safe file handling by combining existence checks with the rename operation, preventing runtime errors on missing files.

Given Input: A file named old.txt must exist in the current directory.

Expected Output: Renamed 'old.txt' to 'new.txt' successfully. or Source file 'old.txt' does not exist.

import os

src = "old.txt"
dst = "new.txt"

# Create the file for testing purposes
open(src, "w").close()

if os.path.exists(src):
    os.rename(src, dst)
    print(f"Renamed '{src}' to '{dst}' successfully.")
else:
    print(f"Source file '{src}' does not exist.")Code language: Python (python)

Exercise 6: Delete a File

Problem Statement: Write a Python program that deletes a file called temp.txt from the current directory, but only after verifying that the file actually exists.

Purpose: Safe file deletion is a critical skill in automation and cleanup scripts. Blindly calling a delete function without checking for existence will raise an exception and halt your program. This exercise builds the habit of defensive file operations.

Given Input: A file named temp.txt (created in the script for testing).

Expected Output: File 'temp.txt' deleted successfully. or File 'temp.txt' not found.

import os

filename = "temp.txt"

# Create the file for testing purposes
with open(filename, "w") as f:
    f.write("temporary content")

if os.path.exists(filename):
    os.remove(filename)
    print(f"File '{filename}' deleted successfully.")
else:
    print(f"File '{filename}' not found.")Code language: Python (python)

Exercise 7: Delete a Directory Tree

Problem Statement: Write a Python program that creates a nested directory structure cleanup/a/b, adds a dummy file inside it, then removes the entire tree including all contents.

Purpose: Removing a directory and all of its contents is a frequent requirement in test teardown, temporary file cleanup, and build scripts. This exercise demonstrates the difference between os.rmdir() (empty directories only) and shutil.rmtree() (recursive deletion).

Given Input: Directory tree cleanup/a/b with a file cleanup/a/b/note.txt inside (created in the script).

Expected Output: Directory tree 'cleanup' removed successfully.

import os
import shutil

base_dir = "cleanup"
nested_path = os.path.join(base_dir, "a", "b")

# Create the nested directory and a dummy file
os.makedirs(nested_path, exist_ok=True)
with open(os.path.join(nested_path, "note.txt"), "w") as f:
    f.write("temporary note")

# Remove the entire tree
if os.path.exists(base_dir):
    shutil.rmtree(base_dir)
    print(f"Directory tree '{base_dir}' removed successfully.")
else:
    print(f"Directory '{base_dir}' not found.")Code language: Python (python)

Exercise 8: Check Path Existence

Problem Statement: Write a Python program that checks whether a given file or directory path exists on the system and prints a descriptive message indicating the result.

Purpose: Before performing any file operation – reading, writing, deleting, or renaming – it is good practice to verify that the target path actually exists. This exercise builds the habit of defensive path checking, which prevents FileNotFoundError crashes in production scripts.

Given Input: path = "sample.txt" (created in the script for testing)

Expected Output: Path 'sample.txt' exists. or Path 'sample.txt' does not exist.

import os

path = "sample.txt"

# Create the file for testing purposes
with open(path, "w") as f:
    f.write("hello")

if os.path.exists(path):
    print(f"Path '{path}' exists.")
else:
    print(f"Path '{path}' does not exist.")Code language: Python (python)

Exercise 9: Split File Extension

Problem Statement: Write a Python program that takes a filename string and extracts both the base name and the file extension separately.

Purpose: Parsing filenames is a routine task in file processing pipelines – for example, when filtering files by type, renaming files while preserving extensions, or routing files to different handlers based on format. This exercise introduces the clean, OS-aware way to split a filename.

Given Input: filename = "report_2025.pdf"

Expected Output: Base: report_2025 and Extension: .pdf

import os

filename = "report_2025.pdf"

base, ext = os.path.splitext(filename)

print("Base:", base)
print("Extension:", ext)Code language: Python (python)

Exercise 10: Get File Size

Problem Statement: Write a Python program that creates a file with some content and then prints its size in bytes.

Purpose: Checking file size is useful in scripts that enforce size limits, monitor disk usage, validate that a file was written correctly, or decide whether to process a file. This exercise shows how to retrieve file metadata without opening the file itself.

Given Input: A file named data.txt containing the text Hello, Python! (created in the script).

Expected Output: File size: 14 bytes

import os

filepath = "data.txt"

# Create the file for testing purposes
with open(filepath, "w") as f:
    f.write("Hello, Python!")

size = os.path.getsize(filepath)
print(f"File size: {size} bytes")Code language: Python (python)

Exercise 11: Read an Environment Variable

Problem Statement: Write a Python program that reads the system’s PATH environment variable and prints its value. If the variable is not found, print a default fallback message.

Purpose: Environment variables are the standard way to pass configuration into programs without hardcoding values. Reading them is essential for writing scripts that behave differently across development, staging, and production environments, or that respect system-level settings.

Given Input: No input required. The value is read from the operating system environment.

Expected Output: The value of the PATH variable (a long colon-separated string on Unix or semicolon-separated on Windows).

import os

path_value = os.environ.get("PATH", "PATH variable not set")
print("PATH:", path_value)Code language: Python (python)

Exercise 12: Set an Environment Variable

Problem Statement: Write a Python program that sets a custom environment variable called APP_MODE to the value development, then reads it back and prints it.

Purpose: Setting environment variables at runtime lets scripts configure themselves or communicate settings to child processes. This is a common pattern in web frameworks, CLI tools, and test harnesses that need to switch between modes without changing source code.

Given Input: No external input. The variable is defined within the script.

Expected Output: APP_MODE is set to: development

import os

# Set the environment variable
os.environ["APP_MODE"] = "development"

# Read it back
app_mode = os.environ.get("APP_MODE", "not set")
print(f"APP_MODE is set to: {app_mode}")Code language: Python (python)

Exercise 13: List All Environment Variables

Problem Statement: Write a Python program that prints all currently available environment variables, displaying each name and its value on a separate line in a readable format.

Purpose: Inspecting the full environment is helpful when debugging configuration issues, auditing what a script can see at runtime, or exploring a new system. This exercise also reinforces how to iterate over a dictionary-like object.

Given Input: No input required. The data is read from the live process environment.

Expected Output: A list of all environment variable names and values, one per line (output varies by system).

import os

for key, value in sorted(os.environ.items()):
    print(f"{key} = {value}")Code language: Python (python)

Exercise 14: Get Current Process ID

Problem Statement: Write a Python program that retrieves and prints the process ID (PID) of the currently running Python script.

Purpose: The process ID uniquely identifies a running program on the operating system. It is useful in logging, debugging multi-process applications, creating unique temporary filenames, and communicating between processes. This exercise introduces basic process introspection using the os module.

Given Input: No input required. The PID is provided by the operating system.

Expected Output: Current Process ID: 12345 (the actual number will vary each time the script runs)

import os

pid = os.getpid()
ppid = os.getppid()

print(f"Current Process ID: {pid}")
print(f"Parent Process ID: {ppid}")Code language: Python (python)

Exercise 15: Run a Shell Command

Problem Statement: Write a Python program that runs a shell command using os.system() and prints the exit code returned by the command.

Purpose: Running shell commands from within Python is a common requirement in automation scripts, build tools, and system administration utilities. This exercise introduces os.system() as the simplest way to invoke a command and inspect whether it succeeded or failed.

Given Input: No external input required. The command is hardcoded in the script.

Expected Output: The output of the shell command printed to the terminal, followed by Exit code: 0

import os
import sys

# Choose command based on OS
if sys.platform == "win32":
    command = "dir"
else:
    command = "ls"

exit_code = os.system(command)
print(f"Exit code: {exit_code}")Code language: Python (python)

Exercise 16: Walk a Directory Tree

Problem Statement: Write a Python program that recursively lists all files in a directory and its subdirectories, printing the full path of each file found.

Purpose: Traversing an entire directory tree is essential for tasks such as bulk file processing, searching for specific files, calculating total disk usage, and building file indexing tools. os.walk() handles all the recursion automatically, making it far simpler than writing your own recursive function.

Given Input: A sample directory tree created in the script: walk_demo/ with two subdirectories each containing a text file.

Expected Output: Full path of every file found inside the directory tree, one per line.

import os

# Create a sample directory tree for testing
os.makedirs("walk_demo/subdir_a", exist_ok=True)
os.makedirs("walk_demo/subdir_b", exist_ok=True)

with open("walk_demo/subdir_a/file1.txt", "w") as f:
    f.write("file one")
with open("walk_demo/subdir_b/file2.txt", "w") as f:
    f.write("file two")
with open("walk_demo/root_file.txt", "w") as f:
    f.write("root file")

# Walk the directory tree
for dirpath, dirnames, filenames in os.walk("walk_demo"):
    for filename in filenames:
        full_path = os.path.join(dirpath, filename)
        print(full_path)Code language: Python (python)

Exercise 17: Join Paths Safely

Problem Statement: Write a Python program that constructs a file path from separate components using os.path.join() and prints the resulting path.

Purpose: Hardcoding path separators like / or \ makes scripts brittle and platform-specific. Using os.path.join() is the correct, portable approach that automatically uses the right separator for the operating system the script runs on.

Given Input: base = "projects", subfolder = "python_exercises", filename = "solution.py"

Expected Output: projects/python_exercises/solution.py (on Unix) or projects\python_exercises\solution.py (on Windows)

import os

base = "projects"
subfolder = "python_exercises"
filename = "solution.py"

full_path = os.path.join(base, subfolder, filename)
print("Joined path:", full_path)

# Bonus: get the absolute version of the path
abs_path = os.path.abspath(full_path)
print("Absolute path:", abs_path)Code language: Python (python)

Exercise 18: Get Absolute Path

Problem Statement: Write a Python program that takes a relative file path and converts it to its full absolute path.

Purpose: Relative paths depend on the current working directory, which can change during a script’s execution. Converting to an absolute path early on locks in the location and prevents hard-to-debug errors when functions change directories mid-run or when paths are passed to other modules.

Given Input: relative_path = "data/report.csv"

Expected Output: A full absolute path such as /home/user/projects/data/report.csv (varies by system and working directory)

import os

relative_path = "data/report.csv"

abs_path = os.path.abspath(relative_path)
directory = os.path.dirname(abs_path)
filename = os.path.basename(abs_path)

print("Absolute path:", abs_path)
print("Directory    :", directory)
print("Filename     :", filename)Code language: Python (python)

Exercise 19: Print Python Version

Problem Statement: Write a Python program that displays the current Python version in two formats: as a human-readable string and as a structured named tuple with individual version components.

Purpose: Knowing the Python version at runtime is essential for writing scripts that conditionally use features only available in certain versions. It is also a standard first line of defence when debugging environment issues across different machines or deployment targets.

Given Input: No input required. The version is provided by the Python interpreter.

Expected Output: Python version: 3.11.4 (main, ...) and Major: 3 Minor: 11 Micro: 4 (values vary by installation)

import sys

print("Python version:", sys.version)
print(f"Major: {sys.version_info.major}  "
      f"Minor: {sys.version_info.minor}  "
      f"Micro: {sys.version_info.micro}")Code language: Python (python)

Exercise 20: Read Command-Line Arguments

Problem Statement: Write a Python program that reads arguments passed to it from the command line and prints each argument with its index position.

Purpose: Command-line arguments are the primary way to pass inputs to standalone scripts without hardcoding values or using interactive prompts. This exercise introduces sys.argv, which is the foundation for building CLI tools, utility scripts, and programs that integrate into shell pipelines.

Given Input: Run the script from the terminal as: python solution.py hello world 42

Expected Output: Each argument printed with its index, starting with the script name at index 0.

import sys

print(f"Total arguments: {len(sys.argv)}")
print("Arguments received:")

for index, arg in enumerate(sys.argv):
    print(f"  [{index}] {arg}")Code language: Python (python)

Exercise 21: Exit a Program

Problem Statement: Write a Python program that checks whether a required command-line argument is provided and exits gracefully with a descriptive error message if it is missing.

Purpose: Controlled program termination is a sign of well-written scripts. Rather than letting a program crash with a cryptic traceback, sys.exit() lets you stop execution cleanly, communicate the reason to the user, and signal success or failure to the calling shell or process manager.

Given Input: Run without arguments (python solution.py) to trigger the exit, or with one argument (python solution.py Alice) to proceed normally.

Expected Output: Error: Please provide a name as an argument. followed by exit, or Hello, Alice! if the argument is present.

import sys
if len(sys.argv) < 2:
    sys.exit("Error: Please provide a name as an argument.")
name = sys.argv[1]
print(f"Hello, {name}!")Code language: Python (python)

Exercise 22: Get Platform Info

Problem Statement: Write a Python program that identifies the current operating system platform and prints a human-readable description of it.

Purpose: Writing cross-platform scripts requires knowing which OS the code is running on so that platform-specific behaviour – such as choosing the right shell command, file separator, or config path – can be handled correctly. This exercise introduces the two most common ways to detect the platform at runtime.

Given Input: No input required. The platform is detected from the runtime environment.

Expected Output: Platform: linux and Detailed platform: Linux-5.15.0-x86_64 (values vary by system)

import sys
import platform

print("sys.platform       :", sys.platform)
print("platform.system()  :", platform.system())
print("platform.platform():", platform.platform())
print("platform.machine() :", platform.machine())Code language: Python (python)

Exercise 23: Inspect sys.path

Problem Statement: Write a Python program that prints all the directories Python searches when looking for modules to import, displaying each directory on a separate line.

Purpose: Understanding sys.path is essential for diagnosing ModuleNotFoundError problems, understanding how Python resolves imports, and knowing where to place custom modules so they can be imported without any configuration. This exercise builds a mental model of how Python’s import system works.

Given Input: No input required. The path list is maintained by the Python interpreter.

Expected Output: A numbered list of all directories in the module search path (output varies by system and virtual environment).

import sys

print(f"Total search paths: {len(sys.path)}\n")

for index, path in enumerate(sys.path):
    print(f"[{index}] {path if path else '(current directory)'}")Code language: Python (python)

Exercise 24: Add to sys.path

Problem Statement: Write a Python program that dynamically adds a custom directory to sys.path so that modules stored in that directory can be imported without installing them as packages.

Purpose: There are situations where you need to import a module from a non-standard location – for example, a shared utilities folder, a sibling project directory, or a path determined at runtime. Modifying sys.path programmatically is the direct way to achieve this without changing environment variables or restructuring the project.

Given Input: A custom directory path custom_modules containing a simple Python file greet.py (both created in the script).

Expected Output: Hello from custom module!

import sys
import os

# Create a custom module directory and a simple module inside it
custom_dir = os.path.abspath("custom_modules")
os.makedirs(custom_dir, exist_ok=True)

with open(os.path.join(custom_dir, "greet.py"), "w") as f:
    f.write('def hello():\n    print("Hello from custom module!")\n')

# Add the directory to sys.path if not already present
if custom_dir not in sys.path:
    sys.path.insert(0, custom_dir)

# Now import and use the module
import greet
greet.hello()Code language: Python (python)

Exercise 25: Get Recursion Limit

Problem Statement: Write a Python program that retrieves and prints the maximum recursion depth allowed by the current Python interpreter.

Purpose: Python limits how deeply functions can call themselves to prevent a stack overflow from consuming all available memory. Knowing this limit helps you understand why deeply recursive algorithms fail with a RecursionError and prepares you for the next exercise where the limit is adjusted.

Given Input: No input required.

Expected Output: Current recursion limit: 1000 (the default on most Python installations)

import sys

limit = sys.getrecursionlimit()
print(f"Current recursion limit: {limit}")

# Demonstrate recursion depth with a simple countdown
def countdown(n):
    if n == 0:
        return "Done"
    return countdown(n - 1)

print(countdown(50))
print("Recursion test with depth 50: passed")Code language: Python (python)

Exercise 26: Change Recursion Limit

Problem Statement: Write a Python program that increases the recursion limit and then tests it by running a recursive function that would fail under the default limit.

Purpose: Some legitimate algorithms – such as processing deeply nested JSON, traversing large trees, or implementing certain parsers – require a deeper call stack than Python’s default allows. This exercise shows how to raise the limit safely and why it should be done with care.

Given Input: No input required. The recursion depth is set within the script.

Expected Output: Old limit: 1000, New limit: 2000, and Recursion test with depth 1500: passed

import sys

old_limit = sys.getrecursionlimit()
print(f"Old limit: {old_limit}")

sys.setrecursionlimit(2000)
print(f"New limit: {sys.getrecursionlimit()}")

def deep_recurse(n):
    if n == 0:
        return "Done"
    return deep_recurse(n - 1)

result = deep_recurse(1500)
print(f"Recursion test with depth 1500: passed")

# Restore original limit
sys.setrecursionlimit(old_limit)Code language: Python (python)

Exercise 27: Script Info Logger

Problem Statement: Write a Python program that collects information about itself – its filename, the current working directory, and the OS platform – and writes all of it to a log file called script_info.log.

Purpose: Logging runtime context is a fundamental practice in production scripts and scheduled jobs. When something goes wrong, a log that captures where the script ran, on what platform, and under which filename gives you the starting point for diagnosis. This exercise combines sys and os together for the first time in a practical output task.

Given Input: No input required. All values are derived from the runtime environment.

Expected Output: A file script_info.log created in the current directory, and the log contents printed to the terminal.

import os
import sys

script_name = sys.argv[0]
current_dir = os.getcwd()
platform    = sys.platform
python_ver  = sys.version.split()[0]

log_lines = [
    f"Script   : {script_name}",
    f"Directory: {current_dir}",
    f"Platform : {platform}",
    f"Python   : {python_ver}",
]

log_path = "script_info.log"

with open(log_path, "w") as log_file:
    for line in log_lines:
        log_file.write(line + "\n")
        sys.stdout.write(line + "\n")

print(f"\nLog written to: {os.path.abspath(log_path)}")Code language: Python (python)

Exercise 28: Directory Size Calculator

Problem Statement: Write a Python program that calculates the total size of all files in a directory tree and displays the result in bytes, kilobytes, and megabytes.

Purpose: Calculating disk usage is a practical task in backup tools, storage monitoring scripts, and deployment pipelines. This exercise combines os.walk() for recursion with os.path.getsize() for per-file measurement, reinforcing how the two functions work together.

Given Input: A sample directory tree size_demo/ created in the script with a few files of varying sizes.

Expected Output: Total size printed in bytes, KB, and MB (exact values depend on the test files created).

import os

# Create a sample directory tree with files for testing
os.makedirs("size_demo/docs", exist_ok=True)
os.makedirs("size_demo/data", exist_ok=True)

with open("size_demo/docs/readme.txt", "w") as f:
    f.write("A" * 1024)           # 1 KB of content

with open("size_demo/data/records.csv", "w") as f:
    f.write("B" * 2048)           # 2 KB of content

with open("size_demo/notes.txt", "w") as f:
    f.write("C" * 512)            # 0.5 KB of content

# Calculate total size
total_bytes = 0
for dirpath, dirnames, filenames in os.walk("size_demo"):
    for filename in filenames:
        full_path = os.path.join(dirpath, filename)
        total_bytes += os.path.getsize(full_path)

print(f"Total size: {total_bytes} bytes")
print(f"Total size: {total_bytes / 1024:.2f} KB")
print(f"Total size: {total_bytes / 1024 ** 2:.4f} MB")Code language: Python (python)

Exercise 29: Environment Config Loader

Problem Statement: Write a Python program that simulates loading application configuration by reading multiple environment variables with fallback defaults, then prints a formatted summary of the configuration to standard output.

Purpose: Reading configuration from environment variables is the industry-standard approach for twelve-factor applications. It keeps secrets and environment-specific settings out of source code. This exercise combines os.environ.get() with sys.stdout to build a realistic config-loading pattern used in web apps, APIs, and CLI tools.

Given Input: Environment variables APP_HOST, APP_PORT, and APP_DEBUG – set within the script to simulate a configured environment.

Expected Output: A formatted configuration summary printed to stdout showing each key and its resolved value.

import os
import sys
# Simulate setting environment variables for this session
os.environ["APP_HOST"]  = "127.0.0.1"
os.environ["APP_PORT"]  = "8080"
# APP_DEBUG is intentionally left unset to demonstrate the fallback
# Load config with defaults
config = {
    "APP_HOST":  os.environ.get("APP_HOST",  "localhost"),
    "APP_PORT":  os.environ.get("APP_PORT",  "5000"),
    "APP_DEBUG": os.environ.get("APP_DEBUG", "False"),
    "APP_ENV":   os.environ.get("APP_ENV",   "production"),
}
# Print summary via sys.stdout
sys.stdout.write("=== Application Configuration ===\n")
for key, value in config.items():
    sys.stdout.write(f"  {key:<12}: {value}\n")
sys.stdout.write("=================================\n")Code language: Python (python)

Exercise 30: Recursive File Finder

Problem Statement: Write a Python program that accepts a file extension as a command-line argument and recursively searches the current directory tree for all files matching that extension, printing the full path of each match.

Purpose: This capstone exercise combines everything covered in the module: sys.argv for input, sys.exit() for validation, os.walk() for traversal, os.path.join() for path construction, and os.path.splitext() for extension matching. It mirrors a real-world utility script that you might use or build as part of a larger automation pipeline.

Given Input: Run as python solution.py .txt from the terminal. A sample directory tree with mixed file types is created by the script for testing.

Expected Output: Full paths of all .txt files found in the directory tree, followed by a count of matches.

import os
import sys
# Create a sample directory tree with mixed file types for testing
os.makedirs("search_demo/docs", exist_ok=True)
os.makedirs("search_demo/data", exist_ok=True)
for name in ["search_demo/docs/notes.txt",
             "search_demo/docs/readme.txt",
             "search_demo/data/records.csv",
             "search_demo/data/summary.txt",
             "search_demo/config.json"]:
    with open(name, "w") as f:
        f.write("sample content")
# Validate command-line argument
if len(sys.argv) < 2:
    sys.exit("Usage: python solution.py <extension>  e.g. python solution.py .txt")
# Normalise the extension
ext = sys.argv[1].lower()
if not ext.startswith("."):
    ext = "." + ext
# Search the directory tree
matches = []
for dirpath, dirnames, filenames in os.walk("search_demo"):
    for filename in filenames:
        if os.path.splitext(filename)[1].lower() == ext:
            matches.append(os.path.join(dirpath, filename))
# Display results
if matches:
    print(f"Files with extension '{ext}':")
    for path in matches:
        print(f"  {path}")
    print(f"\nTotal found: {len(matches)}")
else:
    print(f"No files with extension '{ext}' found.")Code language: Python (python)