I was emboldened to write this book after my video series called Data Science With Julia^[1] got some traction. That too after a tweet about Decision Tree^[2] was liked by Julia Language itself. So I thought why not give it more?

This book should be seen as my attempt to explain Data Science to my self and nothing more. Will this book rise to professional stature is yet to be seen.

The front cover showcases a scene from Indian mythology where the forces of Good (Devar’s) and that of Evil (Asuran’s) churn the cosmic ocean revealing things like poison and elixir. In a similar way a Data Scientist can churn the vast amount of data that he has at his disposal for good purpose like finding out a new drug that might work, or for evil purpose like tracking and invading privacy of some one.

We thank Richard M. Stallman (https://stallman.org) and Free Software Foundation (https://fsf.org) for making this book possible.

A good decent powered computer might be needed to run programs in this book. I would say its preferable to have a GNU/Linux^[4] machines so that you can explore the field of data science.

There is lot of Data, in fact we have coined the term data explosion, and more times than we realize these data indicate something valuable. With data people have become great stock traders^[5], they have made machines win competitions that were thought only humans could win it^[6].

It turns out that if we can use math on lot’s of data with clever computer science, we could do things that were once thought impossible, and there is lot’s of data out there.

Data Science is a field where we use computer science to make sense of huge amounts data around us. We try to make it humanly understandable, we try to predict things even though we may not understand why somethings happen. That’s data science.

This might be the cusp of super intelligence, surely this is a new age of data. So welcome to this wonderful universe!

In professional environments Data Science may not be simple. It requires lot of stages, when I say stages, don’t imagine it as a waterfall model where each of them is a compartment, imagine them as a fuzzy thing where one overlaps another. Enough of work in one may lead to another. This section describes those stages.

There are two ways to analyze data. The first one is very highly romanticized prediction. That is given a set of inputs you are able to predict what the outcome of the inputs would be by making machines learn from the sampled data. This field is called Machine Learning, artificial Intelligence and so on.

The other more essential field is called descriptive analysis. That is some event has happened, then you pour over the data in and out why things have happened that way and what can you learn from it.

In practical sense descriptive analysis is highly important for businesses as they would like to know why things happened in such a way in times of good and bad. A complete understanding of any subject is desired if one wants to be alpha in it and be able to better adjust to changing events and come out at the top.

Many people are confused about what’s the difference between Machine Learning, Artificial Intelligence and Data Science. Even some who claim themselves to be professionals seems not to know how they are different, this section was created to help clarify it.

In this blog we will see how to install Julia. Visit https://julialang.org, you must see a banner like this which offers download. Click on the Download button.

You will be a taken to this page https://julialang.org/downloads/, if you scroll down you will see something like this:

I clicked on the 64-bit thing for Generic Linux x86. Once you do that a file named julia-1.6.2-linux-x86_64.tar.gz will be downloaded. Extract it to your home directory and open ~/.bashrc and add it this at the last:

this tells your computer to look into ~/julia-1.6.2/bin when you call julia. Just for once type this in terminal:

To know more about .basrc you can visit here https://www.journaldev.com/41479/bashrc-file-in-linux.

In your terminal when you type julia, you should be getting this:

Press Ctrl+D to exit.

If all had gone well, you had installed Julia, ran its REPL, and came out of it successfully. In case you are wondering what REPL is, wait for the next blog.

REPL stands for Read Eval(uate) Print Loop. Its a way a programming ecosystem gives you a easy way to execute small programs in shell environments. Let’s get started with it. In your terminal type this:

You should be seeing something like this.

Juila prints a nice ASCII art of Julia logo and it prints version info and when was it released etc. The julia> is julia prompt where you can type some small Julia code, Julia will read it, evaluate it and print the result.

So lets see what 1 and 2 added is, type 1 + 2 and hit ENTER:

So it’s 3 yaaay! Our first small Julia program!!

You can type multiple Julia statements per line, it needs to be separated by semicolon ; as shown:

In the above statement we have a thing like x = 3, this means we put a value of 3 in a box named x and in y = 4, we put 4 in a box named y. Now what happens when we have three x boxes and four y boxes? Try this out:

Julia says its 25!

Now let’s try to multiply x and y:

It fails. We will see why it fails when we see about variables. Okay, mathematically we use dot . to denote multiplication

ion, so let’s try out x.y:

it fails too, we will soon see why in coming blogs (i.e you will learn about it). The right way to multiply in Julia is to use the star * operator as shown:

If you have been using GNU/Linux or Python (even on on evil platforms like Mac and Windows), you will have a way of accessing help documentation in REPL, so does Julia too. To access help, just type ? in Julia prompt, you will be presented with something like this:

You can come out of help by pressing kbd:[Backspace]. Okay lets see what typeof (if you have read previous blog you may have used typeof) does. Just type typeof in help prompt and hit Enter.

Isn’t it useful?

et’s see how to add packages in Julia using it’s REPL. For that just like you went into help mode by pressing ? at julia> prompt, you must for package management press ]. To come out of this package pkg> thing press Backspace.

In case I am going too fast, let’s discuss what packages are. Today is the age of internet, and hence a code written by one can be used by millions, all it needs is a internet connection. So almost all modern languages have a way of managing reusable shared code. In Julia, this reusable shared code is called a Package.

Since Julia’s ecosystem is open source (I wish people understood the merits of [Free Software](https://fsf.org) and ignored the misleading Open Source, any way), many people look at popular packages in Julia and analyze them, they are well maintained and tested and can used with fair amount of trust. So let’s see how to install a package.

Data Science is a highly interactive activity. You get the data, do something with it, see what has happened, then go a step back or step forward depending on the result and so on. Usually data scientist don’t use REPL and a text editor to code, they use something interactive called Jypyter^[8] notebooks which you will learn about in the coming, chapters. Over here we will see how to install it.

Okay, let’s start with Juyter lab. I am using Jupyter notebooks no more because I feel lab is cool. To start it you can either do it by the Julia way by calling IJulia as I mentioned [Installing Jupyter notebook and Jupyter lab]({% post_url 2020-10-31-installing-jupyter-notebook-and-jupyter-lab %}), or I like the Conda way, to do it, in your terminal type this:

When started in IJulia way, the lab asks me what kernel I must use as shown below:

when started the Conda way, it sows something like this:

In the above launcher, I select Julia 1.5.2 in the Notebook section:

When you select a kernel, at the left pane you should be seeing a file called untitled.ipynb, right click on it and change it’s name to starting_with_julia_lab.ipynb. Now this lab is like REPL on steroids, it has got thing called cells as shown:

Now type

in the cell and press Shift + Enter, you see the outputs 3 and the input cell receives a number [1]:, the output too receives number [1] as shown in the image below

Now let’s try to print the legendary [Hello World](https://en.wikipedia.org/wiki/%22Hello,_World!%22_program) in the next cell

It should spit out an output as shown:

Now let’s print 1 + 2 = 3, for that type the following in the cell

and press Shift + Enter or Ctrl + Enter

You will get an output as shown above

in the coming example, we put a value 3 into a thing called variable, this variable is called a and you know how to execute this, go on:

Output:

Similarly we put a value 5 in variable b and execute it:

Output:

Now let’s check if 1 equals 2 in the next cell:

Output:

Once you have done this your notebook should look like this.

A Jupyter lab instance is collection of many notebooks. If you did not understand what I mean by that, its okay, things will clear up.

Instead of Shift + Enter, you can press Alt + Enter, in that case the cell will be executed, and a new cell won’t be created beneath it. To get the code / note book for this blog check out this link https://gitlab.com/data-science-with-julia/code/-/blob/master/starting_with_julia_lab.ipynb

Go on and play around with Jupyter lab, mess it up and crash it, start it all over to learn.

It’s not that all your Julia programs will be in Jupyter Lab and Jupyter notebooks. Once you have done some thing and its kinda set in stone, you can put in a file and and execute it using the Julia run time. In production environment, its nothing but few Julia files getting executed when needed. In this blog we will see how to put Julia programs in a file and execute it.

I hope you have a text editor with you, I strongly do not recommend using Juptyer lab to create Julia files. Why? Because I don’t like it and you will see for yourself if you don’t realize it now. I would suggest one to use [Atom](https://atom.io) or [VS Code](https://code.visualstudio.com/), unfortunately both created by evil Microsoft corporation.

Create a file called hello_world.julia and put this stuff into it:

you can get this source code here https://gitlab.com/data-science-with-julia/code/-/blob/master/hello_world.julia

Now in your terminal, go to the directory where the file is and type this:

and hit Enter. If you get this:

as output, then all is well. Yaay, you have created and executed your first Julia program as a file. In data science we explore a lot with notebooks and lab because of their visual nature. When things are okay, we put them in Julia files and ship it off.

Let us see about basic arithmetic in Julia. The notebook for this blog is available here https://gitlab.com/datascience-book/code/-/blob/master/artthmetic.ipynb.

First start a notebook, so first let’s do addition. Type this in a cell:

and execute it. As you can see + sign adds two numbers and outputs the result as shown:

Try an other example:

Output:

Now let’s try multiplication:

The * sign multiplies numbers at its left and right side and outputs the result as shown:

Now let’s try subtraction which is accomplished by - sign. In the example below we are taking away 8 from 50:

Output:

Now division is done by /, so this is what you get when you divide 375 by 21:

Output:

Now x^y in Julia can be written as x ^ y, so the below example finds out 28 raised to the power of 12:

Output:

For curiosity reason we will see what will happen when we add -2 and 45:

Output:

There is a operator called mod % which gives us the reminder. Lets see what’s the reminder when 21 is divided by 4:

Output:

We have seen how to get reminder, now let’s see how to get quotient of a division operation. For that we use ÷ operator which does integer division. So look at the example below:

Output

To type in ÷ in the notebook, type \div in a cell and press Tab.

It’s not that one can enter only 1 statement in Jupyter lab’s cell and press Shift + Enter to execute it, you can enter multiple statements by using Enter key at the end of statement, then you can press Shift + Enter to execute it.

In the example below, we convert 90 degree Celsius to Fahrenheit.

Output:

In the above example, first we assign value 90 to variable named celcius using this statement celcius = 90. Next we compute Fahrenheit as follows fahrenheit = (9 / 5)celcius + 32. Look how we can give (9 / 5)celcius, Julia can find out you are trying to multiply \$9 / 5\$ with celcius, it’s very much like writing an equation. Then 32 is added to it here (9 / 5)celcius + 32.

For the sake of experimentation try out this statement fahrenheit = (9 / 5) * (celcius + 32). Did you get the right answer? What went wrong?

Now try out the example below:

Output:

Note how quickly Julia could get confused by just leaving a space between (9/5) and celcius, wheras you human can see its a obvious thing.

Now try this example out:

Output:

There is a difference between how Scientists write equations and programmers program it. For example for a scientist writing F = (9/5)C + 32 is a good enough Julia program, but as a programmer one would absolutely hate it. A programmer would like the program to be self documenting. Hence he would like fahrenheit = (9 / 5) * celcius + 32. He would like to mention celcius is multiplied by (9 / 5) explicitly using the * operator.

For a scientist (9/5) is good enough, but for a programmer its blasphemy. Programmers like to the program to be more readable. I think I need to write a blog about the way of code: Scientists Vs Programmers. (9 / 5) is more readable than (9/5) programmer would say.

Now consider the example below. When ever you wrap something in brackets, it get’s executed first, so in the below operation 90 is added with 32 in (celcius + 32) giving 122, then this 122 is multiplied with 9 \over 5 in (9 / 5) * (celcius + 32):

Output:

You can use only round brackets ( and this ) in math iperations in Julia, curly and other brackets are strict no:

Output:

Here I am trying to use square brackets:

Output:

One good thing about Julia is you can assign values to variables and construct algebric equations as follows:

Output:

Try breaking the above example and make it throw errors so that you would learn.

Let’s assign 12 to z as shown:

Output:

Below example is the compact way of writing z = z + 4, that is you are adding 4 with z, making it 16 and assigning it to z again.

Example 1:

Output:

Imagine what would a mathematician think if you present an equation z = z+4 :D Programmer and the way maths and science people think are very different, but data science is marriage of huge amounts of data with computer processing which run algorithms based on scientific observation and mathematics.

Since I am lazy, explain to your self what’s happening in the examples below:

Example 2:

Output:

Example 3:

Output:

Example 4:

Output:

Example 5:

Output:

Imagine a perl necklace, you have a string that runs through pearls, that is you have stringed or strung the pearls. If you string bunch of characters in programming, it’s called a String. as simple as that.

So now let’s create a Hello World string as shown below:

Output:

There is a lot to learn here. We find characters H to ! surrounded by double quotes ", they were strung. That how you create a string.

Now let’s print it out using a function named println (I think this means print line)

Output:

Now let’s put a String into a variable named string

Output:

And let’s print out the variable string

Output:

Look when you print it, how neat it is without those ugly double quotes.

Now let’s assign 42 to a variable named a

Output:

Check its type. It would be Int anyway

Output:

Now let’s use a function named repr to convert it into String.

Output:

I am not sure what’s the meaning or full form of repr, but thats a weird function name in Julia.

Take a look at the code below, execute it in your notebook.

Output:

We see that "Answer to the ultimate question $a", where $a tells Julia to embed the value of a in the string. Technically this is called String Interopolation.

Now let’s print c and see

Output:

There is a function called occursin that checks is a string occurs in another string. To test it, let’s create a string and store it in a variable called sentence as shown below:

Output:

Now let’s check if "spam" occurs in sentence

Output:

and it does!

If you want to find in which location "spam" occurs first, you can use function called findfirst as shown below:

Ouput:

It gives the range, that is "spam" can be found from 3rd character to 6th character of sentence.

Now if you want to find all occurance of "spam" in sentence, you can use findall as shown below:

Output:

Now let’s check if 32nd to 35th character of senctence is really "spam"

Output:

If you have not guessed it, String can be thought of as a Array of characters, to kinda prove it, we check the 7th location of sentence

Output:

and its 'm'.

Now let’s check what are the first seven characters of sentence

Output:

No let’s check what we have from 7th character to the last of sentence, here to get the last place we use length(sentence):

Output:

Like we can iterate element by element in an Array, we can iterate character by character in a String and print them out as shown:

Output:

Just like we can use join function on Array, we can use them on String as shown:

Output:

This section doesn’t go into regular expressions, but we can find if a regular expression is found in a String using the match function as shown:

Output:

We might deep dive into regular expressions possibly when we are learning about Natural Language Processing.

We can use the function uppercase to convert all characters in a sentence to uppercase as shown:

Output:

Similarly, there is a way to convert it to lowercase too:

Output:

This section is a brief introduction to String in Julia. I think this is enough of Strings for a Datascientist.

Let’s look at Boolean algebra^[9] with Julia. The notebook for this blog is here <https://gitlab.com/datascience-book/code/-/blob/master/binary_arithmetic.ipynb

In Julia, something true is represented by a constant true and something false is represented by a constant false. These two things are inbuilt in Julia and you can’t keep a variable like true = 1, Julia will throw an error.

Now let’s look at operators that do binary arithmetic. The and operation is done using the and & operator as shown:

Output:

Output:

We use the pipe | symbol to do the OR operation as shown:

Output:

Output:

The tilde ~ symbol is used for a NOT as shown:

Output:

⊻ does the XOR operation, to type it, type \xor and press Tab key.

Output:

Output:

Output:

The >> is used for arithmetic right shift, so 3 divided by 2 is kinda one.

Output:

The >>> is used for logical right shift

Output:

In the below example I have no clue why it became -2, may be I will explore it in later blogs

Output:

I am blown away why it produces such a result in the example below, may be I will investigate when I am not lazy:

Output:

The << is used for arithmetic left shift, so shifiting 101 by 1 becomes 1010 which is 6 as shown below:

Output:

Output:

and an another one:

Output:

Life is full of comparisons, we must earn more next year than now. We are considered lesser than our boss because he owns an expensive car, or has more money. Programming follows real life, comparisons are important part of programming too. Let’s see how its done in Julia.

The notebook for this blog is available here https://gitlab.com/datascience-book/code/-/blob/master/comparisons.ipynb. So fire your Jupyter lab and let’s get started.

First let’s see if 1 is greater than 2, for checking that we use greater than symbol >

Output:

Looks like 1 is less than 2 in Julia world. Now let’s check if 2 is greater than 1, and it looks so as from below example:

Output:

Now let’s see if 1 is greater than 1:

Output:

Looks not, and it looks as though 1 is equal to 1 as we can see below. The >= checks if the left hand side number is either greater or equal to the right hand side number.

Output:

Now let’s use the less than sign and try to do something. Let’s check if 5 is less than 3 using the less than < operator

Output:

Now lets check if 3 is less than 5

Output:

Now let’s see if 3 is less than or equal to 5 using the ⇐ operator. Since 3 is less than 5 it returns true.

Output:

Now rather than putting = sign after <, we will put it before < and check.

Output:

It fails.

Now let’s check if 3 is less than or equal to 3.

Output:

Now let’s check of 3 equals 3, for that we use the double equal to == operator as shown.

Output:

Now look at the statement below,we are checking if 3 == 3.0, that is 3 on the left side is an integer and 3.0 on the right side is a floating point number or a Real number. These two pieces of data are stored differently in Julia in different locations, yet Julia is smart enough to compare them and say they are equal. If you want to know more about floating point and how they are stored in computers, look here https://en.wikipedia.org/wiki/Floating-point_arithmetic

Output:

If we want to check if two values are stored in same location in computers memory, we can use the triple equal sign === as shown. 3 is stored in different location than 3.0 hence Julia says they both are not equal.

Output:

Try this one

What do you infer from it?

Now there is a special value called NaN in Julia, it means not a number. Now it turns out that two `NaN’s are not equal

Output:

But it turns out that in Julia all the things that are NaN point to a same address located in the RAM, so that passes the === test as shown:

Output:

The last operator we are going to see in the blog is not equal to, denoted by !=, so let’s check if 4 is not equal to 5

Output:

Turns out true. Now let’s check if 4 is not equal to 4:

Output:

In the last section we have seen how to use comparisons and to compare things. Now let’s see how to use them. Let’s see how to compare two numbers and print useful output. The notebook for this blog is here https://gitlab.com/datascience-book/code/-/blob/master/if.ipynb.

Take a look at the example below, type it in your Jupyter lab and execute it:

Output:

It says a = 5 is bigger, now change the values of a and b in a = 5; b = 3 and see what happens. Make one greater than other, make them both equal and see. Now let’s see how it works. The main work horse of the above program is the if condition. It’s syntax is as follows:

it consists of a if key word, followed by some condition. So in:

a > b is the condition. If this condition is true then the code block between if and end will get executed. So in if a > b, a is 5 and b is 3 and hence its true, so the statement println("a = ", a, " is bigger") in:

gets executed, you get the output a = 5 is bigger. Now try explaining the other parts of the program to yourself.

Now in the above program the conditions are checked three times, that is first in if a > b then in if b > a and then in if a == b. What if a > b is true, then its just waste of computing resource to check for other conditions. Is there a programming construct that when one condition passes, all others are ignored? Fortunately yes. Check the program below:

Output:

In the above program b is greater than a, so when it hits if a > b it fails. Then Julia checks if there is a elseif keyword. In this case there is. First we have elseif b > a and b > a is true. So the statement under the elseif gets executed and hence println("b = ", b, " is bigger") gets executed and it prints b = 5 is bigger.

In the above program, we have another condition check elseif a == b, in reality either a or b should be greater or they must be equal, so in fact this will be hit when both conditions a > b and b > a fail, so we could avoid condition check here and assume both numbers are equal and we can write the program as shown:

Output:

Take a look at the above program. Look at the:

This else is hit only when all other conditions have failed. So when neither a or b is greater, they both must be equal. Hence there is no need of a condition check here. else always has no condition in it and is executed when all other conditions in if and elseif fails.

So since all conditions fail in the above program println("both numbers are equal") under the else gets execute and we get both numbers are equal as output.

Unary operator are ones that operate on one stuff like the tilde ~ operator, you can do something like ~ a, ~ false etc and get a result. Binary operators operators act on two stuff, like the plus + operator. You can do 1 + 2 and so on, they get 2 operands. Ternary operator, operates on three stuffs. Take a look at the program below:

Output:

Type it in your Jupyter lab and execute it. So this program is able to find maximum and minimum of two values. Let’s see how it works.

First we assign a to 10 and b to 15 here:

Next look at this line:

Here we have a variable max and we are assigning something to it with an equal to = operator. The interesting part is at the right side, look at it carefully, it goes like this b > a ? b : a. Note the syntax here. There is a condition b > a, so it becomes true or false depending on the avlues of b and a, at the right of it is a ? b : a. If b > a is true, the the stuff between question ? and : get returned and b is assigned to max. If b > a is false, the stuff after the : is assigned to max that is a.

So this ternary operator ? : deals with three stuffs.

I think you can figure out rest of the program by yourself.

As an exercise why don’t you write a simple program with uses ternary operator and and does this:

The Jupyer notebook for this section is available here https://gitlab.com/datascience-book/code/-/blob/master/ternary_operator.ipynb.

In the section Boolean Operations, we had talked about using & to Boolean AND stuff and using | to Boolean OR. But there is one draw back. If I say false & true, just by looking at false & one can say the result is false, irrespective of what is on the right side operand, but this & looks at its both left and right side anyway. There is however are two intelligent and operators that Julia calls as short cut evaluation, one of them is &&, a double AND.

If there is an expression false && true, Julia seeing false &&, doesn’t bother what’s at the right side if the && and just returns false. It saves valuable computing power. In Data Science applications we use very simple algorithms with massive amounts of data, so computing efficiency is important, so Julia is a good candidate for it. It is also possible to write very inefficient programs in Julia if one is not careful. So I feel these kind of small knowledge tidbits are useful.

So lets see a program with double AND && short cut operator. Below program checks which of the three given variables have the highest values and prints them out. Note how we have used && operators everywhere.

Output:

So if you take the line if a > b && a > c, when a > b is false, Julia does not compare a with c in ` a > c`. That’s bit smart and if this program is running billion times on say 50 data crunching servers, it makes a difference.

Similarly we have a double pipe symbol || used for OR operations. So if there is true || false situation, Julia never bothers what’s at the right side of ||, it just returns true. Below is a program that takes weather input, if the weather is "sunny" or "rainy", it tells you to take an umbrella, else it says its a nice weather.

Output:

The notebook for this blog is available here https://gitlab.com/datascience-book/code/-/blob/master/short_circuit_evaluation.ipynb.

No matter what modern programming language you take, you will find a while loop in it, Julia is no exception in that case (but there are languages without it). This section is about while loops in Julia. The notebook for this section can be found here: https://gitlab.com/datascience-book/code/-/blob/master/while.ipynb. So let’s try it out and see. Take this first example, type it in your Jupyter lab and execute it:

Output:

So how it works? First we have got this statement i = 1, where we initialize a variable named i to 1. Next we have while i ⇐ 10, so this while key word gets a condition i ⇐ 10, and i is less than 10, so the stuff between while <condition> and end gets executed. So in the the above code they are these lines:

Here we print i in println(i) and next we increment i by 1 here i += 1 and hence i becomes 2. When it encounters end, it does not end, the control transfers back to while i ⇐ 10, since the condition is true again the loop body gets executed again and 2 gets printed and i become 3 now. It goes on till i is 11 and when it hits while i ⇐ 10, i ⇐ 10 fails and the loop never gets executed and the program ends.

For a visual look here is a diagram that explains how a while loop works:

A while or most programming loops needs the three things to work properly

If we leave out (3), the loop could be a infinite loop, comment out i += 1 and see what happens, hope you know to stop your kernel and kill Jupyter notebook / lab, refer Installing Jupyter notebook and Jupyter lab.

If you wand to say 1 to 10 in Julia, this is a simpler way to do it, its called as range:

Output:

It’s syntax is <start value>:<end value>. And you can print 1 to 10 like this:

Output:

Let me introduce for loop, this can remove lot of clutter compared to a while loop. This for works like this, first you have a variable in this case i and then it’s followed by a in keyword and is followed by a range (in future we will see other data types as well). So you can think for as something that un-bundles 1:10 and puts each value into the variable i one at a time and executes the loop body that is in the above case is print(i, ' '). Notice how the print() is different from the println(). println() prints a new line at the end whereas print() does not.

Let’s say we want to print numbers from 5 to 100 in steps of 5, range has a way for that too, take a look at the example below:

Output:

The format for range with step is this <start value>:<step size>:<end value> as shown below:

Output:

The notebook for this blog is here https://gitlab.com/datascience-book/code/-/blob/master/ranges.ipynb.

Sometimes while you are executing a loop, you might like to skip something, at those times you can use a key word called continue. Let’s say that I don’t want 6 getting printed when I write a program to print 1 to 10, I can write a program like this:

Output:

Look at these lines of code in the above example:

It tells Julia to continue to next iteration if i equals 6, so the statement that comes after it, that is in this case println(i) won’t get executes when i is 6, and it will go to the next iteration and i will become 7 and the loop will go on normally. So seeing this why can’t you write a program that prints only even numbers or odd numbers below a given value in the number line?

continue tells Julia to skip operation and go on to next iteration, break tells it to break out of the loop entirely. Type the program below in your notebook and execute it:

Output:

Here when i is 6, in these lines:

when i==6 becomes true, and break will get executed, and the program breaks out of the loop. Hence only 1 to 6 gets printed and the loop breaks.

A very similar implementation of the above programs is given below using for loop for continue:

Output:

and this one is for break:

Output:

The notebook for this blog can be found here https://gitlab.com/datascience-book/code/-/blob/master/breaks_and_continues.ipynb.

Arrays are nothing but a collection of some stuff. Imagine a rack with, where each compartment is numbered/indexed 1, 2 ,3 …​ and so on and you put an item in each compartment. At a later time you can retrieve the item using the index.

The code for this blog can be fount here https://gitlab.com/datascience-book/code/-/blob/master/arrays.ipynb, let’s get practical here now. Launch your Jupyter Lab and try these out:

First lets create an array as shown below:

Output:

As you can see we have 1, 2, 3, 4, 5, within [ and ], that’s how Julia knows we have created an array, and we assign it to variable named array. So the variable array points to the start of [1, 2, 3, 4, 5].

To determine how many elements are present in an array, we use the length() function as shown below

Output:

I don’t think it should be a mystery to you that we have 5 elements in array.

Now let’s try size():

Output:

so it returns something weird, and it looks like this (5,), this is called a Tuple, a very similar data structure like Array, but it’s immutable. That is we cannot change it. We will look at it in the later blogs.

Now let’s get into some kind of statistics, what about totaling the values in an array, take a look at the example below:

Output:

We use the for loop here, in this line for element in array, in each iteration, element get the value of one element of array. That is in the first iteration element becomes 1 in the second 2 and so on. Now when it hits total += 0, in the first iteration total becomes 0 + 1, that is 1, in the second iteration 1 + 2 that is 3 and so on…​. Finally we print total here println(total) and its 15.

Now let’s see what the average is. Its nothing but total divided by number of elements in the array as shown below:

Output:

In previous blogs we have seen how to find maximum of 2 or three numbers, but look at the program below. You can pack how many number you want in the array and it will find the maximum:

Output:

First we have a variable max which s assigned to the first element of the array here max = array[1], now we have these lines:

In the above lines, each element of the array is assigned to element and here max = max > element ? max : element, max takes on the value of element if it’s greater than element and finally we print out max here println(max).

Now let’s see how to access 3rd element of an array:

Output:

Now we access elements 2 to 4:

Output:

See that in the above example we pass range 2:4 between the brackets.

We wrote a long program to find maximum of an array, but we can also do it like this:

Output:

Here is the code to find minimum:

Output:

We can get cumulative sum of an array as shown:

Output:

This is how to find total or sum of an array:

Output:

Now let’s multiply all elements of an array by 7:

Output:

Now let’s add 1 to all elements of the array:

Output:

Note that we use a dot in array.+ 1, the dot . is a broadcasting operator which is used for element wise operations. I find that we can omit . for multiplying and dividing array by scalar.

In the example below we divide array by scalar:

Output:

In the below example we subtract 4 from each element of the array, notice that we use the dot . operator:

Output:

There is a function called typeof() in Julia that tells the variable type. Let’s see what data type array is:

Output:

So it says Array, that is collection of stuff in an ordered format, it’s elements are integers Int, and each element occupies 64 bits of space. Why don’t you check what is the type of array / 4?

Now let’s see how to add a new element to an array:

Output:

In the above case we have added 21 to the array using push!() function. As a first argument to push!() we give array and as second argument we give the element to be added that is 21.

Wen ever you use push!(), you see that array gets modified as shown below. The exclamation mark, also called as bang ! in computer science indicates that the argument been passed to it gets modified. Let’s check the value of array now:

Output:

Now let’s pop out the last element of the array:

Output:

We use function called pop!(), since it comes with a bang !, we can expect array is modified here as shown below:

Output:

We push 3 into the array:

Output:

We check it again as though we don’t believe in push!():

Output:

We reverse the order of elements in array

Output:

We sort the array here:

Output:

Since we used a function with bang ! above, we can expect the result to be stored in variable array as shown below:

Output:

Now let’s do some real math, lets say we are buying some items, their quantities and prices are given below:

The above cell does not spit any output, look at the semicolon ; at the end of the last line that prevents the cell from cluttering your notebook with its outputs.

Since it’s Julia, I can compute the total prices as shown below:

Output:

As you can see, you can compute the total cost of each item using just the star * operator. That’s a lot of savings for you from writing lot of iterative code (if you know to code in other languages).

Now let’s compute the sun of the above total_array

Output:

Julia provides sum() function that computes the total of an array.

Now let’s use Julia’s built in linear algebra package, and since quantities and prices are nothing but vectors, we can compute the total by taking it’s dot product as shown:

Output:

In the above example we have learned to use or import a package, to import it we use using <package name>. Thankfully Julia has LinearAlgebra package built into it, but it’s not imported at the start by default, so we need to import it using using LinearAlgebra. It provides a convenient dot() function to calculate the dot product.

Now say we want to be more concise, we can use the dot operator ⋅ provided by LinearAlgebra package.

Output:

In case you are wondering how to type ⋅, type \cdot and press Tab.

Tuple is a data type like Array, the only thing is you can’t change values in a Tuple, in Array you can. You can get the Jupyter notebook for this blog here https://gitlab.com/datascience-book/code/-/blob/master/tuples.ipynb.

So let’s dive in.

First we create a Tuple and assign it to a variable called tuple

Output:

So the above example speaks something, in Arrays we wrap elements with square brackets [], but here we are wrapping it with rounded ones ().

In the below example we check the Tuple’s type:

Output:

I am not sure why its called NTuple, I read some docs and I infer it means a homogeneous data type. In the above example our tuple contains all Int64 that is integers of 64 bit wide; and it has 6 elements in them, identified by 6 in NTuple{6,Int64}.

An array is mutable, that is the values in it can be changed, below we have an Array:

Output:

and we change the third element in it:

Output:

This statement array[3] = 10 accesses the third element and sets it to 10. If we try to do this in Tuple as shown below, we get an error:

Output:

Like an Array we can get maximum value in a Tuple using the maximum() function:

Output:

We can get minimum value in a Tuple using the minimum() function:

Output:

We can get total of Tuple using the sum() function:

Output:

Below we get the cumulative sum using cumsum() function:

Output:

We are unable to sort it however, I did not try out sort!() because anything with a bang modifies the argument that’s been passed to it. A Tuple is immutable and hence sort!() makes no sense and hence I tried sort() and it did not work:

Output:

Possibly one must convert Tuple into Array to sort.

Now let’s use our LinearAlgebra package to and wee if ⋅ operator works on Tuple:

Output:

and it does. To get the dot operator type \cdot followed by Tab.

In our last blog about [Array]({% post_url 2020-11-17-arrays %}), we saw that when getting size of an array we got something as shown:

Output:

Well the size of an array is a Tuple. You also see that in the above example it gives an Output (6,) and not (6). Now let’s inspect the type of the returned value:

Output:

As an exercise, why don’t you try typeof6 and see what it is? A Tuple should always have an comma ,, thats how Julia identifies it’s an Tuple than a number surrounded by brackets.

I wish we could convert Tuple to Array by using a construct like this Tuple(<array>), but it turns out that you must do a trickery as shown below:

Output:

In the above example notice this [element for element in tuple], this is called list comprehension, it works like this, it starts with an empty Array [], now take this for element in tuple, this is a for loop, so for each element in tuple, it take an element one by one and puts it into variable named element, now this element is added to Array here [element …​.], so in the first iteration it becomes [1], in the next [1, 5] and so on…​ Finally we get an Array [1, 5, 9, 3, 7, 2] which gets assigned to array_from_tuple.

Though making an Array from Tuple is a pain, making a Tuple from an Array seems to be as easy as shown:

Output:

weird Julia.

In this blog let’s look at comprehensions, you can get the notebook here https://gitlab.com/datascience-book/code/-/blob/master/comprehension.ipynb. First we define a range as shown:

Output:

Now say we want to square the values in the range, we can do it as shown:

Output:

Look at the construct of the program, we separate out each item in the range using this statement for value in range, each time the item gets stored in a variable called value, and in value^2 we square it, and we capture it in an array by wrapping it all between square brackets like this [value^2 for value in range]. This trickery is called list comprehension.

Below let me introduce to you the rand() function, in the below example we want to generate random number between 1 and 100, so we use rand(1:100), and we want to generate 10 numbers, so we pass 10 as the second argument as ten like this rand(1:100, 10). Type the example below and execute:

Output:

As you see from the above example, we assign the random numbers to a variable called array. Now let’s use list comprehension to take square root of array as shown:

Output:

Okay, list comprehension is very powerful feature, but one can take square of array as shown:

Output:

So in the above example we do element wise multiplication, for that we use the .* operator. I tried out array * array and hoped that it would work, but it did not.

The dot . means element wise operation. We can do element wise squaring of the array as shown:

Output:

All we do add a dot . before ^ and that’s it. So does it mean list comprehension is dead? Nope we can do some trickery with list comprehension as shown:

Output:

Let’s see how the program works. First we take each item in the array and assign it to a variable called value here for value in array, but we do not do that all the time, it happens only when the value is odd as given by if value % 2 != 0, if that happens we take the value and put in in an Array like this [value …​..]. So we have complete program as shown here [value for value in array if value % 2 != 0]. So what we are doing is filtering the odd numbers, nothing else.

Julia has a datatype called Set, that is mathematical equivalent of a [Set](https://en.wikipedia.org/wiki/Set_(mathematics)). From the angle of Julia you can think Set as an Array which contains just unique values and cannot be ordered or sorted.

So let’s dive in, we can create a set as shown below:

Output:

So we see that we use an array [1, 2, 3, 4], this is been passed to a Function called Set() like this Set([1, 2, 3, 4]) and out we get out a set which is stored in a variable called set. Why don’t you try out Set([1, 2, 3, 4, 1, 2, 3, 4]) and see what happens?

We will also create another set as shown:

Output:

Now we will try to push in a new value 8 in another set. Note we use push!() function which means the argument passed to it gets modified:

Output:

In the above piece of code we give another_set as argument to the push!() and we add 8 to it, so another_set get modified.

Let’s now try to push 8 again to another_set:

Output:

As you can see from the above example, a set contains just unique values and if you push a value that already exists, it will not grow.

Jupyter notebook for this section could be found here https://gitlab.com/datascience-book/code/-/blob/master/dictionary.ipynb

What comes to your mind when you think of a dictionary? Today in software or online dictionary you type a word and get its meaning in seconds. When I was small we had paper books, in each page there were printed lot of words and its meaning, even then we could find meaning of a word within one or two minutes. That’s because dictionary was a ordered set of words with which we could pin point the word were looking with ease. In programming languages dictionaries are designed in similar fashion, it could book looked up with ease.

In a language dictionary, you can think of a looked up word as a key or index, the meaning that is entered against the word as a value. Take a look at the code below, type it and execute it:

Output:

In the above example we create a dictionary using the Dict() function, the keys are 1, 2 and 3, we have given their English names as their values. Now if you want to get the spelling of 3, you can get it as shown:

Output:

One who knows arrays can argue this can be achieved with the following code:

that’s correct, but take the example as shown below:

Output:

above we have created a dictionary with prices of items, now say is it better for one to access price of a mango by giving prices[1], or prices["mango"]?

Let’s say we went to shop and bought two Briyani parcels and four Samosas, I’m starting to feel hungry now 😋. We can represent our purchase as shown:

Output:

Just to know more about dictionaries, this is how you would list keys of a dictionary:

Output:

This is how you will list values contained in the dictionary:

Output:

The length() function works in a dictionary and returns the count of key value pairs in it.

Output:

typeof() seems to be a universal function, and it works on dictionaries as well:

Output:

Now let’s calculate our bill, type the program below and see what happens:

Output:

So let me explain how the program works. First we have assigned a variable total to 0 here total = 0.

Next look at this statement:

look how we unravel the key value pair as (item, quantity). Since we are using a for loop, for every purchase, the key gets stored in variable called item and value get’s stored in variabe called quantity. Now for the first iteration it would would be like this:

total += prices[item] * quantity

Which would translate into total = 0 + (prices["briyani"] * 2), which will be reduced to total = 80 * 2, hence total will become 160, and the loop goes on and on till all the purchase elements are fetched and the total calculated, and we get a grand total of 220

Since we know list comprehension, we can write the above code as shown below:

Output:

Neat isn’t it?

You might be smart enough to write a piece of code today, but you may not be smart enough 6 months from now. The very code you created will look foreign and non-understandable. So it better for one to comment or add descriptions to ones code. All programming languages provide a way to write comments in them. Comments are there for programmers reference, when the program runs, the comments are ignored as the computer does not need it to run the code.

Take a look at the program below:

It’s a simple program to convert Celsius to Fahrenheit. But notice here:

Here the things followed by the hash , that is Temperature in Celsius is a comment. In the above code I have given C = 30, in reality it would have been far better if I had given celsius = 30 as in today’s way of coding we expect a code to be as good to read as a comment. Any way I hope you now get an idea what an comment is.

The example shown above is a single line comment. I could have given it like this too:

Personally I prefer comments being in a separate line.

Now if you want to write long paragraphs, there is a thing called multiline comments. It starts with a = and ends with a = as shown below:

You can find the source file for the program here https://gitlab.com/datascience-book/code/-/blob/master/comments.jl.

Let’s say you go to a hotel, you order the waiter a dish and you get it. Just saying "I want Briyani" gets you something. No need to tell the waiter how to purchase mutton, rice cook them and all those stuff, just a few words and you are able to accomplish this complex task. Just imagine what you have achieved! There is no need for you to tell about how to water the fields and dry the paddy, raise goats and all those stuff, just a few words and you are done. All is taken care at the background.

Programming is very similar to real world. You can wrap lot of things into a code block, give it a name and call it when needed. Those things are called functions. So lets see a piece of code that makes us understand it a bit. Type the code below and execute it.

Output:

So notice that how a simple and readable is this function call printline(), and it prints us a set of stars for us. You can remember it, call it easily and its intuitive. Those are the power of functions.

When designing a function have these in mind:

Okay now we know function is called by its name followed by round braces like printline() as shown above. Now let’s see how its defined:

You see above the keyword function, that says to Julia that we are defining a function. This is followed by the function name printline like this:

This is immediately followed by braces:

So these define the start of the function, now let’s say where it ends here using the end keyword:

Now between the function printline() and end, we can fill it with code the function should execute as shown:

In the above case we just tell it to print a line made up of 50 stars.

You can get the Jupyter notebook for this blog here https://gitlab.com/datascience-book/code/-/blob/master/functions.ipynb.