The Terminal: First Steps and Useful Commands

Windows

The Windows terminal is a modern and feature-rich application that gives you access to the command line, multiple shells, and advanced customization options. If you have Windows 11 or above, chances are that the Windows terminal is already present on your machine. Otherwise, you can download the application from the Microsoft Store or from the official GitHub repository.

Before continuing with this tutorial, you need to get the terminal working on your Windows computer. You can follow the Your Python Coding Environment on Windows: Setup Guide to learn how to install the Windows terminal.

After you install the Windows terminal, you can find it in the Start menu under Terminal. When you start the application, you should see a window that looks like this:

It can be handy to create a desktop shortcut for the terminal or pin the application to your task bar for easier access.

Linux

You can find the terminal application in the application menu of your Linux distribution. Alternatively, you can press Ctrl+Alt+T on your keyboard or use the application launcher and search for the word Terminal.

After opening the terminal, you should see a window similar to the screenshot below:

How you open the terminal may also depend on which Linux distribution you’re using. Each one has a different way of doing it. If you have trouble opening the terminal on Linux, then the Real Python community will help you out in the comments below.

macOS

A common way to open the terminal application on macOS is by opening the Spotlight Search and searching for Terminal. You can also find the terminal app in the application folder inside Finder.

When you open the terminal, you see a window that looks similar to the image below:

After you launch the terminal application, you’ll see a window that waits for commands. That’s similar to when you’re interacting with a Python script that expects user input.

If you want to interact with the terminal, then you need to know which terminal commands you can enter to proceed. In the next section, you’ll learn about basic terminal commands that’ll help you get started.

Navigate Your File System

The file system is the hierarchical structure of directories and files on a computer. It’s usually what you see when you open a GUI file system application like Windows Explorer or the macOS Finder. It also happens to be an excellent place to start your terminal journey, but again, you’re just dipping a toe into all the terminal’s capabilities here.

The folder that you have currently open in a file system is the current working directory (cwd). As you’ll notice, you use the working directory as a reference point for many file system operations. Understanding the file system and the current working directory as a state is important for effectively navigating and managing files and directories in the terminal.

After you’ve opened the terminal app, you usually start in the user folder of your operating system. You see a command prompt that’s waiting for your input. As you’ll learn, you can use a wide variety of commands as input. But some common commands are the ones to navigate the file system.

To get things started, find out what your current working directory is:

$ pwd
/Users/realpython

The pwd command stands for print working directory, which is the command that you use to determine your current location within the file system. Here pwd shows that the current working directory is /Users/realpython.

The working directory is the current directory that you’re operating in. It’s where commands will be executed by default.

PS> (cat ENV:Path) -Split ";"

$ echo "${PATH//:/\n}"

To see which files and folders the/Users/realpython directory contains, you can use ls, which is short for list:

$ ls
Applications          Movies
Desktop               Music
Documents             Pictures
Downloads             Public
Library

When you type ls and press Enter, you see a list of all the items in the current working directory. In this case, the example shows the folders that you commonly find in the user directory on a macOS machine.

You can also use the -a flag with the ls command, which stands for all. The -a flag shows you all the items in the current working directory, including the hidden items.

Another flag that you can use is -l, which stands for long. When you use this flag along with ls, the command shows you detailed information about the items in the current working directory.

You can also combine these flags to show detailed information about all the items, including the hidden ones, by using ls -al:

$ ls -al
total 80
drwxr-xr-x+  25 realpython  staff    800 Nov 26 11:51 .
drwxr-xr-x    6 root        admin    192 Nov  7 13:22 ..
-rw-r--r--@   1 realpython  staff  14340 Nov  7 16:04 .DS_Store
drwx------  134 realpython  staff   4288 Nov  8 18:37 .Trash
drwx------@   3 realpython  staff     96 Dec  3  2021 Applications
drwx------@  22 realpython  staff    704 Nov  7 16:00 Desktop
drwx------+   4 realpython  staff    128 Nov 17  2021 Documents
drwx------+   3 realpython  staff     96 Nov  1  2021 Downloads
drwx------@  86 realpython  staff   2752 Nov  7 21:08 Library
drwx------    6 realpython  staff    192 Jul 12 14:53 Movies
drwx------+   4 realpython  staff    128 Nov 26  2021 Music
drwx------+   4 realpython  staff    128 Nov  1  2021 Pictures
drwxr-xr-x+   4 realpython  staff    128 Nov  1  2021 Public

The output will show the file type, permissions, owner, size, and timestamp of all the items in the current working directory, including the hidden files and folders. Here, for example, the hidden items are .DS_Store and .Trash.

Hidden files and folders aren’t displayed by default. That’s okay for casual users. But for you as a developer, hidden items can be of interest. They often store configuration data or settings for various applications or the system itself.

The output above may be a bit overwhelming at first. Have a look at this line to understand the output better:

drwx------@  22 realpython  staff    704 Nov  7 16:00 Desktop

This line gives you valuable information about an item. There’s a directory named Desktop. The last modified date is November 7 at 16:00, and it has a size of 704 bytes.

Apart from that, you can see information about the owner and group permissions. If you want to learn more about the file system permission notation, then you can check out the notation of traditional Unix permissions.

Each folder in the output of ls represents a subfolder that’s inside your current working directory. To change the current working directory into the Desktop/ subfolder, you use the change directory command, cd:

$ pwd
/Users/realpython
$ cd Desktop
$ pwd
/Users/realpython/Desktop

When you enter cd followed by a directory name, it’ll change the current working directory to the specified directory. After you run the command cd Desktop, the current working directory changes to /Users/realpython/Desktop.

Note that you don’t specify a slash / or drive indicator like C:\ at the beginning of Desktop. Calling a path like this indicates that you want to navigate into a path that’s relative to the directory that you’re in right now.

You used a relative path in the command above to navigate into a subfolder. Relative paths make it convenient to reference items in your file system because you don’t have to specify the complete path from the root directory. That being said, you can also change into any directory of your file system by using a complete or absolute path:

• Windows
• Linux + macOS

PS> cd C:\Users\realpython\Desktop
PS> pwd
C:\Users\realpython\Desktop

$ cd /Users/realpython/Desktop
$ pwd
/Users/realpython/Desktop

If you use cd with a path that doesn’t exist, then the terminal will print an error. You’ll soon learn how to create new directories. Before you do, make one last move in your file system.

To move one directory up, you usually don’t use the name of the parent folder but two dots:

$ cd ..
$ pwd
/Users/realpython

The two dots (..) represent the parent directory of the current directory. Using cd .. moves you up one directory in the file system hierarchy.

In a GUI file system application like Windows Explorer or the macOS Finder, you’d click little folder icons with your mouse cursor. In the terminal application, you use commands to perform tasks—for example, cd to move between folders and ls to get an overview of the items in a directory.

Create Files and Folders

In this section, you’ll learn how to create and manage files and folders directly from the terminal with some new commands. Additionally, you’ll continue to list the contents of a directory with ls and move between folders with cd, just like you learned before.

With the knowledge from this section, you’ll be able to create and organize your projects from within the terminal.

Start by making sure that your current working directory is the Desktop. Then, use mkdir to create a new folder named rp_terminal:

• Windows
• Linux + macOS

PS> cd C:\Users\realpython\Desktop
PS> pwd
C:\Users\realpython\Desktop
PS> mkdir rp_terminal

$ cd /Users/realpython/Desktop
$ pwd
/Users/realpython/Desktop
$ mkdir rp_terminal

You use the mkdir command to create a new directory. The command stands for make directory. Here, you name the new directory rp_terminal.

Next, move into rp_terminal/ and create a new file named hello_terminal.py. Select your operating system below and use your platform-specific command accordingly:

• Windows
• Linux + macOS

PS> cd rp_terminal
PS> ni hello_terminal.py

$ cd rp_terminal
$ touch hello_terminal.py

Use the long format of ls to verify that you created the file successfully:

$ ls -l
total 0
-rw-r--r--@ 1 realpython  staff  0 Nov 27 12:09 hello_terminal.py

The 0 between the group and the timestamp indicates that hello_terminal.py is currently empty. You’ll use the echo command to add content to hello_terminal.py in a moment. Before you do so, have a look at what echo does when you type the command followed by some text:

$ echo 'print("Hello, terminal!")'
print("Hello, terminal!")

As a Python developer, you know that the text you just provided to echo is a print() function call. However, for the echo command, it’s a plain string, which it outputs back into the terminal. More specifically, the echo command sends the string to the standard output stream (stdout).

The stdout is the default destination for data that a command-line program sends. The data is displayed on the screen, but you can tell the terminal to redirect stdout to a file:

$ echo 'print("Hello, terminal!")' > hello_terminal.py

Again, you’re using echo to output a given string. But this time, you use the caret symbol (>) to send the output into hello_terminal.py.

One way to check if the command worked is to list the contents of your folder again:

$ ls -l
total 8
-rw-r--r--@ 1 realpython  staff  26 Nov 27 12:12 hello_terminal.py

Perfect, the size of hello_terminal.py is 26 bytes now. To verify that it contains the print() function call, you can use the cat command:

$ cat hello_terminal.py
print("Hello, terminal!")

Disappointingly, the cat command doesn’t have to do anything with cats. It’s short for concatenate.

When you use cat with multiple files as arguments, you can concatenate them and display the contents one after another. If you use cat with only one file, then cat is a convenient way to display the contents of a file in the terminal.

Now that you know that hello_terminal.py contains valid Python code, you can run the Python script:

$ python hello_terminal.py
Hello, terminal!

When you’re using the python command, the terminal looks for the Python executable in your PATH.

If you run the python command without any arguments, then you’ll launch the interactive Python interpreter, also known as the REPL. When you run the command with a script file as an argument, then Python runs the provided script.

In this case, you’re executing hello_terminal.py, and you see the output of your print() function directly in the terminal. This works because Python’s print() uses stdout by default.

With the knowledge gained in this section, you can now create, edit, and inspect Python files within the terminal. You’re now well equipped to move on to working with a command-line tool that’s essential on your journey as a Python developer. It’s called pip, and it enables you to include external packages in your Python projects.

Create a Virtual Environment

Python has the built-in venv module for creating virtual environments. This module helps you create virtual environments with an isolated Python installation. Once you’ve activated the virtual environment, you can install packages into this environment. The packages that you install into one virtual environment are isolated from all the other environments on your system.

You can follow these steps to create and activate a virtual environment named venv:

• Windows
• Linux + macOS

PS> python -m venv venv
PS> venv\Scripts\activate
(venv) PS>

$ python -m venv venv
$ source venv/bin/activate
(venv) $

Note that the command prompt has changed. This is a reminder that you’re working within the indicated virtual environment.

When you activate a virtual environment with Python’s venv module, you’re adding a new entry to the PATH environment variable. The new entry points to the location of the virtual environment’s Python executable. This ensures that when you run Python commands or scripts, they’ll use this specific Python executable instead of any other version of Python that may be installed on your system.

Install a Package

In this section, you’ll install the Rich library by Will McGugan, which enables you to create colorful text user interface (TUI) applications for the terminal.

Before you install rich, check which Python packages are currently installed in your virtual environment:

(venv) $ python -m pip list
Package    Version
---------- -------
pip        22.3
setuptools 65.5.0

Running python -m pip list lists all the packages installed in the current environment. Both pip and setuptools are default packages that you’ll find when you start a new virtual environment.

To install rich, use the command below:

(venv) $ python -m pip install rich
Collecting rich
  ...
Installing collected packages: commonmark, pygments, rich
Successfully installed commonmark-0.9.1 pygments-2.14.0 rich-13.0.1

Besides rich, you also installed some other dependencies that you need when you want to use rich. To check all the currently installed packages, you can run python -m pip list again:

(venv) $ python -m pip list
Package    Version
---------- -------
commonmark 0.9.1
pip        22.3
Pygments   2.14.0
rich       13.0.1
setuptools 65.5.0

To see the capabilities that rich offers, run rich without any arguments:

(venv) $ python -m rich

Depending on your terminal’s capabilities, you should see examples that look like this:

In the screenshot above, you can get an impression of what you can do with the rich library. The terminal doesn’t have to be a dark place after all!

Now that your screen is filled from top to bottom, you may want to clear your terminal window again. For this, you can use the clear command:

(venv) $ clear

You use the clear command to clear the terminal screen. It removes all the text and content currently displayed on the terminal, leaving a blank screen. For example, you might want to clear the terminal screen before you run new commands.

In some terminals, you can use Ctrl+L or Cmd+L as keyboard shortcuts to clear the screen.

You’ve learned how to use pip directly from the terminal in this section. Knowing how to use pip in the terminal is crucial for any Python developer, as it allows you to effectively manage and update the packages that you use in your projects.

If you want to learn more about virtual environments and pip, then you can check out Real Python’s primer on Python virtual environments and tutorial on how to use Python’s pip to manage your projects’ dependencies. Both are essential tools to make your life as a Python developer more convenient.

Another helpful tool to manage your projects is Git. Read on to learn how to improve your terminal skills and dive into the world of version control with Git.

Initiate a Git Repository

The first step in using Git is to initialize a repository. A repository is a container that holds all your project files, folders, and metadata.

Create a new Git repository with the command below:

$ git init
Initialized empty Git repository in
⮑ /Users/realpython/Desktop/rp_terminal/.git/

When you run the git init command, Git creates an empty repository in the current working directory. This creates a new subdirectory named .git/ that contains all of the necessary repository files.

After initializing the repository, you can check the status of your repository:

$ git status
On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
    hello_terminal.py
    venv/

nothing added to commit but untracked files present (use "git add" to track)

The git status command shows your repository’s current status. It displays which branch you’re on and whether or not there are any commits.

A Git commit is a snapshot of the changes made to the files in a Git repository. When you make changes to your files and save them, you can take a snapshot of those changes by creating a commit on a branch. As you make new commits, the branch points to the latest commits.

In this case, you’re on the main branch, and there are no commits yet. You can also create new branches to work on new features or bug fixes and then switch between branches as needed. If you want to, then you can create multiple branches to work on various versions of your codebase simultaneously.

Additionally, git status shows you which files are untracked, meaning that Git isn’t tracking them. You might want to ignore specific files and folders, such as the venv/ folder, so that Git won’t track them.

You can ignore files in Git by creating a .gitignore file and listing the files and folders that you want to ignore in that file:

$ echo "venv" > .gitignore

As you learned before, this command creates a new file named .gitignore and writes venv to it. Verify the current items in your Git repository by leveraging another command that you already know:

$ ls -a
.          .git          hello_terminal.py
..         .gitignore    venv

You now have a .gitignore file next to your hello_terminal.py file, your venv/ folder, and the .git/ folder. To check if Git ignores the venv/ folder, run git status again:

$ git status
On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
    .gitignore
    hello_terminal.py

nothing added to commit but untracked files present (use "git add" to track)

Perfect, Git now only shows .gitignore and hello_terminal.py as untracked files. Git knows the files are there, but you haven’t yet added them to the repository.

Track Files With Git

When you start a new project, you’ll likely want to keep track of your changes over time. In the previous section, you initialized a new repository with git init. Now it’s time to start tracking files.

You use the git add command to tell Git which files you want to track:

$ git add .

Remember the dot . in the directory listing before? The dot refers to the current directory. Using . at the end of the git add command tells Git to track all the files in the current directory. Once you’ve added files to the repository, you can check the status of your files using the git status command:

$ git status
On branch main

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
    new file:   .gitignore
    new file:   hello_terminal.py

You can see in the output that the files hello_terminal.py and .gitignore are added and ready to be committed:

$ git commit -m "Initiate git repository"
[main (root-commit) 7b20833] Initiate git repository
 2 files changed, 2 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 hello_terminal.py

With the git commit command, you take a snapshot of the current state of your files and store it in the repository’s history. The -m flag allows you to include a message describing your changes. The output shows the branch that you’re on and the number of files changed.

After you commit any changes, it’s a good idea to check the status of your Git repository again:

$ git status
On branch main
nothing to commit, working tree clean

You can see in the output that there’s nothing to commit, meaning that all changes have been successfully committed.

The workflow that you used in this section is typical when you use Git in the terminal. You use the git add command to tell Git which files to track. Then you use git commit to take a snapshot of the current state of your files and save it to the repository’s history.

Additionally, it’s good practice to use git status often to check the current status of your repository.

While you’ve gotten an introduction to using Git in the terminal, there’s much more that Git has to offer you as a Python developer. If you’re interested in learning more about Git, then you can check out the introduction to Git and GitHub for Python developers and dive even deeper with advanced Git tips for Python developers.