Relative Paths and Absolute Paths

A path is more than a string that names a file or directory. It describes where a resource begins, how to traverse the h

A path is more than a string that names a file or directory. It describes where a resource begins, how to traverse the hierarchy, and which resource to reach. In file systems, command-line tools, and web applications, paths may be interpreted in two fundamental ways: as absolute paths or relative paths.

Choosing the wrong kind of path—or failing to define the correct base directory—often leads to familiar errors: a script cannot find its configuration file, an image disappears after deployment, or a command that works in one directory fails in another.
An absolute path identifies a resource from a fixed root. It does not depend on the current working directory, so the same absolute path points to the same location regardless of where the command is launched.

On Linux and macOS, absolute paths normally begin with /:

/home/alice/project/src/main.py
/var/log/nginx/access.log
/usr/local/bin/python

On Windows, an absolute path commonly begins with a drive letter:

C:\Users\Alice\project\src\main.py
D:\data\input.csv

Windows also supports UNC paths for resources on a network share:

\\server\share\documents\report.xlsx

Because an absolute path contains all the information needed to locate its target, it is especially useful for:

  • System configuration files
  • Service and daemon settings
  • Logging destinations
  • Deployment scripts
  • Scheduled tasks
  • References to resources outside a project tree

The main drawback is portability. A path such as /home/alice/project may be valid on one Linux system but meaningless on another. Likewise, C:\Users\Alice cannot be used directly on a machine that follows a different directory layout or operating system convention.

Relative Paths Depend on a Base

A relative path starts from an implicit or explicit base directory. That base might be the shell’s current working directory, the directory containing a script, the location of a configuration file, or even the URL of the current web document.

Suppose the current working directory is:

/home/alice/project

Then the relative path:

src/main.py

refers to:

/home/alice/project/src/main.py

If the current working directory changes to /home/alice/project/src, the same relative path points somewhere else—or nowhere at all.

Parent-directory references make the dependency explicit:

../config/app.yaml

From /home/alice/project/src, this path moves up to /home/alice/project, then enters the config directory.

Relative paths are usually shorter and more convenient for resources that belong to the same project. They also make it easier to move or rename a project without updating every internal reference. However, they must always be interpreted relative to a clearly defined location.

This distinction is critical in scripts. A script may use:

data/input.csv

assuming it is launched from the project root. If someone runs it from another directory, the program may look for the file in the wrong place.

Common Path Symbols

Several special symbols appear in path expressions:

  • . means the current directory.
  • .. means the parent directory.
  • ~ usually represents the current user’s home directory.
  • / is the root and path separator on Unix-like systems.
  • \ is the path separator commonly used on Windows.

Examples include:

./run.sh
../images/logo.png
~/Documents/notes.txt

The ~ symbol is usually expanded by the shell before a program receives it. Applications that process paths directly may not support it.

On Windows, a backslash may also have a special meaning inside a programming-language string. For example:

path = "C:\\Users\\Alice\\report.txt"

For cross-platform code, it is better to construct paths with a standard path library rather than hard-code separators.

Working with Paths in a Command Line

The pwd command displays the current working directory on Linux and macOS:

pwd

An absolute path can be used whenever that directory is known:

cd /var/log

A relative path is useful when navigating around the current location:

cd ../etc
cat ./nginx/nginx.conf

On Windows Command Prompt, similar commands look like this:

cd C:\Users\Alice\project
cd ..\config
type .\app.yaml

Scripts can make their assumptions safer by detecting the directory from which they were invoked or by defining paths relative to the script itself.

Paths in Python

In Python, a relative Path is normally interpreted relative to the process’s current working directory:

from pathlib import Path

data_file = Path("data") / "input.csv"
print(data_file.resolve())

Calling resolve() produces an absolute path and normalizes segments such as . and ...

This behavior is convenient for command-line tools, but it is not always appropriate for application files. A script located at /home/alice/project/scripts/report.py should not rely on the user launching it from /home/alice/project. A more reliable approach is to establish the script directory as the base:

from pathlib import Path

base_dir = Path(__file__).resolve().parent
config_file = base_dir / "config.yaml"

Similarly, paths assembled with os.path.join or pathlib.Path are less likely to suffer from platform-specific formatting errors:

import os

output_file = os.path.join("output", "results.csv")

Absolute paths can still be useful when a program needs to access a known system location, but externally configurable locations are often more portable.

Paths in the Web

Web paths follow similar principles, but their base is a URL rather than a file-system directory. Three common forms are:

  • Absolute URL, including a protocol and host:

    https://example.com/assets/app.js

  • Root-relative URL, beginning with /:

    /assets/style.css

  • Document-relative URL, resolved against the current document’s location:

    ../images/logo.png

An HTML file might contain:

<link rel="stylesheet" href="/assets/style.css">
<img src="../images/logo.png" alt="Company logo">
<script src="https://cdn.example.com/app.js"></script>

Here, /assets/style.css refers to the root of the website, not the root of the server’s file system. A document-relative URL such as ../images/logo.png is based on the page’s current URL, which may change when the site uses a single-page application or client-side routing. For predictable asset loading, projects often use root-relative paths or configure a public asset base explicitly.

Choosing the Right Approach

A practical rule is to use absolute paths for fixed, system-level locations and relative paths for resources that belong within a project.

Good path-handling practices include:

  • Establishing a clear base directory instead of assuming where a program will run.
  • Resolving important paths to absolute form when diagnosing failures.
  • Using pathlib, os.path.join, or an equivalent library instead of concatenating separators manually.
  • Reading configurable directories from environment variables or configuration files.
  • Normalizing and validating paths supplied by users.
  • Preventing untrusted input from escaping an intended directory through excessive .. segments.
  • Testing scripts from multiple working directories.
  • Distinguishing web root-relative paths from file-system absolute paths.

In short, an absolute path offers clarity and consistency at the cost of portability, while a relative path offers flexibility and brevity at the cost of context. Understanding how the base is determined—and making that base explicit—is the key to building programs that remain reliable across directories, machines, and deployment environments.