Using os, pathlib, sys, and shutil for System-Level Tasks in Python

Course: Python Training

Topic: Using os, pathlib, sys, and shutil for System-Level Tasks

Course Link: Python Training Course

Demo Link: Register for a Course Demo

JustAcademy Website: Visit JustAcademy

1. Introduction to System-Level Tasks in Python

Python is widely used for automation, file management, system administration, application deployment, command-line tools, and maintenance scripts. Many of these tasks require interaction with the operating system, directories, environment variables, command-line arguments, and files.

Python provides several built-in standard-library modules that simplify these operations. Four particularly useful modules are os, pathlib, sys, and shutil.

• os: Interacts with operating-system features, environment variables, directories, and file-system operations.
• pathlib: Provides an object-oriented approach to creating, combining, inspecting, and manipulating filesystem paths.
• sys: Provides access to interpreter information, command-line arguments, standard input and output streams, and Python's module search path.
• shutil: Provides high-level operations for copying, moving, deleting, and archiving files and directories.

These modules are included in Python's standard library, so they usually do not require separate installation with pip.

2. Learning Objectives

After completing this topic, learners should be able to:

• Understand the purpose of the os, pathlib, sys, and shutil modules.
• Retrieve the current working directory and inspect directory contents.
• Create, rename, inspect, and remove files and directories.
• Build portable filesystem paths using pathlib.Path.
• Read command-line arguments and retrieve Python interpreter information.
• Copy and move files and folders using shutil.
• Handle filesystem errors safely and write cross-platform automation scripts.
• Develop a practical file-management utility using multiple modules together.

3. Understanding the os Module

The os module provides a common interface for interacting with operating-system functionality. It is useful when a script needs to inspect the current environment, work with directories, access environment variables, or perform basic filesystem operations.

3.1 Importing the os Module

import os

print("Current directory:", os.getcwd())
print("Operating system:", os.name)

Explanation:

• import os loads the operating-system module.
• os.getcwd() returns the current working directory.
• os.name identifies the general operating-system interface, commonly nt on Windows and posix on Unix-like systems.

The exact output depends on the computer and the directory from which the program is executed.

3.2 Getting and Changing the Current Working Directory

The current working directory is the directory used as the starting point for many relative file paths. It is not necessarily the directory containing the Python script.

import os

current_directory = os.getcwd()
print("Before:", current_directory)

# Change only when you have a valid target directory.
# os.chdir("reports")

# print("After:", os.getcwd())

Important: Changing the working directory affects subsequent relative paths in the process. In larger applications, explicitly constructing paths is often more predictable than frequently calling os.chdir().

3.3 Listing Directory Contents

The os.listdir() function returns the names of entries in a directory.

import os

directory = "."

for name in os.listdir(directory):
    print(name)

Using "." means the current working directory. The returned list may include both files and directories.

To inspect entries recursively, use os.walk().

import os

for root, directories, files in os.walk("."):
    print("Folder:", root)

    for directory in directories:
        print("  Directory:", directory)

    for filename in files:
        print("  File:", filename)

os.walk() traverses a directory tree and yields the current folder, its subdirectories, and its filenames. Be careful when traversing large directories or folders containing symbolic links.

3.4 Creating Directories

Python offers os.mkdir() and os.makedirs() for creating directories.

import os

# Creates one directory.
os.mkdir("reports")

# Creates parent directories when required.
os.makedirs("project/data/processed", exist_ok=True)

The exist_ok=True argument prevents an error when the target directory already exists. It does not make every possible filesystem error disappear; permission problems and other failures can still occur.

3.5 Checking Whether Files and Directories Exist

import os

path = "report.txt"

print("Exists:", os.path.exists(path))
print("Is file:", os.path.isfile(path))
print("Is directory:", os.path.isdir(path))

These functions are useful for basic checks. A file can change between the time it is checked and the time an operation is attempted, so important operations should still handle exceptions.

3.6 Working with Environment Variables

Environment variables store configuration values supplied by the operating system or the environment in which a process runs. They can contain application settings, paths, or deployment configuration.

import os

# Read an environment variable.
home_directory = os.environ.get("HOME")

# Windows commonly uses USERPROFILE for the user profile directory.
if home_directory is None:
    home_directory = os.environ.get("USERPROFILE")

print("Home directory:", home_directory)

# Read a custom setting with a default.
app_mode = os.environ.get("APP_MODE", "development")
print("Application mode:", app_mode)

Use os.environ.get() when a variable may not be defined. Avoid printing sensitive environment variables, such as API keys, access tokens, or passwords, in application logs.

3.7 Joining and Inspecting Paths with os.path

The os.path module contains functions for working with filesystem paths.

import os

folder = "reports"
filename = "summary.txt"

full_path = os.path.join(folder, filename)

print("Path:", full_path)
print("Absolute path:", os.path.abspath(full_path))
print("Filename:", os.path.basename(full_path))
print("Parent path:", os.path.dirname(full_path))
print("Extension:", os.path.splitext(filename)[1])

os.path.join() constructs a path using the conventions of the current operating system. This is safer and more portable than manually joining path components with hard-coded slash characters.

3.8 Renaming and Removing Files

import os

# Rename a file.
# os.rename("old_report.txt", "new_report.txt")

# Remove a file.
# os.remove("temporary.txt")

# Remove an empty directory.
# os.rmdir("empty_folder")

The examples are commented out to avoid changing or deleting files accidentally. os.remove() removes a file, while os.rmdir() removes an empty directory. Removing a non-empty directory requires a different approach, such as shutil.rmtree(), which should be used with particular care.

4. Understanding the pathlib Module

The pathlib module provides an object-oriented way to represent and manipulate filesystem paths. Its main class, Path, makes many path operations easier to read and maintain.

For modern Python code, pathlib is often a convenient default for routine path construction, file discovery, and directory management.

4.1 Creating Path Objects

from pathlib import Path

current_path = Path.cwd()
project_path = Path("project")
report_path = project_path / "reports" / "summary.txt"

print("Current path:", current_path)
print("Project path:", project_path)
print("Report path:", report_path)

The forward-slash operator in project_path / "reports" combines path components. pathlib handles the platform-specific separator automatically.

4.2 Absolute and Relative Paths

• Relative path: Interpreted in relation to a working directory or another known base.
• Absolute path: Identifies a location from a filesystem root or platform-specific anchor.

from pathlib import Path

relative_path = Path("data/input.csv")
absolute_path = relative_path.resolve()

print("Relative path:", relative_path)
print("Resolved path:", absolute_path)
print("Is absolute:", absolute_path.is_absolute())

resolve() produces an absolute, resolved path according to the filesystem and platform. Depending on the options and environment, resolving a path may involve symlinks or filesystem access.

4.3 Inspecting Path Components

from pathlib import Path

path = Path("data/reports/annual_report.csv")

print("Name:", path.name)
print("Stem:", path.stem)
print("Suffix:", path.suffix)
print("Parent:", path.parent)
print("Parts:", path.parts)

For this example, the filename is annual_report.csv, the stem is annual_report, and the suffix is .csv.

4.4 Checking Paths

from pathlib import Path

path = Path("data/input.csv")

print("Exists:", path.exists())
print("Is a file:", path.is_file())
print("Is a directory:", path.is_dir())

Use these methods to determine the current state of a path. They are helpful for ordinary checks, but operations should still be wrapped in appropriate error handling when files may change or permissions may be restricted.

4.5 Creating Directories with pathlib

from pathlib import Path

output_directory = Path("output/reports")
output_directory.mkdir(parents=True, exist_ok=True)

print("Output directory is ready.")

parents=True creates missing parent directories. exist_ok=True allows the target directory to already exist.

4.6 Reading and Writing Text Files

Path objects provide convenient methods for basic text-file operations.

from pathlib import Path

file_path = Path("notes.txt")

file_path.write_text(
    "Python filesystem operations\\n",
    encoding="utf-8"
)

content = file_path.read_text(encoding="utf-8")
print(content)

For larger files, line-by-line processing, or fine-grained control over reading and writing, use the built-in open() function with a context manager.

from pathlib import Path

file_path = Path("large_log.txt")

if file_path.exists():
    with file_path.open("r", encoding="utf-8") as file:
        for line in file:
            print(line.rstrip())

4.7 Finding Files with glob()

The glob() method finds entries matching a filename pattern in a directory.

from pathlib import Path

reports_directory = Path("reports")

for csv_file in reports_directory.glob("*.csv"):
    print(csv_file.name)

Use rglob() when you want to search recursively through subdirectories.

from pathlib import Path

for python_file in Path(".").rglob("*.py"):
    print(python_file)

Recursive searches may include many entries, so restrict the starting directory and pattern when working with large filesystems.

4.8 Renaming and Deleting with pathlib

from pathlib import Path

old_file = Path("draft.txt")
new_file = Path("final.txt")

# Rename a file after confirming the source and destination.
# old_file.rename(new_file)

# Delete a file if it exists.
# if old_file.is_file():
#     old_file.unlink()

# Remove an empty directory.
# Path("empty_folder").rmdir()

unlink() removes a file or symbolic link, while rmdir() removes an empty directory. These operations can fail because of permissions, missing paths, or other filesystem conditions.

5. Understanding the sys Module

The sys module provides information and controls related to the running Python interpreter. It is especially useful for command-line programs, debugging, environment inspection, and application startup.

5.1 Accessing Python Version Information

import sys

print("Python version:", sys.version)
print("Version details:", sys.version_info)
print("Executable path:", sys.executable)
print("Platform:", sys.platform)

These values help identify the interpreter executing a script. sys.executable is particularly useful when troubleshooting environments in which multiple Python installations exist.

5.2 Reading Command-Line Arguments

The sys.argv list contains command-line arguments passed to a Python script. The first element is normally the script name, followed by the supplied arguments.

Consider a file named greet.py:

import sys

print("Arguments:", sys.argv)

if len(sys.argv) > 1:
    name = sys.argv[1]
    print(f"Hello, {name}!")
else:
    print("Please provide a name.")

Run the script from a terminal:

python greet.py Alex

Example output:

Arguments: ['greet.py', 'Alex']
Hello, Alex!

The exact representation of the script path may vary. For more complex command-line interfaces, use Python's argparse module to validate arguments, support options, and generate help messages.

5.3 Exiting a Program with an Exit Status

sys.exit() requests that the program terminate. A zero exit status generally indicates success, while a non-zero status indicates failure.

import sys

success = True

if success:
    print("Operation completed.")
    sys.exit(0)
else:
    print("Operation failed.")
    sys.exit(1)

In most command-line programs, sys.exit() is appropriate at the outermost level when deciding the process's final status. Avoid using it deep inside reusable functions unless termination is explicitly part of the design.

5.4 Using Standard Output and Standard Error

Python provides three common streams: sys.stdin for input, sys.stdout for normal output, and sys.stderr for error messages.

import sys

print("Task started.", file=sys.stdout)
print("Warning: sample file not found.", file=sys.stderr)

Separating error messages from normal output makes command-line utilities easier to automate and troubleshoot.

5.5 Understanding sys.path

sys.path is a list of locations that Python searches when importing modules. It includes paths determined by the interpreter, the environment, and the program's startup configuration.

import sys

for location in sys.path:
    print(location)

Although it is possible to modify sys.path, permanent project solutions should usually use proper package structure, virtual environments, and installation configuration rather than depending on fragile path modifications.

5.6 Getting the Recursion Limit

import sys

print("Current recursion limit:", sys.getrecursionlimit())

The recursion limit helps prevent uncontrolled recursion from exhausting the interpreter stack. Raising it without understanding the program's behavior can cause instability and should not be used as a general fix for recursive algorithm problems.

6. Understanding the shutil Module

The shutil module provides high-level utilities for copying, moving, deleting, and archiving files and directories. It complements os and pathlib by providing convenient operations across collections of filesystem entries.

6.1 Copying a File with shutil.copy()

import shutil
from pathlib import Path

source = Path("data.txt")
destination = Path("backup/data.txt")

destination.parent.mkdir(parents=True, exist_ok=True)

if source.is_file():
    shutil.copy(source, destination)
    print("File copied.")
else:
    print("Source file does not exist.")

shutil.copy() copies file content and permission mode where supported. It does not preserve every item of file metadata.

6.2 Copying File Metadata with copy2()

import shutil

# Copy file content and attempt to preserve additional metadata.
# shutil.copy2("source.txt", "backup/source.txt")

shutil.copy2() attempts to preserve additional metadata, such as modification times. However, not all metadata can be preserved on every operating system or filesystem.

6.3 Copying a Directory Tree

Use shutil.copytree() to copy a directory and its contents recursively.

import shutil
from pathlib import Path

source_directory = Path("project_files")
destination_directory = Path("project_backup")

if source_directory.is_dir():
    shutil.copytree(source_directory, destination_directory)
    print("Directory copied.")
else:
    print("Source directory does not exist.")

By default, the destination directory must not already exist. Recent Python versions provide options such as dirs_exist_ok=True for certain use cases, but overwriting or merging files should be planned carefully.

6.4 Moving Files and Directories

The shutil.move() function moves a file or directory to another location. Depending on the filesystem and destination, the operation may use a rename or copy-and-remove behavior.

import shutil
from pathlib import Path

source = Path("reports/monthly.txt")
destination_directory = Path("archive")

destination_directory.mkdir(parents=True, exist_ok=True)

if source.is_file():
    moved_path = shutil.move(
        str(source),
        str(destination_directory / source.name)
    )
    print("Moved to:", moved_path)
else:
    print("Source file does not exist.")

Always confirm the source and destination before moving important files, particularly when destination files might already exist.

6.5 Removing a Directory Tree

shutil.rmtree() removes a directory and its contents recursively. This is a destructive operation and should never be run on an unverified path.

import shutil
from pathlib import Path

target = Path("temporary_build")

# Only remove a directory that your application explicitly owns.
# if target.is_dir():
#     shutil.rmtree(target)

For production scripts, verify that the target is inside an expected workspace, avoid broad or user-controlled deletion paths, and consider whether a safer alternative is possible.

6.6 Creating ZIP and Other Archives

The shutil.make_archive() function creates an archive from a directory tree.

import shutil
from pathlib import Path

source_directory = Path("project_files")
archive_base = "project_backup"

if source_directory.is_dir():
    archive_path = shutil.make_archive(
        archive_base,
        "zip",
        root_dir=str(source_directory)
    )
    print("Archive created:", archive_path)

This example creates a ZIP archive of the contents of the selected source directory. The supported archive formats depend on the Python build and available compression modules.

6.7 Finding Executables with shutil.which()

shutil.which() searches the system's executable search path for a command.

import shutil

python_path = shutil.which("python")

if python_path:
    print("Python executable:", python_path)
else:
    print("Python executable was not found on PATH.")

This is useful when checking whether a required command-line program is available before attempting to use it.

7. Comparing os, pathlib, sys, and shutil

8. Choosing the Right Module

• Use pathlib when you need readable, portable path construction and basic file or directory operations.
• Use os when you need environment variables, working-directory control, operating-system interfaces, or directory traversal with os.walk().
• Use sys when your script needs command-line arguments, interpreter information, standard streams, or process exit status.
• Use shutil when you need to copy, move, archive, or recursively remove files and directories.

These modules are complementary. A typical automation script might use sys to read an argument, pathlib to construct a path, os to read a configuration variable, and shutil to create a backup.

9. Practical Example: Automated File Backup Utility

The following project demonstrates how to combine all four modules. It accepts a source directory from the command line, checks whether it exists, creates a timestamped ZIP backup, and prints a useful status message.

Save the code as backup_tool.py.

import os
import sys
import shutil
from pathlib import Path
from datetime import datetime


def create_backup(source_directory):
    source = Path(source_directory).expanduser()

    if not source.exists():
        raise FileNotFoundError(
            f"Source directory does not exist: {source}"
        )

    if not source.is_dir():
        raise NotADirectoryError(
            f"Source path is not a directory: {source}"
        )

    source = source.resolve()

    backup_root = Path(
        os.environ.get("BACKUP_DIR", "backups")
    ).expanduser()

    backup_root.mkdir(parents=True, exist_ok=True)

    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    archive_base = backup_root / f"{source.name}_{timestamp}"

    archive_path = shutil.make_archive(
        str(archive_base),
        "zip",
        root_dir=str(source)
    )

    return Path(archive_path)


def main():
    if len(sys.argv) != 2:
        print(
            "Usage: python backup_tool.py <source_directory>",
            file=sys.stderr
        )
        return 2

    try:
        archive = create_backup(sys.argv[1])
        print(f"Backup created successfully: {archive}")
        return 0
    except (OSError, shutil.Error) as error:
        print(f"Backup failed: {error}", file=sys.stderr)
        return 1


if __name__ == "__main__":
    sys.exit(main())

9.1 Running the Project

From a terminal, run the script with a directory that you want to back up.

python backup_tool.py project_files

To choose a custom backup directory, set the BACKUP_DIR environment variable before running the program.

Example for Windows Command Prompt:

set BACKUP_DIR=E:\PythonBackups
python backup_tool.py project_files

Example for macOS or Linux:

export BACKUP_DIR="$HOME/python_backups"
python backup_tool.py project_files

9.2 How the Project Works

1. sys.argv retrieves the directory supplied by the user.
2. pathlib.Path represents the source and backup paths.
3. expanduser() expands a home-directory shortcut when supported.
4. os.environ.get() retrieves the optional backup-directory configuration.
5. mkdir() creates the backup directory if it does not exist.
6. shutil.make_archive() creates the ZIP file.
7. The program returns a meaningful exit status for success or failure.

Note: This example creates an archive of the source directory's contents. For production backup systems, also consider free disk space, file permissions, files changing during backup, archive verification, exclusion rules, retention policies, and secure storage of sensitive data.

10. Error Handling for System-Level Operations

Filesystem and operating-system operations can fail for several reasons: a path may not exist, access may be denied, a file may be in use, or a destination may already exist.

10.1 Handling Common Exceptions

from pathlib import Path
import shutil

source = Path("input.txt")
destination = Path("backup/input.txt")

try:
    if not source.is_file():
        raise FileNotFoundError(
            f"Input file was not found: {source}"
        )

    destination.parent.mkdir(
        parents=True,
        exist_ok=True
    )

    shutil.copy2(source, destination)
    print("Copy completed.")

except FileNotFoundError as error:
    print("Missing file:", error)

except PermissionError as error:
    print("Permission denied:", error)

except shutil.Error as error:
    print("Copy operation failed:", error)

except OSError as error:
    print("Filesystem error:", error)

FileNotFoundError and PermissionError are specific kinds of OSError. Catch more specific exceptions before the general filesystem exception so that each failure can be handled appropriately.

10.2 Useful Exception Types

11. Best Practices for System-Level Programming

• Prefer portable paths: Use pathlib.Path or os.path.join() instead of hard-coding platform-specific separators.
• Use explicit encodings: Specify encoding="utf-8" when reading or writing text files unless another encoding is required.
• Validate inputs: Check user-supplied paths before performing operations.
• Handle errors: Expect missing files, permission problems, and destination conflicts.
• Avoid unsafe deletion: Be extremely careful with shutil.rmtree() and other destructive operations.
• Protect sensitive configuration: Do not expose environment variables containing secrets in logs or terminal output.
• Use context managers: Use with open(...) or Path.open() for file operations that need explicit resource management.
• Prefer argument parsing for complex tools: Use argparse rather than manually interpreting many command-line arguments.
• Keep scripts predictable: Build paths from known directories rather than relying unnecessarily on the current working directory.
• Test on target platforms: Path rules, permissions, symbolic links, and metadata behavior can differ across operating systems.
• Review copy behavior: Copy functions may not preserve all metadata, permissions, or platform-specific attributes.
• Limit filesystem scope: Automation should operate only on the directories and files it is intended to manage.

12. Common Mistakes and Troubleshooting

13. Practice Exercises

1. Write a program that prints the current working directory and Python version.
2. Use os.listdir() to list all entries in a chosen directory.
3. Create a nested directory structure using Path.mkdir().
4. Write a program that finds every .txt file in a directory using Path.glob().
5. Create a command-line script that accepts a filename and reports whether it exists.
6. Use shutil.copy2() to copy a sample file into a backup directory.
7. Create a ZIP archive of a sample project directory using shutil.make_archive().
8. Write a program that reads a configuration value from an environment variable.
9. Add exception handling to a file-copy script for missing files and permission errors.
10. Build a backup utility that accepts a source folder and an optional destination directory.

14. Mini Project: File Organizer

Develop a file organizer that scans a selected directory and categorizes files by extension. For example, image files can be placed in an Images folder, text files in a Documents folder, and PDF files in a PDFs folder.

Suggested Requirements

• Accept the target directory through command-line arguments.
• Use pathlib to discover files and construct destination paths.
• Use os.environ to read an optional configuration value.
• Use shutil.move() to move files into categorized folders.
• Use sys.stderr to report errors and sys.exit() to return an appropriate status.
• Skip directories and handle files with no extension.
• Avoid overwriting existing files unless the user explicitly chooses an overwrite policy.
• Include a dry-run option that lists proposed moves without changing files.

Extension challenge: Add a log file, duplicate-filename handling, a summary of files moved, and a restore plan. Test with a temporary folder containing sample files before using the program on personal or production data.

15. Interview Questions and Answers

Q1. What is the purpose of the os module?

Answer: The os module provides interfaces for interacting with operating-system features, including environment variables, directory operations, and filesystem-related functionality.

Q2. What is the difference between os and pathlib?

Answer: os provides operating-system interfaces and various filesystem functions, while pathlib represents paths as objects and offers readable methods for common path and file operations.

Q3. What is the difference between a relative path and an absolute path?

Answer: A relative path is interpreted in relation to a base directory, commonly the current working directory. An absolute path identifies a location from the filesystem's root or platform-specific anchor.

Q4. What does sys.argv contain?

Answer: It contains the command-line arguments supplied to the running Python program. The first element is normally the script name or script path.

Q5. What is sys.executable used for?

Answer: It identifies the path to the Python interpreter executing the current program, which can help troubleshoot interpreter and environment issues.

Q6. What is the difference between shutil.copy() and shutil.copy2()?

Answer: Both copy file contents and permission mode where supported. copy2() also attempts to preserve additional metadata, such as modification times, although not all metadata can be copied on every platform.

Q7. How do you copy an entire directory?

Answer: Use shutil.copytree(source, destination). By default, the destination directory must not already exist.

Q8. How do you safely create a directory if it may already exist?

Answer: Use Path("folder").mkdir(parents=True, exist_ok=True) or os.makedirs("folder", exist_ok=True).

Q9. What is the purpose of os.environ?

Answer: It provides a mapping of environment variables available to the running process. It is commonly used to read application configuration supplied by the environment.

Q10. What is the difference between os.remove() and os.rmdir()?

Answer: os.remove() removes a file, while os.rmdir() removes an empty directory.

Q11. What does shutil.rmtree() do?

Answer: It recursively removes a directory and its contents. Because this can permanently delete many files, the target should be verified before the function is called.

Q12. Why should you avoid hard-coded path separators?

Answer: Operating systems can use different path conventions. pathlib and os.path.join() construct paths according to the platform and improve portability.

Q13. How can you find all Python files in a directory tree?

Answer: Use Path(".").rglob("*.py") or use os.walk() to traverse directories and filter filenames.

Q14. What is the purpose of sys.exit()?

Answer: It requests program termination and can communicate a status code to the calling environment. A status of zero generally indicates success, while a non-zero status indicates an error or unsuccessful result.

Q15. Why is exception handling important in system-level scripts?

Answer: Filesystem operations can fail due to missing paths, permissions, disk problems, or destination conflicts. Exception handling lets a program report these failures and respond predictably.

16. Quick Revision Checklist

• os.getcwd() retrieves the current working directory.
• os.listdir() lists entries in a directory.
• os.makedirs() creates nested directories.
• os.environ.get() reads an environment variable with an optional default.
• Path() creates a path object.
• Path.exists(), is_file(), and is_dir() inspect a path.
• Path.glob() and rglob() discover matching entries.
• sys.argv retrieves command-line arguments.
• sys.executable identifies the current Python interpreter.
• sys.stderr writes error messages to the standard error stream.
• shutil.copy() and copy2() copy files.
• shutil.copytree() copies a directory tree.
• shutil.move() moves a file or directory.
• shutil.make_archive() creates an archive.
• Validate paths, handle exceptions, and verify destructive operations before executing them.

17. Conclusion

The os, pathlib, sys, and shutil modules are essential tools for Python developers who build automation scripts, command-line applications, backup utilities, and system-maintenance programs. Each module solves a different part of the problem: operating-system access, path manipulation, interpreter interaction, and high-level file management.

By combining these modules with portable path handling, clear exception handling, input validation, and safe filesystem practices, developers can create reliable scripts that work across different environments.

18. Additional Learning Resources

• Official Python Documentation: os Module
• Official Python Documentation: pathlib Module
• Official Python Documentation: sys Module
• Official Python Documentation: shutil Module
• Explore the Python Training Course at JustAcademy
• Register for a Python Course Demo
• Visit the JustAcademy Homepage

Final Takeaway: Use pathlib for readable path handling, os for operating-system interfaces, sys for interpreter and command-line interaction, and shutil for high-level file operations. Together, they provide a strong foundation for practical Python system automation.