Forem: Fueler - Your Developer Portfolio

Git Reset vs. Git Revert: When to Use Each Command

Rahul — Wed, 05 Apr 2023 15:46:34 +0000

Create your Dev Portfolio today at Fueler.

Have you ever committed changes to a repository, only to realize that it wasn't what you meant to do?

Don't worry—we've all been there.

The good news is that there are smarter ways of undoing commits than simply rolling back the entire repository.

At its core, Git is a version-control system that lets you track and manage changes in your projects.

It offers several powerful commands which can help you undo commits and restore a clean state for your project.

These commands are Git Reset and Git Revert.

But what’s the difference between them? When should you use each command?

In this article, we'll look at both Git Reset and Git Revert in detail and explain when it’s best to use each one.

That way, you’ll never have to worry about messing up your commits again! Let's start by learning about the basics of Git Reset vs Revert.

What Is Git Reset?

Git reset is one of the most powerful commands in git. It can help you reset your local branch to any commit in the branch's history, going back in time as far as you need.

There are three types of Git reset:

Soft: This just resets the pointer that references your commits to whatever you specify (for example, a previous commit). Your working directory and staging area aren't changed at all.
Mixed: The mixed option moves your HEAD pointer back but leaves everything else untouched. In other words, any committed changes are still saved, but the staging index and working directory are updated with the contents of HEAD at that commit.
Hard: If you want to erase all commits after a certain point, the hard option is your best bet. Once applied, any changes committed after the target commit are permanently discarded. It’s important to note that this resets both your current branch and staging index and makes them look exactly like they did when you set it back.

Git reset is best used when you need to undo changes made in a single file (or fewer) and don’t want to discard any of your other work or commits. But be careful—a hard reset can cause serious headaches if used improperly!

Code example: how to perform a soft reset using Git command line

First, open your terminal and navigate to the repository you want to work with.
To perform a soft reset, use git reset --soft HEAD~1 command

This will undo the last commit, but keep the changes in the staging area so that you can modify them and commit again.

To check the status of your repository after the reset, use the git status command. This will show you the files that were changed in the last commit, which are now in the staging area.
To modify the changes and commit again, use:

    git add <file-name>

    git commit -m "New commit message"

This will add the modified changes to the staging area and create a new commit with a new message.

Note: It's important to be cautious when using git reset as it can delete commits and modify the history of your repository.

Always make sure to backup your work before using this command, and consider using git revert instead if you want to undo a commit without modifying the history.

What Is Git Revert?

Git revert is a command that allows you to undo a specified commit while preserving the rest of your history in the repository. It creates a new commit that undoes some or all changes of the specified commit, making Git revert an ideal way to undo a specific change to your repository.

When should you use Git revert?

Generally speaking, it's an effective way to undo changes in certain scenarios.

For example, if you've pushed code that breaks the build, has unforeseen bugs, or violates another team member’s work, Git revert should be your go-to command.

However, there are some risks and precautions to consider when using Git revert.

Like for example, always double-check that you're reverting the correct commit – if not, it could introduce its own bugs and issues.

It's also important to make sure there aren't any conflicts between branches with similar commits; this could cause problems when trying to merge branches in the future.

Overall, Git revert is a great tool for discreetly undoing changes and keeping your repository clean and organized. When used properly and with caution though, it can save you from any major blunders or missteps down the road.

How to revert a commit using Git command line

First, use the git log command to find the commit hash that you want to revert. The commit hash is a long string of characters that uniquely identifies the commit.

commit 946763c97874be293696ba2c119c97ff1b7cb3
Author: rahuldotbiz <gamerrahul1122@gmail.com>
Date:   Thu Mar 16 14:02:46 2023 +0530

    analytics removed
...

Once you have identified the commit hash, use the git revert command followed by the commit hash to create a new commit that undoes the changes made in the specified commit.
```
git revert 946763c97874be293696ba2c119c97ff1b7cb3
[master 4387c34] Revert "Add new feature"
 1 file changed, 1 deletion(-)
```
Git will open up a text editor where you can enter a commit message describing the revert. Once you save and close the editor, Git will create a new commit that undoes the changes made in the specified commit.

    Revert "Add new feature"

    This reverts commit 946763c97874be293696ba2c119c97ff1b7cb3.

    Reason for revert: This feature caused a regression in the application and needs to be reworked.

Finally, use the \git push\ \ command to push the new revert commit to the remote repository.

Comparing Git Reset and Git Revert

When undoing a commit, it's important to know the differences between git reset and git revert. They seemingly do the same thing, but their impacts are very different.

Git Reset

Git reset is a powerful command that should be used with caution. It moves the HEAD and the current branch pointer to the desired commit.

One of its benefits is that it affects only your local repository, while changes can be pushed to remote repositories with git push.

However, using this command has certain drawbacks as well—if you want to go back further than what you've already committed, it can only be done from the staging area.

Git Revert

Unlike git reset, git revert does not move any of your branches or change anything about them—it just creates a new commit that is the opposite of the one you specify.

In other words, if you have a commit that adds some lines of code, running git revert on that commit adds another commit that removes those lines again.

This allows for more flexibility in terms of going back further in your history and making changes to existing commits.

When it comes to making changes in your repository, it's important to understand when it's appropriate to use one command over another — otherwise, you could end up with unexpected results.

Of course, both commands can be used on local or remote repositories but there are certain circumstances in which one is better than the other.

Knowing this will help make sure you're making the right choices when using either command.

Conclusion

To recap, if you want to make an old commit disappear from Git history, use git reset. If you just want to leave a commit intact but undo the changes it introduced, use git revert.

As a general rule of thumb, try to use git revert first. If you’re dealing with a messy merge conflict, though, you may want to use git reset to go back to a known good state before trying the merge again.

Just remember that using git reset to undo commits is a bit more risky and should be used with caution.

Understanding the differences between “git reset” vs “git revert” can save you a lot of time and headaches in the long run.

But in the next, we'll learn more about how to undo multiple commits using Git interactive rebase.

Create your Dev Portfolio today at Fueler.

Learn how to create Python Dictionary | Beginners Guide

Rahul — Wed, 05 Apr 2023 12:48:04 +0000

Create your Dev Portfolio today at Fueler.

Welcome to the world of Python dictionaries! Whether you're a beginner looking to get your feet wet or an experienced programmer taking a refresher course, understanding dictionaries is an essential part of learning the language.

So what exactly is a dictionary?

Simply put, a Python dictionary is an unordered collection of key-value pairs. This means that each piece of data has associated with it a key that can be used to access it.

As such, this makes dictionaries incredibly useful for organizing large sets of data in an efficient manner.

In Python, dictionaries are used to store data in a way that’s both organized and accessible.

Since data stored in dictionaries is organized into key-value pairs, retrieving or updating this information can be done quickly and easily—without having to remember exact locations or indices within the structure itself.

This makes them easy to use and master for any level of programmer learning Python.

In short, whether you’re dealing with small sets of data or large ones, Python dictionaries will make your life (and working with Python) much easier!

Creating a Dictionary

Creating a dictionary in Python is a simple and effective way to start making your data accessible and usable in your code.

There are a few different ways that you can use to create a dictionary, each one has its strengths and weaknesses.

Using the dictionary constructor to create an empty dictionary: The simplest way to create an empty dictionary is to use the dict() constructor. This method provides you with an empty structure that you can populate with keys and values.

# Create an empty dictionary using the dict() constructor
my_dict = dict()

# Add key-value pairs to the dictionary
my_dict['name'] = 'Rahul'
my_dict['age'] = 18
my_dict['city'] = 'Amsterdam'

# Print the dictionary
print(my_dict) // returns {'name': 'Rahul', 'age': 18, 'city': 'Amsterdam'}

Using curly braces ({}) to create a dictionary with initial values: If you know some of the initial key-value pairs you want in your dictionary, you can use curly braces {} to quickly set up the structure. This method is ideal for quickly creating dictionaries with an initial set of data.

# create a dictionary with initial values using curly braces
car = {'make': 'Jaguar', 'model': 'Ftype', 'year': 2023, 'color': 'maroon'}

# print the dictionary
print(car)

Creating a dictionary with nested dictionaries: If you need more complex structures than simple key-value pairs, then this method will come in handy. It allows you to make nested dictionaries, which is useful when creating complex data structures like graphs or trees.

# Creating a dictionary with nested dictionaries
employees = {
    'John': {
        'position': 'Manager',
        'salary': 100000,
        'team': {
            'Mary': {
                'position': 'Developer',
                'salary': 70000
            },
            'Bob': {
                'position': 'Developer',
                'salary': 65000
            }
        }
    },
    'Alice': {
        'position': 'Director',
        'salary': 150000,
        'team': {
            'Sarah': {
                'position': 'Manager',
                'salary': 120000,
                'team': {
                    'Tom': {
                        'position': 'Developer',
                        'salary': 80000
                    }
                }
            }
        }
    }
}

# Accessing nested dictionary values
print(employees['John']['team']['Mary']['position']) # Output: Developer
print(employees['Alice']['team']['Sarah']['team']['Tom']['salary']) # Output: 80000

Above we have a dictionary called employees that contains nested dictionaries.

The first level of the dictionary contains the names of the employees as keys, and their information (position, salary, and team) as values.

The team key of each employee also contains a nested dictionary that contains the information of the employees in their team.

Accessing Dictionary Items

Now that you've created a dictionary, let's look at how you can access the data inside it. To do this, you'll need to use dictionary keys and values.

Retrieving Values Via Keys

The simplest way to access a value in a Python Dictionary is to use the key associated with it. Let's see from an example:

# Create a dictionary
phonebook = {"Rahul": 999999999, "Sunaina": 123456789, "SunainaFather": 456789123}

# Retrieve a value using a key
rahul_phone = phonebook["Rahul"]

# Print the retrieved value
print(rahul_phone)

Above we create a dictionary called phonebook with three key-value pairs. We then use the key "Rahul" to retrieve the associated value (999999999) from the phonebook dictionary and assign it to a variable called rahul_phone.

Finally, we print the value of rahul_phone, which should output 999999999.

Using The Get() Method To Access Dictionary Items Safely

If you're not sure that the item exists in your Python Dictionary, then another option is to use the .get() method.

This allows you to safely retrieve items from your dictionary — or, if that item doesn't exist, then it will return None instead of throwing a KeyError.

For example:

# create a dictionary
my_dict = {'apple': 2, 'banana': 3, 'orange': 4}

# using the get() method
apple_count = my_dict.get('apple')
pear_count = my_dict.get('pear')

# print the results
print(apple_count)  # Output: 2
print(pear_count)   # Output: None

Above we have a dictionary my_dict with the key-value pairs {'apple': 2, 'banana': 3, 'orange': 4}.

We then use the get() method to safely retrieve the value associated with the key 'apple' and 'pear'. The value associated with 'apple' is 2, so apple_count is assigned the value 2. The key 'pear' is not in the dictionary, so pear_count is assigned the value None.

Handling KeyError Exceptions

When accessing dictionary items in Python, it's important to handle the possibility of a KeyError exception. This occurs when a key is not found in the dictionary. Let's understand this from a short example.

# Creating a dictionary with key-value pairs
my_dict = {"apple": 1, "banana": 2, "orange": 3}

# Retrieving a value using a non-existent key
try:
    value = my_dict["grape"]
except KeyError:
    print("The key 'grape' does not exist in the dictionary")

Above we are trying to retrieve a value from the my_dict dictionary using the key 'grape'. However, since this key doesn't exist in the dictionary, a KeyError exception will be raised.

To handle this exception, we can use a try-except block. The try block contains the code that may raise an exception, while the except block specifies how to handle the exception.

In this case, we are catching the KeyError exception and printing a message to inform the user that the key doesn't exist in the dictionary.

Modifying Dictionary Items

Another important part of working with dictionaries is knowing how to modify existing items in them.

On the surface, this might seem pretty simple—you just add it back in with a new value, right? Well, it's a bit more complex than that.

A great way to get started is by first learning the syntax: it requires brackets and quotation marks at certain points.

# Creating a dictionary with some initial values
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# Modifying an existing item in the dictionary
my_dict['age'] = 26

# Printing the updated dictionary
print(my_dict)

Above we first create a dictionary called my_dict with some initial key-value pairs. We then modify the value of the 'age' key to 26 by accessing it using the brackets and assigning the new value to it.

It's important to note that if the key you're trying to modify doesn't already exist in the dictionary, the above approach will create a new key-value pair.

If you don't want that to happen, you can use the update() method to modify existing items or add new ones.

# Creating a dictionary with some initial values
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# Modifying an existing item or adding a new one using the update() method
my_dict.update({'age': 26, 'gender': 'female'})

# Printing the updated dictionary
print(my_dict)

Here we use the update() method to modify the value of the 'age' key to 26 and add a new key-value pair for 'gender'. Note that the update() method takes a dictionary as an argument, and any matching keys in the dictionary will be updated with their corresponding values.

Modifying items in an existing dictionary requires some code literacy and trial and error, but once you have the syntax down, you'll be able to edit your dictionaries like a pro!

Dictionary Methods and Operations

Let's now look at some useful dictionary methods and operations.

`len()`

The len() function is great for finding out the length of a dictionary, that is, the number of items in a dictionary. You can use this to see how many items your dictionary contains.

In short, a simple len() statement will display how many keys and values are stored within your dictionary!

my_dict = {'apple': 2, 'banana': 3, 'orange': 1, 'pear': 4}

# Finding the length of the dictionary
length = len(my_dict)

print("The dictionary contains", length, "items.")

So here the len() function will return the number of key-value pairs in the dictionary, which is 4 in this case.

Checking if a key exists using the `in` keyword

The in keyword can be used to check if a key exists in a given Python Dictionary. Let's see a small example:

# Create a dictionary
my_dict = {"apple": 2, "banana": 3, "orange": 4}

# Check if a key exists using the in keyword
if "apple" in my_dict:
    print("The key 'apple' exists in the dictionary!")
else:
    print("The key 'apple' does not exist in the dictionary.")

In this example, we create a dictionary called my_dict with three key-value pairs. We then use the in keyword to check if the key "apple" exists in the dictionary. Since "apple" is a key in the dictionary, the output will be: The key 'apple' exists in the dictionary!.

If the key you are looking for does exist, then anything within the if statement will execute; otherwise, nothing happens—it's as simple as that!

Retrieving all Keys and Values of a Dictionary

You can retrieve all keys and values of a dictionary with two built-in functions: dict.keys(), which shows the keys to your dictionary; and dict.values(), which returns all values of the given Python Dictionary.

What's more, you can find out both keys and values by using the dict.items() method!

# Create a dictionary with some key-value pairs
my_dict = {'apple': 2, 'banana': 3, 'orange': 4}

# Retrieve all keys and values of the dictionary using the items() method
for key, value in my_dict.items():
    print(f'{key}: {value}')

Above we create a dictionary my_dict with some key-value pairs. We then use the items() method to retrieve all the keys and values of the dictionary, and iterate through them using a for loop.

Inside the loop, we print out each key and its corresponding value using string formatting.

Updating and Merging Dictionaries

Updating an existing Python Dictionary with new data is easy—simply use the update() method, which takes two parameters: one that contains all keys and values from another dictionary (the source) and another that points to an existing dictionary (the target).

# Updating a dictionary
dict1 = {'name': 'John', 'age': 30}
dict2 = {'age': 35, 'city': 'New York'}
dict1.update(dict2)
print(dict1)
# Output: {'name': 'John', 'age': 35, 'city': 'New York'}

# Merging two dictionaries
dict3 = {'name': 'Alice', 'gender': 'Female'}
dict4 = {'age': 25, 'city': 'Chicago'}
merged_dict = {**dict3, **dict4}
print(merged_dict)
# Output: {'name': 'Alice', 'gender': 'Female', 'age': 25, 'city': 'Chicago'

In the above example, we have two dictionaries dict1 and dict2. We update dict1 with the contents of dict2 using the update() method.

This changes the value of the 'age' key in dict1 to 35 and adds the 'city' key with the value 'New York' to dict1.

Next, we have two dictionaries dict3 and dict4. We merge these dictionaries into a new dictionary merged_dict using the {**dict1, **dict2} syntax, which combines the key-value pairs from both dictionaries into a single dictionary.

You're getting it right? Just take time to understand, it can be a bit confusing but when you get it, it's easy.

Iterating Through a Dictionary

Using a for loop to iterate through a dictionary

You can also use a for loop to iterate through a dictionary. A for loop is another way of repeating an action or set of actions over and over again. It's like a robotic machine, where you give it instructions and it will simply follow them.

Basically, what you do is tell the loop to go through each value in your dictionary, one at a time, and then execute the instructions that you have given it.

It will stop when it reaches the end of your dictionary. Here's an example:


# Create a dictionary of fruits and their colors

fruits = {"apple": "red", "banana": "yellow", "grape": "purple"}

# Loop through the keys and values of the dictionary

for fruit, color in fruits.items():

print(f"The {fruit} is {color}")

# Output:
# The apple is red
# The banana is yellow
# The grape is purple

In this example, we first create a dictionary called fruits that contains the names of different fruits as keys and their corresponding colors as values.

Then, we use a for loop to iterate through the keys and values of the fruits dictionary using the items() method. Inside the loop, we assign the key to the variable fruit and the value to the variable color.

Finally, we use the print() function to display a message for each fruit and its corresponding color.

The loop will stop when it reaches the end of the fruits dictionary.

Pretty cool right? Iterating with a for loop is just one of many ways to work with dictionaries in Python—there's plenty of other methods that you can explore!

items() method

item() method is used to retrieving keys and values. Let's see a simple example for this:

Suppose we have a dictionary that contains the names and ages of some individuals as key-value pairs. We can use the items() method to iterate through the dictionary and retrieve the name and age of each person as a pair.

# Creating a dictionary with names and ages of individuals
ages = {"Alice": 30, "Bob": 25, "Charlie": 35}

# Iterating through the dictionary using the items() method
for name, age in ages.items():
    print(name, "is", age, "years old")

#The output
Alice is 30 years old
Bob is 25 years old
Charlie is 35 years old

Conclusion

In conclusion, Python dictionaries make it easy to manage complex data. They're a powerful tool for data manipulation, and a great way to store and access information. With this beginner's guide, you now have the information you need to start using Python dictionaries for yourself.

You'll be able to create, modify, and iterate over dictionaries with ease. Go ahead and get started now—you'll be glad you did.

Create your Dev Portfolio today at Fueler.

A Step-by-Step Guide to Comment Blocking in Python

Rahul — Wed, 05 Apr 2023 12:27:30 +0000

If you're new to coding in Python, you may be wondering what comment blocking is and how it can help you.

Well, comment blocking is a process that helps you organize your code, which is important for readability, maintainability, and debugging.

By using comment blocks, you can separate different parts of your code into logical sections.

This makes it easy to quickly find parts of a program when making changes or troubleshooting issues.

The block comments also serve as helpful reminders for yourself or other coders who need to make changes in the future.

Comment blocks help ensure that your code remains organized and easy to work with. It also allows you to quickly jump between different functional parts of a program without having to manually search through the codebase.

Create your Dev Portfolio today at Fueler.

How to Write Single Line Comments in Python

Writing comments in your code is a great way to organize it, keep track of your progress, and make sure that anyone else who might use your code can understand it more easily. In Python, you can create single line comments using a pound (#) symbol at the beginning of a line.

When you use this symbol in Python, anything that follows the # is considered part of the comment-in other words, it won't be read by the interpreter at runtime.

This is useful for adding explanations and context to your code without changing its behavior.

For instance, if you’re writing a function that will calculate the tax on a purchase, you might include an explanatory comment like this:

# calculate tax on a purchase
tax_amount = purchase_amt * 0.085

Including helpful comments like this allows anyone looking at your code to understand what each line does and why it’s there. It also creates an easier path for debugging later down the road.

How to Write Multi Line Comments in Python

If you want to write a multi-line comment in Python, then you can use the triple quotation marks. This is useful when you are writing long comments that need to be broken into multiple lines.

Here's an example of what a multi-line comment would look like in Python:

""" This is a

multi-line comment

in Python """

You can also use the multi-line comment in your code. For example, if you are writing a large block of code and you want to add some explanatory comments, then you can use the triple quotation marks to do this.

The comments will appear after the code block, which makes them easier to read and understand.

Another great thing about using the triple quotation marks is that they allow you to add more detailed comments than a single line of text would allow.

This makes it easier to explain what is happening in your code and provide helpful notes for other developers who might be reading your code.

Benefits of Comment Blocking for Python Programming

You might be wondering what the benefits are that come with comment blocking in Python;

after all, why bother when it can feel like an extra step in your programming workflow?

As it turns out, there are some great reasons to get on board with comment blocking.

1. Testing made easier

Comment blocking helps you to quickly test snippets of code within larger projects, and means you don’t have to keep cutting out desired portions from within a program and pasting them into a new file.

Because comment blocks exist outside of the main code, you can easily pull them out for testing purposes without worry.

2. Improved clarity

Comment blocking helps both yourself and other readers of your code understand your logic quickly and easily;

each block is divided from the main program, so at a glance it’s easy to understand which pieces of code are related.

This makes project troubleshooting a breeze for other programmers who may be collaborating on your project.

3. More efficient coding

Comment blocking allows you to keep all your related functions in the same area and significantly reduces the amount of scrolling required when searching through longer programs.

Having the ability to quickly move between related functions can save huge amounts of time in development.

Commonly Asked Questions About Python Comment Blocking

Comment blocking can seem like an intimidating task for the beginner Python coder, but don’t worry—it’s actually not so hard, once you understand the fundamentals.

To help you get started, here are some of the most commonly asked questions about comment blocking in Python.

1. Is it possible to block comments in Python?

Yes! Comment blocking is actually a straightforward process in Python. All you need to do is use the “#” symbol before any text that you want to be blocked, and it will be ignored by the compiler.

2. How will comment blocking affect code execution?

Comment blocking won't affect code execution—in fact, it's completely invisible to the compiler.

You can use comment blocking to create notes or reminders for yourself and other coders without affecting the program's functionality.

3. Is everything between /* and */ ignored by the program in Python?

No, everything between /* and */ is not ignored in Python because this is not the syntax used for comments in Python. In Python, single-line comments are denoted by a hash symbol (#) and multi-line comments can be created using triple quotes (''' or """).

Conclusion

Commenting in Python is a great way to organize and simplify your code. With the help of this guide, you've learnt how to block comments to make your code more readable and easier to debug.

By following the steps outlined in this tutorial, you can now confidently add comments to your Python code and know that it will be blocked properly.

So be sure to practice this skill and enable yourself to comment with ease in the future!

Create your Dev Portfolio today at Fueler.

Ultimate Guide to Big O Notation in 2023 | A Comprehensive Cheatsheet

Rahul — Tue, 04 Apr 2023 13:00:46 +0000

If you're feeling a bit overwhelmed by the concept of Big O Notation and need a quick cheat sheet to help you understand it, then you've come to the right place!

In this comprehensive guide, we'll give you all the tips and tricks you need to learn Big O Notation quickly and easily.

From the basics of Big O to some of its most common symbols, we'll cover what you need to know to help you in exams or just for coding at home.

Whether you're new to computer science or already have some coding skills, this cheat sheet will give you all the information you need about Big O Notation in one easy-to-follow guide.

So let's dive in!

Introduction to Big O Notation

If you're a programmer or studying computer science, you've probably heard of Big O notation. It's an important tool used in the analysis of algorithms and helps to determine the time complexity of a given software or program.

It's also essential for optimizing code and understanding how efficient your software performs.

An easy-to-follow Big O cheatsheet can help make understanding this complex concept simpler.

Big O notation is used to describe the runtime or space complexity of an algorithm.

A high-level description can be provided quickly for a simple algorithm without diving into every detail about how it works.

In Big O notation, two variables are used - the input size (n), and the amount of time it takes to execute (t). The notation gives us a way to compare algorithms based on their execution times - that is, to find out which algorithm is more efficient when dealing with different input sizes.

The purpose of our cheatsheet is to provide an overview of Big O notation, including its symbols, examples, and rules for determining time complexity.

To make things easier for those just starting out with Big O notation we'll provide examples using simple algorithms so you can better understand the concepts at hand.

Also included are resources to deepen your understanding should you want to explore further into this topic.

Basic Concepts

If you’ve been brushing up on algorithms and data structures, you may have heard of something called Big O Notation. But what is Big O Notation and why is it so important? Let's dive into this topic with a refresher on the basics to get you up to speed.

What Does "O" Stand For?

The "O" stands for the Greek letter "Omega," which essentially means infinite or unbounded. So when someone says something has an "O(n)" time complexity, they're talking about the runtime of an algorithm being relative to the size or quantity of input data (n).

What is Time Complexity?

Time complexity is a measure of how much time it takes for a computer algorithm to run and is usually expressed using Big O notation. It's a useful tool to help you understand how efficient certain algorithms are and how they scale with extra data.

Basically, the time complexity of an algorithm will determine how fast it can complete a task and how much memory it will require for larger datasets.

What is Space Complexity?

When it comes to understanding Big O Notation, one of the key elements that can define the performance of an algorithm is space complexity. Space complexity measures the amount of memory that an algorithm requires for it to execute, and is expressed in terms of the size of the input.

Understanding Asymptotic Behavior

Understanding Big O Notation requires understanding asymptotic behavior, which is when a function grows increasingly larger or smaller than some base value.

That increase can be taken at different rates—linear (O(n)), logarithmic (O(log n)), quadratic (O(n^2)), cubic (O(n^3))—and so on.

There are also common functions in Big O Notation that include constant functions (all runtimes are equal), exponential functions (runtime increases exponentially), and loglinear functions (when the runtime increases linearly with each additional input).

Now that you have a better understanding of the basic concepts behind Big O Notation, you're ready to explore this mathematical tool further!

Below this section, you will look at the key time and space complexities, explanations, and examples.

Big O Notation Cheatsheet

Learning Big O notation can be a challenge, and you may not have time to become an expert. That's why we've created this Big O Notation cheat sheet for you to bookmark and refer to as needed.

Let's quickly break it down:

Constant Time - O(1)

This is the fastest time complexity class — it means an algorithm takes the same amount of time regardless of the input size. A good example would be when you add two numbers together — it takes exactly the same amount of time whether you are adding 1 + 1 or 10^256 + 10^256.

Let's understand this from a simple example:

def add_numbers(a, b):
    return a + b

In the above example, the function add_numbers takes two integer inputs a and b and returns their sum. No matter what the values of a and b are, the function will always take the same amount of time to execute as it only performs a single operation of adding the two inputs together.

Logarithmic Time - O(log n)

This is a bit slower than constant time, but still pretty fast. Put simply, it means that if your input size doubles, the algorithm will only take one more step to finish which is amazing compared to other complexity classes.

An example would be searching a sorted array — as you iterate through it, the search space gets halved after each check since “binary search” divides and conquers approach is used.

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

In the above example, the binary search algorithm takes a sorted array "arr" and a target value "target" as input. It initializes two pointers "left" and "right" to the beginning and end of the array respectively, and then repeatedly divides the search space in half by computing the midpoint "mid".

If the target value is found at the midpoint, the function returns the index of the midpoint. If the target value is less than the midpoint, the function continues the search on the left half of the array by updating the "right" pointer.

Otherwise, the function continues the search on the right half of the array by updating the "left" pointer.

Linear Time - O(n)

This complexity type is actually quite slow compared to the previous two, because here your time for computation grows proportionally with your input size — i.e., double your inputs and the algorithm will take twice as much time.

An example would be finding something in an unsorted array — each iteration takes longer until you find what you’re looking for.

def find_element(my_list, element):
    for num in my_list:
        if num == element:
            return True
    return False

my_list = [3, 7, 1, 9, 5, 2, 8]
print(find_element(my_list, 9)) # Output: True
print(find_element(my_list, 4)) # Output: False

In this example, the function find_element takes a list my_list and an element element as input. It iterates through the list and checks each element to see if it matches the desired element. If it finds a match, it returns True. If it reaches the end of the list without finding a match, it returns False.

The time complexity of this algorithm is O(n), as the number of iterations (that is the time it takes to find the element) grows proportionally with the size of the list.

Linearithmic Time - O(n log n)

Linearithmic time is an algorithm that takes a certain amount of time to run but scales logarithmically with the size of the data input. This means that when you double your data set, the algorithm only takes twice as long to run.

Let's say you have an unsorted list of numbers and you want to sort them in ascending order using the Merge Sort algorithm.

Merge Sort has a time complexity of O(n log n) in the worst-case scenario, meaning that as the size of the input list (n) increases, the time taken to sort the list increases logarithmically.

def merge_sort(arr):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left = arr[:mid]
    right = arr[mid:]

    left = merge_sort(left)
    right = merge_sort(right)

    return merge(left, right)

def merge(left, right):
    result = []
    i = 0
    j = 0

    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result += left[i:]
    result += right[j:]

    return result

In this example, when we call the merge_sort function on an unsorted list, it will divide the list into smaller sublists, sort them recursively using merge_sort, and then merge them back together using the merge function.

The time complexity of Merge Sort is O(n log n) because the algorithm divides the input list into halves repeatedly until each sublist contains only one element (which takes O(log n) time), and then merges the sublists together in a linear time of O(n) for each level of the recursion, resulting in a total time complexity of O(n log n).

As the size of the input list (n) increases, the time taken to sort the list increases logarithmically.

Exponential time - `O(2^n)`

Exponential Time (O(2^n)) is when the time required to complete an algorithm doubles with each increase in input size.

This means that the growth rate of this type of algorithm is exponential—for every extra item in its input, the time it needs more than doubles!


def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

In the above example, we have a recursive function that calculates the nth Fibonacci number. The function makes two recursive calls for each value of n. As a result, the time required to calculate the nth Fibonacci number doubles with each increase in n.

Factorial time - `O(n!)`

Factorial Time (O(n!)) refers to a type of algorithm which requires processing all possible combinations of a set.

This means that the input size increases exponentially—for every extra item added, there are more unique combinations possible, and thus more calculation required.

Let's say you have a list of numbers [1, 2, 3], and you want to find all possible permutations of the list.

import itertools

def find_permutations(lst):
    permutations = []
    for permutation in itertools.permutations(lst):
        permutations.append(permutation)
    return permutations

If we call this function with the list [1, 2, 3], it will return a list of all possible permutations of that list: [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)].

Data Structure Complexity Chart

Access means accessing an element at a given index
Search means finding an element with a given key
Insertion means adding a new element to the data structure
Deletion means removing an element from the data structure
n is the number of elements in the data structure
m is the length of the key being searched in the Trie
"-" means the operation is not applicable or not defined for that data structure.

Data Structure	Access	Search	Insertion	Deletion
Array	O(1)	O(n)	O(n)	O(n)
Linked List	O(n)	O(n)	O(1)	O(1)/O(n)
Stack	O(n)	O(n)	O(1)	O(1)
Queue	O(n)	O(n)	O(1)	O(1)
Hash Table	-	O(1)	O(1)	O(1)
Binary Search Tree	O(log n)	O(log n)	O( log n)	O(log n)
B-Tree	O(log n)	O(log n)	O( log n)	O(log n)

Algorithm Complexity Chart

When talking about Big O Notation, it's important to differentiate between best-case, average-case and worst-case scenarios.

Best Case Scenario: The best-case scenario is when a given algorithm takes the least amount of time to complete it’s task. This means it has the most optimal performance.

Average Case Scenario: The average-case scenario is when an algorithm completes its task in an expected amount of time – neither too fast nor too slow. It's neither the best nor worst case, but rather a combination of different scenarios.

Worst Case Scenario: The worst-case scenario is when a given algorithms takes the most amount of time to complete its task. This means that it has the least optimal performance. This is important to consider because algorithms are typically designed with worst-case scenarios in mind, so they run efficiently even under unfavorable conditions.

When talking about Big O Notation, it's important to understand each scenario and determine which one best suits your needs – as this can make a huge difference in terms of performance!

Algorithm	Best case	Average Case	Worst Case	Space Complexity
Bubble Sort	O(n)	O(n^2)	O(n^2)	O(1)
Insertion Sort	O(n)	O(n^2)	O(n^2)	O(1)
Selection Sort	O(n^2)	O(n^2)	O(n^2)	O(1)
Merge Sort	O(n log n)	O(n log n)	O(n log n)	O(n)
Quick Sort	O(n log n)	O(n log n)	O(n^2)	O(log n)
Heap Sort	O(n log n)	O(n log n)	O(n log n)	O(1)
Binary Search	O(1)	O(log n)	O(log n)	O(1)

Which one to focus on? Time Complexity or Space Complexity?

The answer depends on your use case. If you're dealing with a real-time system like a video game with strict time constraints then it's important to focus on time complexity; if you're concerned about memory usage then focus on space complexity.

Ultimately, it depends on your underlying needs — knowing when to focus on each type of Big O notation can help you create better algorithms for your use cases and optimize your codebase.

Conclusion

In summary, Big O notation is an essential tool for any developer or data scientist. It's a simple way of identifying the time complexity of an algorithm, and is incredibly useful when analyzing algorithms to see which perform best. It can also be used to evaluate data structures and determine the best one to use for a particular application.

Having a solid understanding of Big O notation will help you become a better programmer and data scientist. With the cheatsheet in this article, you can look up the complexity of any algorithm or data structure, and improve your coding.

So, don't miss the chance to become a pro and build algorithms for complex data structures with the help of Big O notation cheatsheets.

Create your Dev Portfolio today at Fueler.

Forem: Fueler - Your Developer Portfolio

Git Reset vs. Git Revert: When to Use Each Command

What Is Git Reset?

Code example: how to perform a soft reset using Git command line

What Is Git Revert?

How to revert a commit using Git command line

Comparing Git Reset and Git Revert

Git Reset

Git Revert

Conclusion

Learn how to create Python Dictionary | Beginners Guide

Creating a Dictionary

Accessing Dictionary Items

Retrieving Values Via Keys

Using The Get() Method To Access Dictionary Items Safely

Handling KeyError Exceptions

Modifying Dictionary Items

Dictionary Methods and Operations

len()

Checking if a key exists using the in keyword

Retrieving all Keys and Values of a Dictionary

Updating and Merging Dictionaries

Iterating Through a Dictionary

Using a for loop to iterate through a dictionary

items() method

Conclusion

A Step-by-Step Guide to Comment Blocking in Python

How to Write Single Line Comments in Python

How to Write Multi Line Comments in Python

Benefits of Comment Blocking for Python Programming

1. Testing made easier

2. Improved clarity

3. More efficient coding

Commonly Asked Questions About Python Comment Blocking

1. Is it possible to block comments in Python?

2. How will comment blocking affect code execution?

3. Is everything between /* and */ ignored by the program in Python?

Conclusion

Ultimate Guide to Big O Notation in 2023 | A Comprehensive Cheatsheet

Introduction to Big O Notation

Basic Concepts

What Does "O" Stand For?

What is Time Complexity?

What is Space Complexity?

Understanding Asymptotic Behavior

Big O Notation Cheatsheet

Constant Time - O(1)

Logarithmic Time - O(log n)

Linear Time - O(n)

Linearithmic Time - O(n log n)

Exponential time - O(2^n)

Factorial time - O(n!)

Data Structure Complexity Chart

Algorithm Complexity Chart

Which one to focus on? Time Complexity or Space Complexity?

Conclusion

`len()`

Checking if a key exists using the `in` keyword

Exponential time - `O(2^n)`

Factorial time - `O(n!)`