Navigating Files and Directories¶
The linux file system¶
The part of the operating system responsible for managing files and directories is called the file system. It organizes our data into files, which hold information, and directories (also called "folders"), which hold files or other directories.
Several commands are frequently used to create, inspect, rename, and delete files and directories. To start exploring them, we'll go to our open shell window.
First let's find out where we are by running a command called pwd (which stands for "print working directory"). Directories are like places - at any time while we are using the shell we are in exactly one place, called our current working directory. Commands mostly read and write files in the current(present) working directory, i.e. "here", so knowing where you are before running a command is important. pwd shows you where you are:
jupyter-user~:$pwd
/jupyter/jupyter-user
This is known as our home directory.
To understand what a "home directory" is, let's have a look at how the file system as a whole is organized. For the sake of this example, we'll be illustrating the filesystem on our scientist Nelle's computer. After this illustration, you'll be learning commands to explore your own filesystem, which will be constructed in a similar way, but not be exactly identical.
For example, on Nelle's computer, the filesystem looks like this:
At the top is the root directory that holds everything else. We refer to it using a slash character, /, on its own; this is the leading slash in /Users/nelle.
Inside that directory are several other directories: bin (which is where some built-in programs are stored), data (for miscellaneous data files), Users (where users' personal directories are located), tmp (for temporary files that don't need to be stored long-term), and so on.
We know that our current working directory /jupyter/jupyter-username is stored inside /jupyter/ as /jupyter/ is the first part of its name. In the same way Nell's home directory /Users/nelle is stored inside /Users because /Users is the first part of its name. Similarly, we know that /Users is stored inside the root directory / because its name begins with /.
Underneath /Users, we find one directory for each user with an account on Nelle's machine, her colleagues the Mummy and Wolfman.
The Mummy's files are stored in /Users/imhotep, Wolfman's in /Users/larry, and Nelle's in Users/nelle. Because Nelle is the user in our examples here, this is why we get /Users/nelle as our home directory.
Typically, when you open a new command prompt you will be in your home directory to start.
Now let's learn the command that will let us see the contents of our own filesystem. We can see what's in the data-shell directory by running ls, which stands for "listing":
jupyter-user:~$ls
IntroShell Welcome.ipynb courses
ls prints the names of the files and directories in the current directory. We can make its output more comprehensible by using the flag -F (also known as a switch or an option) , which tells ls to add a marker to file and directory names to indicate what they are:
jupyter-user:~$ls -F
IntroShell/ Welcome.ipynb@ courses@
- A trailing
/indicates that this is a directory - @ indicates a link
*indicates an executable
Depending on your settings, it might also use colors to indicate the entry types. Any names that don;t have a classification symbol are just plain old files.
Getting help¶
ls has lots of other flags. There are two common ways to find out how to use a command and what flags it accepts:
- We can pass a
--helpflag to the command, such as:ls --help - We can read its manual with man, such as:
man ls
Depending on your environment you might find that only one of these works (either man or --help). We'll describe both ways below.
The --help flag¶
Many bash commands, and programs that people have written that can be run from within bash, support a --help flag to display more information on how to use the command or program:
jupyter-user:~$ls --help
Usage: ls [OPTION]... [FILE]...
List information about the FILEs (the current directory by default).
Sort entries alphabetically if none of -cftuvSUX nor --sort is specified.
Mandatory arguments to long options are mandatory for short options too.
-a, --all do not ignore entries starting with .
-A, --almost-all do not list implied . and ..
--author with -l, print the author of each file
-b, --escape print C-style escapes for nongraphic characters
--block-size=SIZE scale sizes by SIZE before printing them; e.g.,
'--block-size=M' prints sizes in units of
1,048,576 bytes; see SIZE format below
-B, --ignore-backups do not list implied entries ending with ~
-c with -lt: sort by, and show, ctime (time of last
modification of file status information);
with -l: show ctime and sort by name;
otherwise: sort by ctime, newest first
...
...
...
The man command¶
The other way to learn about ls is to type:
jupyter-user:~$man ls
LS(1) User Commands LS(1)
NAME
ls - list directory contents
SYNOPSIS
ls [OPTION]... [FILE]...
DESCRIPTION
List information about the FILEs (the current directory by default). Sort entries alphabetically if none of
-cftuvSUX nor --sort is specified.
Mandatory arguments to long options are mandatory for short options too.
-a, --all
do not ignore entries starting with .
-A, --almost-all
do not list implied . and ..
--author
with -l, print the author of each file
-b, --escape
print C-style escapes for nongraphic characters
...
...
...
man is a command that will display the manual with more information for a command/program if it is present.
This will turn your terminal into a page with a description of the ls command and its options and, if you're lucky, some examples of how to use it.
To navigate through the man pages, you may use ↑ and ↓ to move line-by-line, or try B and Spacebar to skip up and down by a full page. To search for a character or word in the man pages, use / followed by the character or word you are searching for.
To quit the man pages, press Q.
Exploring other directories¶
Not only can we use ls on the current working directory, but we can use it to list the contents of a different directory. Let’s take a look at the one of the directories in our home directory by running:
jupyter-user:~$ls -F IntroShell
data/
, i.e., the command ls with the -F option and the argument IntroShell. The argument IntroShell tells ls that we want a listing of something other than our current working directory, and we can see that in the IntroShell directory there is another directory called data.
As you may now see, using a bash shell is strongly dependent on the idea that your files are organized in a hierarchical file system. Organizing things hierarchically in this way helps us keep track of our work: it’s possible to put hundreds of files in our home directory, just as it’s possible to pile hundreds of printed papers on our desk, but it’s a self-defeating strategy.
We if we wish to change our location to a different directory, so we are no longer located in our home directory.
The command to change locations is cd followed by a directory name to change our working directory. cd stands for “change directory” i.e. thischanges the directory we are located in.
Let’s say we want to move to the IntroShell/ directory. We can use the following command to get there:
jupyter-user:~$cd IntroShell
`
We now know how to go down the directory tree (i.e. how to go into a subdirectory), but how do we go up (i.e. how do we leave a directory and go into its parent directory)? We might try the following:
jupyter-user:~$cd data
bash: cd: data: No such file or directory
`
But we get an error! Why is this?
With our methods so far, cd can only see sub-directories inside your current directory. There are different ways to see directories above your current location; we'll start with the simplest.
There is a shortcut in the shell to move up one directory level that looks like this:
jupyter-user:~$cd ..
.. is a special directory name meaning "the directory containing this one", or more succinctly, the parent of the current directory. Sure enough, if we run pwd after running cd .., we're back in /jupyter/jupyter-user/IntroShell/data:
jupyter-user:~$pwd
/jupyter/jupyter-cor22/IntroShell/data
The special directory .. doesn't usually show up when we run ls. If we want to display it, we can give ls the -a flag:
jupyter-user:~$ls -a
. .. shell-lesson-data
-a stands for "show all"; it forces ls to show us file and directory names that begin with ., such as .. (which, if we're in /jupyter/jupyter-user/IntroShell/data, refers to the /jupyter/jupyter-user/IntroShell directory) As you can see, it also displays another special directory that's just called ..
. means "the current working directory". It may seem redundant to have a name for it, but we'll see some uses for it soon.
Note that in most command line tools, multiple flags can be combined with a single - and no spaces between the flags: ls -F -a is equivalent to ls -Fa.
We can get back to the IntroShell directory the same way:
jupyter-user:$cd ..
jupyter-user:$pwd
/jupyter/jupyter-user/IntroShell
Let's try returning to the shell-lesson-data directory in the data directory, which we saw before. Last time, we used two commands, but we can actually string together the list of directories to move to shell-lesson-data in one step:
jupyter-user:$cd data/shell-lesson-data
Check that we've moved to the right place by running pwd and ls -F
If we want to move up one level from the data directory, we could use cd ... But there is another way to move to any directory, regardless of your current location.
So far, when specifying directory names, or even a directory path (as above), we have been using relative paths. When you use a relative path with a command like ls or cd, it tries to find that location from where we are, rather than from the root of the file system.
However, it is possible to specify the absolute path to a directory by including its entire path from the root directory, which is indicated by a leading slash. The leading / tells the computer to follow the path from the root of the file system, so it always refers to exactly one directory, no matter where we are when we run the command. This allows us to move to any directory from anywhere on the filesystem.
Run pwd and ls -F to ensure that we're in the directory we expect.
These then, are the basic commands for navigating the filesystem on your computer: pwd, ls and cd. Let's explore some variations on those commands.
What happens if you type cd on its own, without giving a directory?
jupyter-user:$cd
How can you check what happened? pwd gives us the answer!
jupyter-user:$pwd
/jupyter/jupyter-user
It turns out that cd without an argument will return you to your home directory, which is great if you've gotten lost in your own filesystem.
Relative Path Resolution
Using the filesystem diagram below, if pwd displays /Users/thing, what will ls -F ../backup display?
../backup: No such file or directory2012-12-01 2013-01-08 2013-01-272012-12-01/ 2013-01-08/ 2013-01-27/original/ pnas_final/ pnas_sub/
ls Reading Comprehension
Using the filesystem diagram below, if pwd displays /Users/backup, and -r tells ls to display things in reverse order, what command will display:
pnas_sub/ pnas_final/ original/
ls pwdls -r -Fls -r -F /Users/backup- Either #2 or #3 above, but not #1.
General syntax of a Shell Command¶
We have now encountered commands, options, and arguments, but it is perhaps useful to formalise some terminology.
Consider the command below as a general example of a command, which we will dissect into its component parts:
jupyter-user:$ls -F /
ls is the command, with an option -F and an argument /. We’ve already encountered options which either start with a single dash (-) or two dashes (--), and they change the behavior of a command. Arguments tell the command what to operate on (e.g. files and directories). Sometimes options and arguments are referred to as parameters. A command can be called with more than one option and more than one argument, but a command doesn’t always require an argument or an option.
You might sometimes see options being referred to as switches or flags, especially for options that take no argument. In this lesson we will stick with using the term option.
Each part is separated by spaces: if you omit the space between ls and -F the shell will look for a command called ls-F, which doesn’t exist. Also, capitalization can be important. For example, ls -s will display the size of files and directories alongside the names, while ls -S will sort the files and directories by size, as shown below:
jupyter-user:$cd ~/IntroShell/data/shell-lesson-data
jupyter-user: ls -s exercise-data
0 animal-counts 0 creatures 4 numbers.txt 0 proteins 0 writing
jupyter-user:$cd ~/IntroShell/data/shell-lesson-data
jupyter-user: ls -S exercise-data
proteins creatures writing animal-counts numbers.txt
Putting all that together the command ls -f / gives us a listing of the files and directories in the root directory /:
jupyter-user:$ls -F /
1 initrd.img@ lib/ proc/ sys/
bin/ initrd.img.old@ lib64/ root/ tmp/
boot/ jupyter/ lost+found/ run/ usr/
dev/ jupyterhub-proxy.pid media/ sbin/ var/
etc/ jupyterhub.sqlite mnt/ snap/ vmlinuz@
home/ jupyterhub_cookie_secret opt/ srv/ vmlinuz.old@
Nelle's Pipeline: Organizing Files¶
Knowing just this much about files and directories, Nelle is ready to organize the files that the protein assay machine will create.
First, she creates a directory called north-pacific-gyre (to remind herself where the data came from), which will contain the data files from the assay machine, and her data processing scripts.
Each of her physical samples is labelled according to her lab’s convention with a unique ten-character ID, such as ‘NENE01729A’. This ID is what she used in her collection log to record the location, time, depth, and other characteristics of the sample, so she decides to use it as part of each data file’s name. Since the assay machine’s output is plain text, she will call her files NENE01729A.txt, NENE01812A.txt, and so on. All 1520 files will go into the same directory.
Now in her current directory shell-lesson-data (change into your copy of this folder to foloow along), Nelle can see what files she has using the command:
jupyter-user:~$ls north-pacific-gyre/
This is a lot to type, but she can let the shell do most of the work through what is called tab completion. If she types:
jupyter-user:~$ls no
and then presses tab (the tab key on her keyboard), the shell automatically completes the directory name for her:
jupyter-user:~$ls north-pacific-gyre/
Pressing tab again does nothing, since there are multiple possibilities; pressing tab twice brings up a list of all the files.
If Nelle adds g and presses Tab again, the shell will append ‘goo’ since all files that start with ‘g’ share the first three characters ‘goo’.
jupyter-user:~$ls north-pacific-gyre/goo
To see all of those files, she can press Tab twice more.
jupyter-user:~$ls north-pacific-gyre/goo
goodiff.sh goostats.sh
This is called tab completion, and we will see it in many other tools as we go on.