Relative paths in Python

Using the os module: Your Swiss army knife

Dive into the world of file systems with the essential os module. It does more than just path handling, ensuring your path handling is system compatible.

Fetching the current directory on the fly

import os
cwd = os.getcwd()  # "You Are Here" marker in the file system maze!


Stitching paths together

Construct paths with ease, dodging any platform-specific traps:

joined_path = os.path.join('my_folder', 'my_file.txt')  # "Build-A-Path" Workshop


os.path.join() makes sure the right separator for your OS is used, avoiding any path chaos.

Dealing with the mysterious file

__file__ packs a punch, but it's not always the most reliable, especially when playing around with C extensions or if you are inside an interactive interpreter:

script_dir = os.path.dirname(os.path.abspath(__file__))  # Get location, minus the smoke and mirrors


Embrace the elegance of pathlib

For those who want more than just functionality - pathlib. It brings path manipulation into the 21st century, with intuitive and future-proof methods.

Opening files like a boss

Why use open() when you can add some flair with:

with Path('my_file.txt').open('r') as f:
    contents = f.read()  # Just a normal reading session...


Who doesn't enjoy method chaining?

Treasure hunt for files

When searching for files by a pattern, pathlib has you covered:

for path in Path('.').glob('**/*.txt'):
    print(path)  # "File, come out, come out, wherever you are!"


Get a recursive list of all .txt files. You're now a Python file detective!

Making script's directory your playground

To import modules seamlessly from the script's directory, add it to sys.path like a pro:

import sys, os

sys.path.append(os.path.dirname(__file__))  # Knock-knock importing!


Heads up: Watch out for these!

Working with paths can be tricky. That's why we're here to help you dodge some pitfalls.

System differences can be a party pooper

Different systems can behave differently. Use os.path.abspath() to ensure an absolute path without surprises.

Beware of resource leaks

Make sure to close file handles after use or use a context manager to avoid dropping resources down a black hole. A hint - pathlib has a built-in resource-friendly open method.

Transformation magic with os

Convert relative paths to absolute paths using the wizardry of os.path.realpath():

real_path = os.path.realpath('some_relative_path')  # Like taking off the edge-blurred glasses


Best practices: Get ahead of the game

Here are some smart moves for being a steps ahead while working with paths.

Handling the package's bonus files

Storing some non-Python files in packages? No worries, setuptools got your back:

from pkg_resources import resource_filename
resource_path = resource_filename(__name__, 'some_resource')  # "Hey setuptools, can you find this for me?"


Import without the surprises

When running into relative imports, always bundle your module-level code in a if __name__ == "__main__" safety net to avoid any script sneaking up during imports.

No hard-coding separators

Avoid "Tom"/"Jerry" like situations by preventing directly typing path separators like "/" or "\\". The organic way here is to always prefer os.path.join() or use pathlib's forward slash operator:

from pathlib import Path
new_path = Path('my_folder') / 'my_file.txt'  # "Care for some Path delicacy?"


Sail smoothly with file

__file__ is priceless for Python-scripts-as-tools, but always validate its behavior under script vs. module execution to avoid any path fiasco!