Every process has a current directory. When a process starts, it simply inherits the current directory from its parent process; and it’s not, for example, set to the directory which contains the program you are running.
For a more detailed explanation, read on.
When disks became large enough that you did not want all your files in the same place, operating system vendors came up with a way to structure files in directories. So instead of saving everything in the same directory (or “folder” as beginners are now taught to call it) you could create new collections and other new collections inside of those (except in some early implementations directories could not contain other directories!)
Fundamentally, a directory is just a peculiar type of file, whose contents is a collection of other files, which can also include other directories.
On a primitive operating system, that was where the story ended. If you wanted to print a file called
term_paper.txt which was in the directory
spring_semester which in turn was in the directory
2021 which was in the directory
studies in the directory
mine, you would have to say
(except the command was probably something more arcane than
print, and the directory separator might have been something crazy like square brackets and colons, or something;
but this is unimportant for this exposition) and if you wanted to copy the file, you would have to spell out the whole enchilada twice:
copy mine/studies/2021/spring_semester/term_paper.txt mine/studies/2021/spring_semester/term_paper.backup
Then came the concept of a current working directory. What if you could say “from now on, until I say otherwise, all the files I am talking about will be in this particular directory”. Thus was the
cd command born (except on old systems like VMS it was called something clunkier, like
copy term_paper.txt term_paper.backup
That’s really all there is to it. When you
cd (or, in Python,
os.chdir()), you change your current working directory. It stays until you log out (or otherwise exit this process), or until you
cd to a different working directory, or switch to a different process or window where you are running a separate command which has its own current working directory. Just like you can have your file browser (Explorer or Finder or Nautilus or whatever it’s called) open with multiple windows in different directories, you can have multiple terminals open, and each one runs a shell which has its own independent current working directory.
So when you type
pwd into a terminal (or
cwd or whatever the command is called in your command language) the result will pretty much depend on what you happened to do in that window or process before, and probably depends on how you created that window or process. On many Unix-like systems, when you create a new terminal window with an associated shell process, it is originally opened in your home directory (
/home/you on many Unix systems,
/Users/you on a Mac, something more or less like
C:\Users\you on recent Windows) though probably your terminal can be configured to open somewhere else (commonly
Documents inside your home directory on some ostensibly “modern” and “friendly” systems).
Many beginners have a vague and incomplete mental model of what happens when you run a program. Many will incessantly
cd into whichever directory contains their script or program, and be genuinely scared and confused when you tell them that you don’t have to. If
frobozz is in
/home/you/bin then you don’t have to
because you can simply run it directly with
and similarly if
ls is in
/bin you most definitely don’t
just to get a directory listing.
Furthermore, like the
ls (or on Windows,
dir) example should readily convince you, any program you run will look in your current directory for files. Not the directory the program or script was saved in. Because if that were the case,
ls could only produce a listing of the directory it’s in (
/bin) — there is nothing special about the directory listing program, or the copy program, or the word processor program; they all, by design, look in the current working directory (though again, some GUI programs will start with e.g. your
Documents directory as their current working directory, by design, at least if you don’t tell them otherwise).
Many beginners write scripts which demand that the input and output files are in a particular directory inside a particular user’s home directory, but this is just poor design; a well-written program will simply look in the current working directory for its input files unless instructed otherwise, and write output to the current directory (or perhaps create a new directory in the current directory for its output if it consists of multiple files).
Python, then, is no different from any other programs. If your current working directory is
/Users/you/Documents when you run
python then that directory is what
os.getcwd() inside your Python script or interpreter will produce (unless you separately
os.chdir() to a different directory during runtime; but again, this is probably unnecessary, and often a sign that a script was written by a beginner). And if your Python script accepts a file name parameter, it probably should simply get the operating system to
open whatever the user passed in, which means relative file names are relative to the invoking user’s current working directory.
python /home/you/bin/script.py file.txt
open(sys.argv) and fail with an error if
file.txt does not exist in the current directory. Let’s say that again; it doesn’t look in
file.txt — unless of course that is also the current working directory of you, the invoking user, in which case of course you could simply write
python script.py file.txt
On a related note, many beginners needlessly try something like
with open(os.path.join(os.getcwd(), "input.txt")) as data:
which needlessly calls
os.getcwd(). Why is it needless? If you have been following along, you know the answer already: the operating system will look for relative file names (like here,
input.txt) in the current working directory anyway. So all you need is
with open("input.txt") as data:
One final remark. On Unix-like systems, all files are ultimately inside the root directory
/ which contains a number of other directories (and usually regular users are not allowed to write anything there, and system administrators with the privilege to do it typically don’t want to). Every relative file name can be turned into an absolute file name by tracing the path from the root directory to the current directory. So if the file we want to access is in
/home/you/Documents/file.txt it means that
home is in the root directory, and contains
you, which contains
Documents, which contains
file.txt. If your current working directory were
/home you could refer to the same file by the relative path
you/Documents/file.txt; and if your current directory was
/home/you, the relative path to it would be
Documents/file.txt (and if your current directory was
/home/you/Music you could say
../Documents/file.txt but let’s not take this example any further now).
Windows has a slightly different arrangement, with a number of drives with single-letter identifiers, each with its own root directory; so the root of the C: drive is
C:\ and the root of the D: drive is
D:\ etc. (and the directory separator is a backslash instead of a slash, although you can use a slash instead pretty much everywhere, which is often a good idea for preserving your sanity).
Your python interpreter location is based off of how you launched it, as well as subsequent actions taken after launching it like use of the os module to navigate your file system. Merely starting the interpreter will place you in the directory of your python installation (not the same on different operating systems). On the other hand, if you start by editing or running a file within a specific directory, your location will be the folder of the file you were editing. If you need to run the interpreter in a certain directory and you are using idle for example, it is easiest to start by creating a python file there one way or another and when you edit it you can start a shell with Run > Python Shell which will already be in that directory. If you are using the command line interpreter, navigate to the folder where you want to run your interpreter before running the python/python3/py command. If you need to navigate manually, you can of course use the following which has already been mentioned:
This has nothing to do with osx in particular, it’s more of a concept shared by all unix-based systems, and I believe Windows as well.
os.getcwd() is the equivalent of the bash
pwd command – it simply returns the full path of the current location in which you are in. In other words:
alex@suse:~> cd /
Python 2.7.12 (default, Jul 01 2016, 15:34:22) [GCC] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import os
It depends from where you started the python shell/script.