Forem: Gowtham Venkatesan

Python Lists in under 10 minutes

Gowtham Venkatesan — Sat, 08 Aug 2020 11:41:36 +0000

In the previous post, we discussed about the String data type. In this post let’s discuss the List data type. List is an ordered collection data type. It’s like an array. Think of it as a variable but instead of a single value you can store multiple values in it. And the values inside these lists can be a combination of numbers, strings, or lists(list inside a list) etc. Lists are indexable and they support slicing as well. Let’s learn all about them!

Declaring a variable of the List Type:

The syntax for list : variableName = []. And inside these square brackets, we add the values we want separated by commas. The following example will make things clear.

myList = [1, 2, 3, 4, 5] #This is list
print(type(myList))

We can store any type of value inside a list. For example, we can store a list of strings. Or we can create a list with both numbers and strings. Or we can even have a list inside a list.

    myList2 = ["Hello", "This", "Is", "A", "List"]
    myList3 = ["A", "List", "can also contain numbers", 1, 2, 2.2]
    print(type(myList2))
    print(type(myList3))

Run the code below and check it out:

You can combine two lists by using the + sign:

Paste the code below in the repl window above and run it.

myList = [1, 2, 3]
myList2 = [4, 5]
myList3 = myList + myList2

So now myList3 will contain [1, 2, 3, 4, 5] . Same goes for lists consisting of a combination of multiple data types. It just adds the list to the right of the + operator to the list on the left of the + operator.

Accessing elements in the list:

Because Lists are an ordered sequence of data items we can index them. Just like in Strings. You can access elements inside the list using a method called Indexing. Meaning every data item in the list has a number associated with it. Using these numbers we can grab parts of the list and we can manipulate them without affecting the original List. All you have to do is pass in the position of the element you want to access to the list. It is important to note that the position of elements in a list or any data type that is indexable starts with 0. Let’s look at an example.

myList = [1, 3, "Four", 5, "Six", 7]

A List can be indexed in two ways:

1: Positive Indexing

2: Negative or reverse indexing

myList indexing

1: Positive Indexing:

In positive indexing, the list is numbered from left to right starting with 0. Yes 0. You start numbering from 0. So 0 will the index value of the first data item in the list, 1 will be the index value of the second item in the list and so on …

2: Negative Indexing:

In negative indexing, the list is numbered from the right to left start with negative 1. So -1 will the be the index of the first item from the right and you increment as you go on …

So to grab a data item from the list:

Syntax : listName[index]

a = myList[0]  # stores 1 in a 
b = myList[5]  # stores 7 in b
c = myList[-1] # stores 7 in c
d = myList[-2] # stores 'Six' in d

Now, what if we wanted to access multiple items in the list at once?

Accessing elements in the list using Slicing:

Using slicing we can use indexingto grab multiple items of the list. Here’s the Syntax : listName[startIndex : stopIndex].

The stop index is excluding meaning it’ll grab the items only until the stop index but not including the character at the stop index. The start index is inclusive of the item at the start index. Run the code below.

If you don’t understand the code above learn more about slicing in detail check out my previous post on Strings where I explain the very same in-depth. Negative Slicing alone doesn’t work as expected with slicing in lists. Negative indexing is possible and will work just fine. Just not negative slicing.

Adding elements to the list:

Now if we want to add elements to the list we can use the methods append(), insert() and extend().

1: append():

Using append we can add a single element at the end of the list.
In the append() method you simply pass the element to it.

We’ll learn more about what passing means when we learn about functions in python. For now, think of it as sending something to this line of code which in-turn makes use of some other lines of code which python knows by default.

If it is just numbers you don’t have to bother about the ‘’ . If it is a character or a string you must enclose it in a ‘’ or “”.

    myList = [1]
    myList.append(2)

2: insert():

Using the insert() method we can add elements at a specific index in the list.
In the insert() method we pass in the index (position) we want to add the element followed by the actual element. This will add the element at the specified index pushing the other elements in the list towards the right.
`
myList1 = [1, 3, 4, 5]
myList1.insert(1, 2)

3: extend():

In the extend() method we need to pass the elements to it as another list (in [] separated by commas).

myList2 = ["Hello"]
myList2.extend(["World", "!"])

If you just pass in using ‘’ or “” it’ll add each character of the element as a new item on the list you are performing the method on.

myList3 = ['H', 'E', 'L']
myList3.extend('LO')

Run the code below to see the output of the above code.

Deleting elements from the list:

Now if we want to delete elements from the list we can use the pop(), del() or the remove() methods.

1: pop():

The pop() method will remove a single element from the end of the list each time it is used. You can optionally pass the index to the pop() method to delete elements at a particular index.

myList = [1, 2, 2, 3, 4, 5, 5]
myList.pop()

2: del():

Using the del() method we can delete an element at a specific index. You need to pass the index of the element you want to delete to it. The del() syntax is a little different. We use del Listname[index]. The only difference between del() and pop() is that pop() returns the element that is being deleted while the del() does not.

del myList[5]

3: remove():

And using the remove() we can remove the first occurrence of the element in the list. Meaning if the list1 has [1,2,3,2,4] using remove(2) on it deletes the 2 at index 1 and not the one index 3 as well. It stops after deleting the first occurrence the element you pass to it.

myList.remove(2)

Bonus operations on List:

There are a few additional useful methods that you can apply to Lists such as sort(), reverse(), extend() and index().

1: sort():

If your list consists of numbers you can use the sort method to store the numbers in the list in ascending or descending order. Same goes for strings in the list(based on the first character of the string). This ascending/descending order is dependent on the actual values of the elements in the list. For descending order alone we need to pass something a little special to the method. We need to pass reverse = True to the sort() method for descending.

myList = [1, 4, 8, 9, 3]
myList.sort() 
myList.sort(reverse = True)
myList1 = ['a', 'z', 'y', 'e', 'b']
myList1.sort()
myList1.sort(reverse = True)

2: reverse():

As the name suggests, it is used to reverse the elements in the list but based on the index and not on the actual values.

myList2 = [1, 3, 2, 5, 6]
myList2.reverse()

3: extend():

Using the extend() method we can combine two lists just like we did with + operator we discussed earlier.

myList = [1, 2, 3]
myList2 = [4, 5]
myList.extend(myList2)

This method updates the list we were applying it to show the concatenation of the two original lists.

4: index():

This method searches for the element we pass to it from the start of the list and returns its index. If the given element isn’t present it throws an error.

myList = [1, 2, 3]
index = myList.index(3)
print(index)
# index2 = myList.index(4)
# The above line will throw an error

In this post we learned about the List Data Type, how to declare it, add lists together, indexing, slicing and it’s madness. We learnt some useful methods that we can apply on Lists as well. We can also have lists inside a list, even dictionaries, sets and tuples. We’ll learn more about them in a later post.

And that’s pretty much it for the List Data Type in Python. What? I’m serious. This is all you need to know about Lists. For Now.

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

Next up: It's all about sets.

Python Strings in under 10 minutes

Gowtham Venkatesan — Sat, 08 Aug 2020 11:22:27 +0000

In the previous post, we discussed the numbers data type. In this post, we'll discuss about the String data type.

Every value that we work with in Python has a type. A data type is a classification that specifies which type of value a variable has and what type of operations can be applied to it. This post is a quick introduction to the String data type in python. Let’s get started!

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

Strings

An ordered sequence of characters is called a String. Anything under a ‘ ‘ single-quote or a “ “ is a string. It is used to store sentences, words, characters, special symbols, spaces etc. A username is an example of where strings might be used in real life.

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

Declaring the String Data Type:

All you have to do is assign a variable name to the string of your choice in ‘’ or a “”. And that’s pretty much it.

myStr = 'a'
myStr2 = "The quick brown fox jumps over the lazy dog"
myStr3 = "!@#$%^&*()_+"
myStr4 = '222'

Run the code below and see for yourself :

Any sequence of characters. ANY. Anything under a ‘ ‘ or a “ “ is a string.
Even if it’s a number and it’s inside a ‘ ‘ it’s considered as a string. I repeat ANY. ANYTHING INSIDE IT.

You can also add strings using the + operator:

The code below is pretty self-explanatory. Run the code and see the results.

myStr = "Hello"
myStr2 = "World"
myStr3 = myStr + myStr2 + "!"
print(myStr + myStr2 + "!")
print("Hello" + myStr2 + "!")
print(myStr + "World" + "!")
print("Hello" + "World" + "!")

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

Indexing :

Because strings are an ordered sequence of characters we can index them. Meaning every character in the string has a number associated with it. Using these numbers we can grab parts of the string and we can manipulate them without affecting the original string. Let me show you what I’m talking about.

Let’s Look at an example of the string “Lasagna”. Let’s declare it.

myString = "Lasagna" #This is a string
myString = 'Lasagna' # You can also use ' ' instead of " "

A String can be indexed in two ways:

Positive Indexing
Negative or reverse indexing

1. Positive Indexing:

In positive indexing, the string is numbered from left to right starting with 0. Yes 0. You start numbering from 0. So 0 will the index value of the first character in the string, 1 will be the index value of the second character and so on …

2. Negative Indexing:

In negative indexing, the string is numbered from the right to left start with negative 1. For Obvious reasons. You do know right?. So -1 will the be the index of the first character from the right and you increment as you go on …

So to grab a character from a string:

Syntax : variableName[index]

myString = "Lasagna"
a = myString[0]  # stores 'L' in a 
b = myString[6]  # stores 'a' in b
c = myString[-1] # stores 'a' in c
d = myString[-5] # stores 's' in d

Edit the code below and try to grab ‘g’ and store it in a new variable e.

Any character in a string is indexable. Even spaces in between sentences. So even the spaces should be numbered and considered during indexing.

Okay so now what if we want to grab multiple characters? This is where slicing comes in.

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

Slicing:

In slicing we’ll use indexing to grab a portions of the original string. Here’s the Syntax : variableName[startIndex : stopIndex].

myString = "The Council of Water Sheep"

Say for example you want to grab the first 10 characters in the myString variable. All you have to do is mention the start index followed by a : then the stop index. The stop index is excluding meaning it’ll grab the characters only until the stop index but not including the character at the stop index. The start index is inclusive.

So we can modify the syntax as follows: variableName[startIndex : stopIndex + 1]. The + 1 is to include the character at the stop index. Just increment it to the next number. In the case of negative indexing if the index is -16 for example, incrementing it by one should give you -15 and so on...
This slicing operation isn’t visible in the output section unless you print it or store it in a variable and then print it.

So let’s try and grab the first 10 characters: “The Council” :

First 10 characters of myString

Positive Indexing :

a = myString[0:11]
print(a)

0 is the start of the index and 10 is the stop index for the substring we are trying to grab. But since the stop index isn’t inclusive we increment it to 11.

Negative Indexing :

myString[-26:-15]

-26 is the start index and -16 is the stop index. But we increment it to -15. Why?

We normally use negative indexing to access the characters towards the end of the string as it is easier to number. But you can use negative indexing to grab the characters at the beginning of the string as well.

Refer to the index mapping of the string in the image above to get a better understanding.

Now let’s grab ‘water’ from the string :

WATER substring from myString

Positive Indexing :

myString[15:20]

Negative Indexing :

myString[-11:-6]

Run the code below to check it out!

Let’s grab the last 8 characters now :

The last 8 characters of myString

Positive Indexing

myString[18:26]

Should work just fine. As expected.

Negative Indexing

myString[-8:-1] # Something's wrong I can feel it

Something’s wrong in the above line of code. The last character has the value of -1. You can’t increment it to 0 and expect it to return the desired outcome. It messes up the order. So you leave the stop index blank. Don’t freak out. Just keep reading.

Leaving the start or stop index blank:

Case 1 : Stop index is blank:

If we leave the stop index blank then the slicing will grab all the characters from the start index till the end of the string. Let’s try and grab the ‘Sheep’ substring from myString.

myString[21:] # Positive indexing
myString[-8:] # Negative indexing

21 / -8 is the start of the index for the substring ‘Sheep’. We specify the start string alone and leave the stop index blank so it’ll grab everything from 21 / -8 till the very end of the string.

Case 2 : Start index is blank:

If we leave the start index blank then the slicing will grab all the characters from the start of the string till the stop index. Let’s grab the first 10 characters of myString by leaving the start index blank.

myString[:10] # Positive indexing
myString[:-16] # Negative indexing

10 / -16 is the stop index to grab the first 10 characters from the string. We leave the start index blank. So this slicing operation grabs everything from the start of string until the stop index.

Case 3 : Both Start and Stop index are blank:

If both the start and stop index is blank then the slicing operation will grab the entire string. Because there is no start or stop conditions mentions.

myString[:]

There’s this thing called the step index:

Optionally you can include this thing called the step value using which you can skip characters which are grabbed during the slicing operation. This step index is right after the stop index.
Syntax : variableName[startIndex : stopIndex: stepValue]

So if we set the stop value as 2 it’s going to skip 2 characters for every 2 characters grabbed.

myString = "Encyclopaedia"
myString[0:8:2]

So the above code is going to grab the characters from the start index until the stop index 8 but only every 2 alternate characters.

So normally if the slicing was myString[0:8] it would grab the substring : Encyclop. But if we add the step value myString[0:8:2] it would return Ecco.

You can leave the start/stop/step values blank in any varying combinations. Let me show you what I’m talking about.

myString[0::3]
myString[:6:2]
myString[::2]

Run the code to see the results :

Well, I hope you understood slicing properly. We’ll be using this concept in other data types as well. So get comfortable with it. It isn’t going anywhere.

If you’ve reached till here, GOOD JOB! Baby steps! One at a time! In this post, we learned about the Strings Data Type, how to declare it, add strings together, indexing, and slicing. We have some useful methods that we can apply on strings. We’ll look at them in another post. We need to learn a few more concepts first.

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

And that’s pretty much it for the Strings Data Type in Python. What? I’m serious. This is all you need to know about String. For Now.

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

Next up: It's all about lists.

Python Numbers in under 10 minutes

Gowtham Venkatesan — Sat, 08 Aug 2020 11:01:58 +0000

// If you're new to Python, I suggest you read my previous post where you can get started with Python in under 10 minutes.

Every value that we work with in Python has a type. A data type is a classification that specifies which type of value a variable has and what type of operations can be applied to it. It’s as simple as that. This article is a quick introduction to the Numbers data type in python. So let’s get started!

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

Numbers

Numbers are the most basic data types in Python. Any number that you assign to a variable is of the data type Number.

Now within Numbers, there are three classes :

Integer
Floating point numbers
Complex Numbers

These are the types of Numbers Python supports.

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

1. Integer (int) :

Any and every whole number falls in ‘int’ class. Any number without decimals is an Integer.

myVar1 = 20
myVar2 = 10000
myVar3 = 0

Let’s quickly check the type of the above variables using the type() method.

Run the code by hitting the big green play button. You can also edit the code and run it as well.

If you run the code above by clicking on the big green play button, you’ll get an output saying these variables are of . This tells us the type(class) the variable belongs to.

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

2. Floating Point Numbers (float) :

All decimal numbers fall under the ‘float’ class. Any number with decimals is of a float type. The result of a division operation between two numbers results in a floating-point number. Even if the result is a whole number it will be converted to floating-point.

myVar = 1.2345
myVar2 = 1231.232323
myVar3 = 6/3  
# Even though the result is 3 which is a whole number, it will be be converted to a floating point number resulting in the value 3.00

Let’s quickly run the above code:

If you run the code above, you’ll get an output saying these variables are of the .

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

3. Complex Numbers (complex) :

Complex numbers are specified as + j. Just like how you would do in regular math. But this type is rarely used.

myVar = 2 + 3j
myVar2 = 6 + 3j
print(type(myVar))
print(type(myVar2))
print(myVar + myVar2)

Run the code below!

If you check the type of the above variable, it’ll return .

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

Operations on Numbers:

We can perform the basic mathematical operations on numbers using what is known as an “operator”. It’s nothing but a symbol that defines what type of operation you want to perform on numbers. You can use these operators to perform operations on variables containing numbers.

Gotta love gradients

Addition :

The + operator is used for addition.

myVar1 = 1 + 2
myVar2 = 3 + 5
myVar3 = myVar1 + myVar 2

Subtraction :

The - operator is used for subtraction.

myVar1 = 1 - 2
myVar2 = 3 - 5
myVar3 = myVar1 - myVar 2

Multiplication :

The *****operator is used for multiplication.

myVar1 = 1 * 2
myVar2 = 3 * 5
myVar3 = myVar1 * myVar 2

Division :

The / operator is used for division.

myVar1 = 4 / 2
myVar2 = 2 / 1
myVar3 = myVar1 * myVar 2

Modulus :

The % operator is used to find the remainder of a division operation.

myVar = 6 % 4
# Which will give you 2.

Exponent or Power or whatever:

The ** operator is used to raise the number on the left side of the operator to the power of the number on the right side of the operator.

myVar = 2 ** 3
myVar2 = 2 ** 2
myVar3 = 3 ** 3

Okay so now let’s run the code on a repl portal and see the results.

You can also use () to separate multiple mathematical operations just like you would on a calculator.

myVar = (1 + 2) * (3 / 4)
myVar = (3 * 4) / (6 / 3)
myVar = ((3 * 4) / (6 / 3) - (1 + 2) * (3 / 4))
# And so on ...
# You get the point. Right?

If you’ve reached till here, GOOD JOB! You’ve taken your first steps into learning Python. In this post we learned about the Numbers Data Type, it’s subtypes and the operations you can perform on it. In the next post, we’ll learn more about strings.

And that’s pretty much it for the Numbers Data Type in Python. What? I’m serious. This is all you need to know about numbers in Python.

▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬▬

Next up: Strings in Python

Get Started with Python in under 10 minutes

Gowtham Venkatesan — Sun, 11 Aug 2019 06:30:28 +0000

So you want to learn how to code? You have no prior coding experience or are you coming from another programming language? You have come to the right place. This is an ultimate beginners guide to Programming with Python. We’re not going to go knees deep into programming. But we’re going to get started and write code as quickly as possible. So let’s get started!

Part I: Setting up the coding environment

You can write Python code on your terminal, VSCode or even on a dedicated IDE like PyCharm. But since you’re a beginner we don’t want to you waste time setting one up. You can do it later. For now, you can look to the cloud for an easy and instant IDE setup.

Go to Repl.it. It gives you an instant IDE to learn, build, collaborate, and host all in one place.

Create a new Repl.
Choose Python (not Python 2.7).
Name your Repl.
Create Repl.

Follow the GIF if you have any confusions.

Now that we have an IDE, let’s write our first line of code!

Part II: Let’s Write Some Code!

Before you start coding, in any programming language it’s a tradition to get started by writing code to print “Hello World!” So let’s not break tradition and do just that!

1. Let’s print stuff using Python :

The middle section of the repl is where you write your code. The right side is called a console. Think of it as the middle man between you and python. The console is where you’ll do your input/output to your python program.

To print something on the console, we use the print() statement. Specify the text you want to print inside ‘ ’ or “ ” quotes.

print('Hello World!')
print("Hello World!")

After writing the above code in the console hit the Run button on top.

Congratulations! You have written your first piece of Python Code! Now let’s go ahead write some code that actually does something.

By now you should be familiar with how to use repl.it. From now I’ll embed the repl directly here in the article so you don’t have to keep switching tabs which can quickly become really annoying. So you can write in your own code and run them right here!

2. Comments in Python

Comments are used to explain what your line of code does. You can write a comment using the ‘#’ symbol. The ‘#’ tells python to ignore the line and not to execute it. You can even add # symbol before existing lines of code to make it a comment. You can also have multi-line comments by starting and ending it with ‘’’. Refer the example below for clarity.

Tap the big green play button below to execute the code. You can also edit the code here. Add in your lines of code and run them!

3. Variables in Python

Think of variables like a box, where you store stuff. You can store numbers, characters, sentences and so much more. For now let’s work with numbers, characters, and sentences(strings).

Let’s assign a number to a variable.

Equal to symbol ‘=’ is an assignment operator and is used to assign values to variables.

myVariable = 13
myVariable2 = 12.6969

You can go ahead and check the type of your variable using the type() statement, and passing in your variable name inside of the type().

type(myVariable)
type(myVariable2)

# To view this in the console pass the above statement inside the print function like this :

print(type(myVariable))
print(type(myVariable2))

When you run the above code you’ll see that myVariable returned and myVariable2 returned .

You might’ve guessed it. It’s because 13 is an integer and 12.6969 is a decimal number which we call it as floating-point numbers in the programming world.

Let’s assign a character/string to a variable.

To assign a character to a variable, you must enclose the value of the variable in ‘ ’(single quotes) or “ “(double quotes).

Characters by convention have a length of one and use ‘ ‘ (single quotes).
Strings are sentences or have more than one character generally enclosed in
“ “ (double quotes).

char1 = 'a'
string1 = "Musk Cult"

Run the code below and see for yourself!

4. Arithmetic Operations in Python

Remember we created number valued variables above? You can perform mathematical operations on them. Let’s see the implementation of some of the basic arithmetic operations in math.

The code below is pretty self-explanatory. Run the code and check it out.

myVariable1 = 6
myVariable2 = 3

Addition + :

myVariable + myVariable2

# To see the result on the console :
print(myVariable + myVariable2)

Subtraction - :

print(myVariable - myVariable2)

Multiplication * :

print(myVariable * myVariable2)

Division / :

print(myVariable / myVariable2)

5. Printing variables

Previously we printed the result of the arithmetic operations directly using the print statement. But there’s a better way to do this; store the result in another variable.

result = myVariable + myVariable2
print(result)

You can also print the values of variables along with a print statement. Let me show you what I’m talking about. Run the code below.

print("The result of addition is :",result)

So instead of having just a number being printed in the console, we can have meaningful statements.

You can also specify a particular place in the print statement where you want your variable to be printed.

print("%s is the value of myVar!" % myVar)

Instead of the comma, we used after the string inside the print statement we use the ‘%’ here. ‘ %s’ is called a string literal which is used to specify the position inside a string where you want the value of a variable to be.

print("The result of addition of %s and %s is : %s" % (myVar,myVar2,result))

Here we wanted to place multiple variables so, after the % add a parenthesis ( ) and mention the variables in the order you want them inside the print statement separated by a comma. Run the code below and see for yourself.

6. Getting input from the user.

Previously we assigned values to variables ourselves. Instead, we can get the value of the variable from the user. Here’s how :

We use the input() statement. Equate the variable to an input statement. And inside the parathesis pass in your statement inside single quotes or double-quotes.

myVar = input("Enter the First Number : ")
myVar2 = input("Enter the Second Number : ")

If you check the type of myVar and myVar2 it’s going to be .
It’s because by default the type of the input function is a string. But we can perform mathematical calculations only on numbers. So to convert this to a number we do something called a ‘Type Casting’. We wrap the input statement inside an int(). This converts the string type to integer typer. If you want to work with decimals use float().

myVar = int(input("Enter the First Number : "))
myVar2 = int(input("Enter the Second Number : "))

And there you have it! You’ve written your first piece of code that does something! We’ll learn more about programming and python in upcoming posts!

And that’s pretty much it for the basics.

Learn the Basics of Git in Under 10 Minutes

Gowtham Venkatesan — Sat, 13 Jul 2019 13:18:36 +0000

Yes, the title is a clickbait. There is no way you can understand the basics of git technology in just 10 minutes. But you can get pretty close in about 25 minutes. And that is the purpose of this article.

If you want to get started on learning about Git technology, you’ve come to the right place. This is a comprehensive beginner’s guide to Git. There are many clients for Git. The technology is all the same no matter the client. But in this guide, we’ll be using GitHub to understand Git.

Let’s get started!

What is Version Control?

Version control is a system that records changes to a file or set of files over time so that you can recall specific versions later. So ideally, we can place any file in the computer on version control.

Umm… Okay… But Why Tho?

Here’s Why:

A Version Control System (VCS) allows you to revert files back to a previous state, revert the entire project back to a previous state, review changes made over time, see who last modified something that might be causing a problem, who introduced an issue and when, and more. Using a VCS also means that if you screw things up or lose files, you can generally recover easily. And sometimes you just want to know “who wrote this crap”, and having access to that information is worthwhile 😈.

So What is Git?

Git is a version control system for tracking changes in computer files and coordinating work on those files among multiple people. Git is a Distributed Version Control System. So Git does not necessarily rely on a central server to store all the versions of a project’s files. Instead, every user “clones” a copy of a repository (a collection of files) and has the full history of the project on their own hard drive. This clone has all of the metadata of the original while the original itself is stored on a self-hosted server or a third party hosting service like GitHub.

Git helps you keep track of the changes you make to your code. It is basically the history tab for your code editor(With no incognito mode 🌚). If at any point while coding you hit a fatal error and don’t know what’s causing it you can always revert back to the stable state. So it is very helpful for debugging. Or you can simply see what changes you made to your code over time.

A simple example of version history of a file.

In the example above, all three cards represent different versions of the same file. We can select which version of the file we want to use at any point of time. So I can jump to and fro to any version of the file in the git time continuum.

Git also helps you synchronise code between multiple people. So imagine you and your friend are collaborating on a project. You both are working on the same project files. Now Git takes those changes you and your friend made independently and merges them to a single “Master” repository. So by using Git you can ensure you both are working on the most recent version of the repository. So you don’t have to worry about mailing your files to each other and working with a ridiculous number of copies of the original file. And collaborating long distance becomes as easy as HTML 🙃.

Git Workflow:

Before we start working with Git commands, it is necessary that you understand what it represents.

What is a Repository?

A repository a.k.a. repo is nothing but a collection of source code.

There are four fundamental elements in the Git Workflow.

Working Directory, Staging Area, Local Repository and Remote Repository.

Diagram of a simple Git Workflow

If you consider a file in your Working Directory, it can be in three possible states.

It can be staged. Which means the files with the updated changes are marked to be committed to the local repository but not yet committed.
It can be modified. Which means the files with the updated changes are not yet stored in the local repository.
It can be committed. Which means that the changes you made to your file are safely stored in the local repository.

git add is a command used to add a file that is in the working directory to the staging area.
git commit is a command used to add all files that are staged to the local repository.
git push is a command used to add all committed files in the local repository to the remote repository. So in the remote repository, all files and changes will be visible to anyone with access to the remote repository.
git fetch is a command used to get files from the remote repository to the local repository but not into the working directory.
git merge is a command used to get the files from the local repository into the working directory.
git pull is command used to get files from the remote repository directly into the working directory. It is equivalent to a git fetch and a git merge.

Now that we know what Git is and it’s basic terminologies, let’s see how we can place a file under git. We’re going to do it the right way and the difficult way. Without any GUI applications.

I’m assuming you already have a file you want to place under version control. If not create a sample folder named ‘MuskCult’ and place some sample code files in it.

Step 0: Make a GitHub Account. Duh.

If you don't already have one, you can make one here.

Step 1: Make sure you have Git installed on your machine.

If you are on a Mac, fire up the terminal and enter the following command:

$ git --version

This will prompt open an installer if you don’t already have git. So set it up using the installer. If you have git already, it’ll just show you which version of git you have installed.

If you are running Linux(deb), enter the following in the terminal:

$ sudo apt install git-all

If you are on Windows:

$ get a mac

Just kidding… Relax… The number of people I triggered… Phew…
Go to this link or this link for more info on how to get it.

Step 2: Tell Git who you are.

Introduce yourself. Slide in. Seriously, mention your Git username and email address, since every Git commit will use this information to identify you as the author.

$ git config --global user.name "YOUR_USERNAME"

$ git config --global user.email "im_satoshi@musk.com"

$ git config --global --list # To check the info you just provided

Step 3: Generate/check your machine for existing SSH keys. (Optional)

Why you ask? Using the SSH protocol , you can connect and authenticate to remote servers and services. With SSH keys, you can connect to GitHub without supplying your username or password at each visit.

Follow this link to learn more about SSH.
Go here to check if you have an existing SSH key.
Go here to generate a SSH Key.
Go here to add the SSH key to your GitHub account.
And finally, go here to test its connection.

If you did setup SSH, every git command that has a link you replace it by:

**Instead of: https://github.com/username/reponame**

**You use    : git@github.com/username/reponame.git**

      **Note: You can use both ways alternatively**

I’ll be using SSH protocol in this tutorial.

Step 4: Let’s Git

Create a new repository on GitHub. Follow this link.
Now, locate to the folder you want to place under git in your terminal.

$ cd Desktop/MuskCult

Initialize Git:

And to place it under git, enter:

$ touch README.md   # To create a README file for the repository
$ git init          # Initiates an empty git repository

Now go edit the README.md file to provide information about the repository.

Add files to the Staging Area for commit:

Now to add the files to the git repository for commit:

$ git add . 
# Adds all the files in the local repository and stages them for commit

OR if you want to add a specific file

$ git add README.md
# To add a specific file

Before we commit let’s see what files are staged:

$ git status # Lists all new or modified files to be committed

Commit Changes you made to your Git Repo:

Now to commit files you added to your git repo:

$ git commit -m "First commit"
# The message in the " " is given so that the other users can read the message and see what changes you made

Uncommit Changes you just made to your Git Repo:

Now suppose you just made some error in your code or placed an unwanted file inside the repository, you can unstage the files you just added using:

$ git reset HEAD~1
# Remove the most recent commit
# Commit again!

Add a remote origin and Push:

Now each time you make changes in your files and save it, it won’t be automatically updated on GitHub. All the changes we made in the file are updated in the local repository. Now to update the changes to the master:

$ git remote add origin remote_repository_URL
# sets the new remote

The git remote command lets you create, view and delete connections to other repositories.

$ git remote -v
# List the remote connections you have to other repositories.

The git remote -v command lists the URLs of the remote connections you have to other repositories.

$ git push -u origin master # pushes changes to origin

Now the git push command pushes the changes in your local repository up to the remote repository you specified as the origin.

And now if we go and check our repository page on GitHub it should look something like this:

And that’s it. You’ve just added the files to the repository you just created on GitHub.

See the Changes you made to your file:

Once you start making changes on your files and you save them, the file won’t match the last version that was committed to git. To see the changes you just made:

$ git diff # To show the files changes not yet staged

Revert back to the last committed version to the Git Repo:

Now you can choose to revert back to the last committed version by entering:

$ git checkout .

OR for a specific file

$ git checkout -- <filename>

View Commit History:

You can use the git log command to see the history of commit you made to your files:

$ git log

Each time you make changes that you want to be reflected on GitHub, the following are the most common flow of commands:

$ git add .
$ git status # Lists all new or modified files to be committed
$ git commit -m "Second commit"
$ git push -u origin master

Now if we go and see our repo, we can identify whether the commit was successful by looking at the commit message for each file.

Step 5: That’s all well and good… But How do I download and work on other repositories on GitHub?

Cloning a Git Repo:

Locate to the directory you want to clone the repo. Copy the link of the repository you want and enter the following:

$ git clone remote_repository_URL

Feel free to go ahead and clone the repo I created above using: https://github.com/Gothamv/MuskCult

Pushing Changes to the Git Repo:

Now you can work on the files you want and commit to changes locally. If you want to push changes to that repository you either have to be added as a collaborator for the repository or you have to create something known as a pull request. Go and check out how to do one here and give me a pull request with your code file.

Collaborating:

So imagine you and your friend are collaborating on a project. You both are working on the same project files. Each time you make some changes and push it into the master repo, your friend has to pull the changes that you pushed into the git repo. Meaning to make sure you’re working on the latest version of the git repo each time you start working, a git pull command is the way to go.

Now below is an example of a project my friend and I are collaborating on:

There has just been a commit on the repo

So to make sure those changes are reflected on my local copy of the repo:

$ git pull origin master

Here’s two more useful git commands:

$ git fetch
    AND
$ git merge

In the simplest terms, git fetch followed by a git merge equals a git pull. But then why do these exist?

When you use git pull, Git tries to automatically do your work for you. It is context sensitive, so Git will merge any pulled commits into the branch you are currently working in. git pull automatically merges the commits without letting you review them first.

When you git fetch, Git gathers any commits from the target branch that do not exist in your current branch and stores them in your local repository. However, it does not merge them with your current branch. This is particularly useful if you need to keep your repository up to date, but are working on something that might break if you update your files. To integrate the commits into your master branch, you use git merge.

One More Thing:

.gitignore

So what is it?

.gitignore tells git which files (or patterns) it should ignore. It's usually used to avoid committing transient files from your working directory that aren't useful to other collaborators, such as compilation products, temporary files IDEs create, etc.

So in the above example, files like pycache, .DS_Store are used by the system to store information for faster access. This is not useful for other collaborators. So we can tell git to ignore them by adding a .gitignore file.

Use the touch command to create the .gitignore file:

$ touch .gitignore

And you can add the following patterns to tell git to ignore such files.

/.cmake

/.DS_Store

/.user

/build

etc. depending upon the files you want git to untrack

And that’s pretty much it for the basics. Stay tuned for Part 2 which will focus on Branch, Merge, Stash, Rebase etc.

Peace Out ✌️

References:

https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/

https://blog.github.com/2015-06-08-how-to-undo-almost-anything-with-git/

https://dont-be-afraid-to-commit.readthedocs.io/en/latest/git/commandlinegit.html

https://docs.gitlab.com/ee/gitlab-basics/start-using-git.html

https://stackoverflow.com/questions/292357/what-is-the-difference-between-git-pull-and-git-fetch

https://youtu.be/3a2x1iJFJWc