File Systems & Paths Explained — A Beginner's Guide to Computer Storage

Learn how computer file systems work, understand absolute and relative paths, navigate directories, and manage files efficiently with clear examples for beginners.

What You'll Learn

By the end of this tutorial, you will understand how file systems organize data, the difference between absolute and relative paths, and how to navigate directories using the command line and file managers.

Why It Matters

Every piece of data on a computer lives somewhere in a file system. Source code, configuration files, databases, logs, and executables are all files organized in a hierarchical structure. Without understanding file systems and paths, you cannot effectively write code, configure tools, or troubleshoot problems.

Real-World Use

When you install Durga Antivirus Pro, it places program files in specific directories, stores quarantine data in a secure folder, and writes logs to a dedicated location. Understanding where these files go helps you verify installations, read debug logs, and customize configuration.

Your Learning Path

flowchart LR
  A[Computer Basics] --> B[File Systems & Paths]
  B --> C[Terminal Basics]
  C --> D[Version Control]
  D --> E[Programming Fundamentals]
  B --> F{You Are Here}
  style F fill:#f90,color:#fff

What Is a File System?

A file system is the method your operating system uses to organize and store data on a disk. Think of it as a digital filing cabinet where every drawer, folder, and document has a specific place.

Hierarchical Structure

File systems are tree-like structures. The topmost level is called the root directory, represented by a forward slash / on Linux and macOS, or a drive letter like C:\ on Windows.

/
├── home/
│   └── user/
│       ├── Documents/
│       │   ├── report.pdf
│       │   └── notes.txt
│       └── Projects/
│           └── website/
│               └── index.html
├── etc/
│   └── config.ini
└── usr/
    └── bin/
        └── python3

Expected behavior: This tree shows how directories branch from root into subdirectories, eventually containing individual files. Each indentation level represents a deeper nesting.

Common Directory Structure Differences

Understanding File Paths

A file path is a string that specifies the unique location of a file or directory in the file system. There are two types: absolute and relative.

Absolute Paths

An absolute path starts from the root and specifies every directory down to the target file. It works from anywhere because it is complete.

Windows:  C:\Users\alice\Documents\report.pdf
macOS:    /Users/alice/Documents/report.pdf
Linux:    /home/alice/Documents/report.pdf

Relative Paths

A relative path starts from your current working directory. It uses special symbols to refer to parent directories.

# If you are in /home/alice/Documents
# Relative path to report.pdf:
report.pdf

# Relative path from Documents to home:
../

# Relative path to a file in Pictures:
../Pictures/photo.jpg

Expected behavior: The relative path report.pdf resolves to /home/alice/Documents/report.pdf when the current directory is /home/alice/Documents.

Navigating the File System with Python

Python's os and pathlib modules give you programmatic access to the file system. The pathlib module is the modern, recommended approach.

from pathlib import Path

# Get current working directory
current = Path.cwd()
print(f"Current directory: {current}")

# List all files and directories in current location
for item in current.iterdir():
    if item.is_dir():
        print(f"[DIR]  {item.name}")
    else:
        print(f"[FILE] {item.name} ({item.stat().st_size} bytes)")

# Build a path
docs = current / "Documents" / "projects"
print(f"Documents/projects path: {docs}")
print(f"Does it exist? {docs.exists()}")

Expected output:

Current directory: /home/alice
[DIR]  Documents
[DIR]  Pictures
[FILE] config.txt (1024 bytes)
Documents/projects path: /home/alice/Documents/projects
Does it exist? False

Creating and Organizing Directories

from pathlib import Path

# Create a project structure
base = Path.home() / "my_project"
base.mkdir(exist_ok=True)

# Create subdirectories
(base / "src").mkdir(parents=True, exist_ok=True)
(base / "tests").mkdir(parents=True, exist_ok=True)
(base / "data" / "input").mkdir(parents=True, exist_ok=True)
(base / "data" / "output").mkdir(parents=True, exist_ok=True)

# Create a placeholder file
readme = base / "README.md"
readme.write_text("# My Project\n\nA sample project structure.")

# Verify the structure
for path in sorted(base.rglob("*")):
    depth = len(path.relative_to(base).parts)
    indent = "  " * depth
    print(f"{indent}{path.name}")

Expected output:

my_project
  README.md
  data
    input
    output
  src
  tests

File Permissions and Metadata

Every file has metadata including permissions, owner, size, and modification time. Understanding permissions is critical for security.

ls -la /home/alice/Documents

Expected behavior: Output shows file types (- for file, d for directory), permissions (rwx for read/write/execute for user, group, and others), owner, group, size, modification date, and filename.

Permission Breakdown

Common File System Errors and Mistakes

1. Using Wrong Path Separator

Windows uses backslashes while Linux and macOS use forward slashes. Hardcoding \ in cross-platform code breaks on Unix systems. Use pathlib or os.path.join() to remain portable.

2. Confusing Relative and Absolute Paths

Using a relative path in a script that runs from a different working directory causes file-not-found errors. Always verify the current working directory with Path.cwd() before using relative paths.

3. Forgetting That Paths Are Case-Sensitive

On Linux and macOS, File.txt and file.txt are different files. On Windows, they are the same. This causes bugs when code written on Windows is deployed to Linux.

4. Not Checking if a Directory Exists Before Writing

Attempting to create a file inside a non-existent directory raises a FileNotFoundError. Always create parent directories with mkdir(parents=True) or check with path.exists() first.

5. Hardcoding Absolute Paths in Code

An absolute path like /home/alice/project/data.csv works only on one machine. Use relative paths or environment variables to keep code portable across systems and team members.

6. Ignoring Permission Errors

Writing to system directories like /etc or C:\<a href="/operating-systems/windows/">Windows</a> requires administrator privileges. Attempting to write without permission raises a PermissionError. Use proper locations like the user's home directory or a config folder.

7. Leaving Temporary Files Behind

Scripts that create temp files but never clean them clutter the file system. Use tempfile.TemporaryDirectory() or clean up explicitly in a finally block.

Practice Questions

1. What is the difference between an absolute path and a relative path? An absolute path starts from the root directory (like /home/alice/file.txt) and is complete. A relative path starts from the current working directory (like Documents/file.txt) and depends on where you are.

2. Why does Python code that uses \ as a separator break on Linux? Windows uses backslash as the path separator. Linux and macOS use forward slash. Hardcoding \ causes invalid paths on Unix systems. Use pathlib.Path or os.path.join() for cross-platform code.

3. What does the .. symbol mean in a file path? It refers to the parent directory of the current directory. For example, if you are in /home/alice/Documents, then .. refers to /home/alice.

4. How can you create nested directories in Python in one call? Use Path.mkdir(parents=True, exist_ok=True). The parents=True flag creates all intermediate directories that do not exist.

5. Challenge: Write a Python script that creates a project directory structure for a web application with folders for static assets, templates, source code, and tests. Print the full tree when done.

Mini Project: File System Organizer

Write a Python script that scans a messy download folder and organizes files by extension into subdirectories (Images, Documents, Archives, Code, Others). Your script should handle nested folders, skip hidden files, and print a summary of what was moved.

from pathlib import Path

DOWNLOADS = Path.home() / "Downloads"

# Category definitions
CATEGORIES = {
    "Images": [".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg"],
    "Documents": [".pdf", ".docx", ".txt", ".md", ".csv"],
    "Archives": [".zip", ".tar", ".gz", ".rar", ".7z"],
    "Code": [".py", ".js", ".html", ".css", ".json", ".yaml", ".toml"],
}

def organize_folder(folder):
    for item in folder.iterdir():
        if item.is_file() and not item.name.startswith("."):
            ext = item.suffix.lower()
            moved = False
            for category, extensions in CATEGORIES.items():
                if ext in extensions:
                    target = folder / category
                    target.mkdir(exist_ok=True)
                    item.rename(target / item.name)
                    print(f"Moved {item.name} -> {category}/")
                    moved = True
                    break
            if not moved:
                other = folder / "Others"
                other.mkdir(exist_ok=True)
                item.rename(other / item.name)
                print(f"Moved {item.name} -> Others/")

if __name__ == "__main__":
    organize_folder(DOWNLOADS)
    print("Organization complete.")

Expected behavior: The script scans every file in the Downloads folder, matches its extension to a category, creates category folders if needed, and moves each file. Files with unknown extensions go to the Others folder.

Built by the developers of Doda Browser, DodaZIP, and Durga Antivirus Pro.