This chapter is a brief introduction to the Unix shell. You'll learn why it is still in use after almost 50 years, how it compares to the graphical tools you may be more familiar with, how to move around in the shell, and how to create, modify, and delete files and folders.

How does the shell compare to a desktop interface?

Where am I?

How can I identify files and directories?

How else can I identify files and directories?

How can I move to another directory?

How can I move up a directory?

How can I copy files?

How can I move a file?

How can I rename files?

How can I delete files?

How can I create and delete directories?

Wrapping up

Manipulating files and directories

The commands you saw in the previous chapter allowed you to move things around in the filesystem. This chapter will show you how to work with the data in those files. The tools we’ll use are fairly simple, but are solid building blocks.

How can I view a file's contents?

How can I view a file's contents piece by piece?

How can I look at the start of a file?

How can I type less?

How can I control what commands do?

How can I list everything below a directory?

How can I get help for a command?

How can I select columns from a file?

What can't cut do?

How can I repeat commands?

How can I select lines containing specific values?

Why isn't it always safe to treat data as text?

Manipulating data

The real power of the Unix shell lies not in the individual commands, but in how easily they can be combined to do new things. This chapter will show you how to use this power to select the data you want, and introduce commands for sorting values and removing duplicates.

How can I store a command's output in a file?

How can I use a command's output as an input?

What's a better way to combine commands?

How can I combine many commands?

How can I count the records in a file?

How can I specify many files at once?

What other wildcards can I use?

How can I sort lines of text?

How can I remove duplicate lines?

How can I save the output of a pipe?

How can I stop a running program?

Combining tools

Most shell commands will process many files at once. This chapter shows you how to make your own pipelines do that. Along the way, you will see how the shell uses variables to store information.

How does the shell store information?

How can I print a variable's value?

How else does the shell store information?

How can I repeat a command many times?

How can I repeat a command once for each file?

How can I record the names of a set of files?

A variable's name versus its value

How can I run many commands in a single loop?

Why shouldn't I use spaces in filenames?

How can I do many things in a single loop?

Batch processing

History lets you repeat things with just a few keystrokes, and pipes let you combine existing commands to create new ones. In this chapter, you will see how to go one step further and create new commands of your own.

How can I edit a file?

How can I record what I just did?

How can I save commands to re-run later?

How can I re-use pipes?

How can I pass filenames to scripts?

How can I process a single argument?

How can one shell script do many things?

How can I write loops in a shell script?

What happens when I don't provide filenames?

Creating new tools

The Unix command line has survived and thrived for almost 50 years because it lets people do complex things with just a few keystrokes. Sometimes called "the universal glue of programming," it helps users combine existing programs in new ways, automate repetitive tasks, and run programs on clusters and clouds that may be halfway around the world. This course will introduce its key elements and show you how to use them efficiently.

Discover the Unix command line and how to use it to combine existing programs, automate repetitive tasks, and run programs on clusters and clouds in Shell.

Introduction to Shell

The Unix command line helps users combine existing programs in new ways, automate repetitive tasks, and run programs on clusters and clouds. 

Shell

Programming

This chapter explains what version control is and why you should use it, and introduces the most common steps in a common Git workflow.

What is version control?

Where does Git store information?

How can I check the state of a repository?

How can I tell what I have changed?

What is in a diff?

What's the first step in saving changes?

How can I tell what's going to be committed?

Interlude: how can I edit a file?

How do I commit changes?

How can I view a repository's history?

How can I view a specific file's history?

How do I write a better log message

Basic workflow

This chapter digs a little deeper into how Git stores information and how you can explore a repository's history.

How does Git store information?

What is a hash?

How can I view a specific commit?

What is Git's equivalent of a relative path?

How can I see who changed what in a file?

How can I see what changed between two commits?

How do I add new files?

How do I tell Git to ignore certain files?

How can I remove unwanted files?

How can I see how Git is configured?

How can I change my Git configuration?

Repositories

Since Git saves all the changes you've made to your files, you can use it to undo those changes. This chapter shows you several ways to do that.

How can I commit changes selectively?

How do I re-stage files?

How can I undo changes to unstaged files?

How can I undo changes to staged files?

How do I restore an old version of a file?

How can I undo all of the changes I have made?

Undo

Branching is one of Git's most powerful features, since it allows you to work on several things at once. This chapter shows you how to create and manage branches.

What is a branch?

How can I see what branches my repository has?

How can I view the differences between branches?

How can I switch from one branch to another?

How can I create a branch?

How can I merge two branches?

What are conflicts?

How can I merge two branches with conflicts?

Working with branches

This chapter showcases how Git allows you to share changes between repositories to collaborate at scale.

How can I create a brand new repository?

How can I turn an existing project into a Git repository?

How can I create a copy of an existing repository?

How can I find out where a cloned repository originated?

How can I define remotes?

How can I pull in changes from a remote repository?

What happens if I try to pull when I have unsaved changes?

How can I push my changes to a remote repository?

What happens if my push conflicts with someone else's work?

Collaborating

Version control is one of the power tools of programming. It allows you to keep track of what you did when, undo any changes you decide you don't want, and collaborate at scale with other people. This course will introduce you to Git, a modern version control tool that is very popular with data scientists and software developers, and show you how to use it to get more done in less time and with less pain.

Discover Git, a popular and modern version control tool for data scientists, and how you can use it work more efficiently, quickly, and with fewer errors.

Introduction to Git

This course is an introduction to version control with Git for data scientists. 

Data Science Courses

Data Science Tracks

Our Learning Experience

Get started with Python and Anaconda

Create Your Free Account

Loved by learners at thousands of companies