Git Tutorial: Git Revert Multiple Commits


Git is a popular version control system that allows developers to track changes to their code over time. One of the key features of Git is the ability to revert changes made to the codebase. Reverting changes means undoing one or more commits that have already been pushed to the repository.

Git revert is a powerful command that can be used to undo multiple commits at once. It creates a new commit that undoes the changes introduced by one or more previous commits. This is useful in situations where you want to remove a set of changes from your project history without losing any of the other work that has been done since then.

For example, let’s say you accidentally introduced a bug in your codebase and pushed several commits that included that bug. Instead of manually undoing each commit, you can use git revert to undo all of them at once, without losing any of the other changes made during that time period.

Overall, git revert is a valuable tool for managing your project’s history and ensuring that your codebase remains stable and free from errors.

Viewing Commit History

When working with Git, it’s important to keep track of the changes you make to your code. Git allows you to do this by creating commits, which are essentially snapshots of your code at a specific point in time. To view the commit history of your repository, you can use the `git log` command.

The `git log` command displays a list of all the commits in your repository, starting with the most recent commit. By default, each commit is displayed on a separate line and includes the commit hash (a unique identifier for the commit), the author, the date and time the commit was made, and the commit message (a brief description of the changes made in that commit).

Here’s an example of how to use `git log`:

$ git log
commit 6b2e4c7f9d01c4d1a4c24a45b7e8b8d0e7a3d328 (HEAD -> master)
Author: John Smith <>
Date: Mon Sep 27 10:00:00 2021 -0400</>

Add new feature

commit ceb59f3cfb5f6fd1c53bb8e5a5ce5f5d6e13c6fd
Author: Jane Doe <>
Date: Fri Sep 24 14:30:00 2021 -0400</>

Update documentation

commit f1cc4f8abcf67fb21ad042de19d9c72e7ca9eb96
Author: John Smith <>
Date: Wed Sep 22 09:15:00 2021 -0400</>

Fix bug in login process

In this example, we can see that there are three commits in the repository. The most recent commit (with the hash `6b2e4c7f9d01c4d1a4c24a45b7e8b8d0e7a3d328`) was made by John Smith on September 27, 2021 at 10:00 AM. The commit message indicates that a new feature was added.

By default, `git log` displays the entire commit history for the current branch. However, you can also specify a range of commits to display. For example, if you only want to see the commits made in the last week, you can use the `–since` option:

$ git log –since=1.week

This will display all the commits made in the last week.

Overall, using `git log` is an important tool for keeping track of your repository’s history and understanding what changes have been made over time.

Identifying Commits to Revert

Before we dive into the process of reverting multiple commits, it’s important to first identify which commits need to be reverted.

One way to do this is by using the `git log` command. This command displays a list of all the commits in reverse chronological order (i.e., most recent commit first). By default, `git log` shows the commit hash, author, date, and message for each commit.

To view the commit history for a specific branch, run `git log` followed by the branch name:

$ git log

This will display the commit history for that branch. You can use the up and down arrow keys to scroll through the list of commits.

To exit `git log`, press `q`.

Once you have identified the commits that need to be reverted, you will need to take note of their commit hashes. The hash is a unique identifier for each commit and is typically a long string of letters and numbers.

To find the hash for a specific commit, you can use `git log` with the `-1` flag followed by the commit message:

$ git log -1

Alternatively, you can use `git show`, which displays detailed information about a specific commit:

$ git show

This will display information such as the author, date, and changes made in that particular commit.

By using these commands, you can easily identify and locate the specific commits that need to be reverted.

Reverting a Single Commit

In git, reverting a commit means undoing the changes introduced by that commit. This can be useful when you want to undo a mistake or revert to a previous version of your codebase.

To revert a single commit, you can use the `git revert` command followed by the hash of the commit you want to revert. For example, if you want to revert the commit with hash `abc123`, you would run:

git revert abc123

This will create a new commit that undoes the changes introduced by the specified commit.

By default, `git revert` creates a new commit that reverses the changes from the specified commit using a “soft” revert. This means that the changes are undone in your working directory and staging area, but not committed yet. You still need to run `git commit` to finalize the revert.

If you want to perform a “hard” revert instead, which immediately applies the changes and commits them without creating an intermediate commit, you can use the `–no-commit` option:

git revert –no-commit abc123

This will apply the changes from the specified commit and stage them for committing, but not actually create a new commit yet. You can then review and edit the changes as needed before running `git commit` to finalize the revert.

Overall, reverting a single commit is straightforward with git revert. Just make sure you understand whether you want a soft or hard revert and use the appropriate options accordingly.

Reverting Multiple Commits

Sometimes, you may find yourself in a situation where you need to undo multiple commits. Git provides a simple solution for this through the `git revert` command.

To revert multiple commits, you can specify a range of commits using their hashes. For example, to revert the last three commits, you can use the following command:

git revert HEAD~3..HEAD

In this command, `HEAD~3` represents the third commit before the current commit (i.e., three commits ago), and `HEAD` represents the current commit. The `..` between them specifies a range of commits.

Alternatively, you can also specify the hashes of individual commits that you want to revert. For example, to revert two specific commits with hashes `abc123` and `def456`, you can use the following command:

git revert abc123 def456

When you run this command, Git will create new commit(s) that undo the changes introduced by the specified commit(s). It’s important to note that reverting a commit does not delete it from your repository history. Instead, it creates a new commit that undoes the changes introduced by the original commit.

In summary, reverting multiple commits in Git is straightforward with the `git revert` command. You can specify a range of commits or individual commit hashes to undo changes introduced by multiple commits.

Dealing with Conflicts

When you revert multiple commits, it’s possible that conflicts may arise. Conflicts occur when the changes made in the commits you’re trying to revert interfere with other changes that have been made in the codebase since then.

In order to resolve conflicts, you have two options: using a merge tool or manual editing.

Using a merge tool is the easier option, especially if you’re not comfortable manually editing code. Git comes with its own merge tool, which you can invoke by running `git mergetool` after encountering a conflict during the revert process. The merge tool will guide you through the conflict resolution process and help you decide which changes to keep and which to discard.

Alternatively, you can manually edit the code to resolve conflicts. This involves examining the changes made in each commit and deciding which ones to keep and which ones to remove. Once you’ve resolved all conflicts, you can continue with the revert process as usual.

It’s important to remember that conflicts can be time-consuming to resolve, especially if there are many changes involved. However, taking the time to resolve conflicts correctly will ensure that your codebase remains stable and functional.


In this tutorial, we covered how to revert multiple commits in Git using the git revert command. We learned that git revert is a safe way to undo changes and that it creates a new commit to record the reversion.

We also discussed how to use the git log command to find the SHA of the commit that we want to revert and how to use the git revert command with multiple SHAs to revert multiple commits at once.

Finally, we saw how to use the git revert command with the –no-commit option to make changes without immediately creating a new commit.

Git revert is a powerful tool that allows us to safely undo changes in our Git repository. If you’re working on a project and make a mistake, don’t panic! Just remember that git revert is there to help you. Give it a try for yourself and see how it can simplify your workflow.

How to Become a Data Scientist PDF

Your FREE Guide to Become a Data Scientist

Discover the path to becoming a data scientist with our comprehensive FREE guide! Unlock your potential in this in-demand field and access valuable resources to kickstart your journey.

Don’t wait, download now and transform your career!

Pierian Training
Pierian Training
Pierian Training is a leading provider of high-quality technology training, with a focus on data science and cloud computing. Pierian Training offers live instructor-led training, self-paced online video courses, and private group and cohort training programs to support enterprises looking to upskill their employees.

You May Also Like

Data Science, Tutorials

Guide to NLTK – Natural Language Toolkit for Python

Introduction Natural Language Processing (NLP) lies at the heart of countless applications we use every day, from voice assistants to spam filters and machine translation. It allows machines to understand, interpret, and generate human language, bridging the gap between humans and computers. Within the vast landscape of NLP tools and techniques, the Natural Language Toolkit […]

Machine Learning, Tutorials

GridSearchCV with Scikit-Learn and Python

Introduction In the world of machine learning, finding the optimal set of hyperparameters for a model can significantly impact its performance and accuracy. However, searching through all possible combinations manually can be an incredibly time-consuming and error-prone process. This is where GridSearchCV, a powerful tool provided by Scikit-Learn library in Python, comes to the rescue. […]

Python Basics, Tutorials

Plotting Time Series in Python: A Complete Guide

Introduction Time series data is a type of data that is collected over time at regular intervals. It can be used to analyze trends, patterns, and behaviors over time. In order to effectively analyze time series data, it is important to visualize it in a way that is easy to understand. This is where plotting […]