Programming in Data Science – A Brief Overview

Programming in Data Science – A Brief Overview

Understanding, comprehending, analyzing, and mining data is one of the biggest and highly valued tasks in today’s world.

The best way to master these is to learn to read and write codes, in other words, learn the art of coding. Coding or programming is very powerful in the age of data. Almost all the businesses are on the lookout for data, from within the company and also from external sources. They need this data to understand their company and their performance better and thereby gain insights to improve.

An example for a simple Binary Search:


def binary_search(arr, value, offset=0)

  mid =  (arr.length) / 2

  if value < arr[mid] binary_search(arr[0…mid], value, offset) elsif value > arr[mid]

     binary_search(arr[(mid + 1)..-1], value, offset + mid + 1)


     return offset + mid




Learning to code,  though seems difficult at the onset, could be learned effectively and efficiently through any of the best courses available. You could check out the Data Science course from GeekLurn.

This article discusses basic coding techniques and logic to learn to gradually master data science and thereby use it to develop and enhance any business and industrial segment in the world.

Data Science Oriented Programming in Brief

  • Computational Thinking – Algorithms

Algorithms are logically sequenced computational instructions, that helps to execute the program it corresponds to. They can also be understood as a source of successive guides given to the computer to carry out a task or an action.

Algorithm for Data Science

There are 2 main parts of an algorithm: the input and the output. The algorithm takes in the input, works on it, and executes the action, and finally provided the output. Algorithms are used widely in Itsector pertaining to any business domain. This helps carries out lengthy, huge, and tedious calculations. In some cases, this helps take critical and quick business decisions as well.

As a simple example, the long division method we follow in Mathematics is a classic example of an algorithm. There are inputs, the step-by-step instructions to follow to get the answer, and thereby output, which is the final answer.

  • Understand the Building Blocks – Data Constants and Variables

Constructing an algorithm is very much similar to constructing a building from scratch. There have to be some building blocks that help with the complete and foolproof construction of an algorithm. These are the data variables and constants. 

Variables are the elements that can hold different values at different points in time. These play a crucial role in calculation purposes where there would be a need to assign different values at different points in time.

  • The Trick to Pattern Formation and Repetition

A pattern is a sequence of data that repeats itself periodically. This repetition results in a logical flow of ideas as well. Another use of repetition codes is to repeat the message several times. This can be utilized as a powerful error-correcting methodology in coding.

Pattern formation is also immensely helpful. It can help visualize the code to a great extent, thereby making it easy to work o and predict the results as well. The whole coding environment could also be analyzed using the same method. This also helps to create shapes, curves, and related patterns to analyze the data that is being fed into the system or algorithm.

  • Handling Decision Points or Choices

An intricate part of coding is implementing choices in them. These are called Decision Nodes in the programming jargon. These nodes are ital as they execute all decisions or choices that need to be included in the program, in its algorithm.

Sample Python code of Decision Tree classifier:


import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

from sklearn import datasets

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier

iris = datasets.load_iris()

X =[:, 2:]

y =

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1, stratify=y)

clf_tree = DecisionTreeClassifier(criterion=’gini’, max_depth=4, random_state=1), y_train)


This part of programming also helps us handle all permutations and combinations of decisions possible with respect to the data fed into the algorithm, thereby giving us a range of possible answers based on the varied scenario.

Improper implementation of the same could lead to incorrect output and readings and program crashes at the worst. This is where this decision part of coding gets serious and must be handled with great care.

  • Debugging and Testing

Client requirements are gathered, the coding is done and the program is developed. Now, it is not possible to directly release the same to the client.

An important process called Debugging is necessary. Debugging helps to check every code of the algorithms, to verify and make sure it gives the output that is actually required. Though this is a bit of a time-consuming process, the importance of this is immense.

To understand this in detail, let is have a look at the below simple code to generate a code dump:


using namespace std;  

int divint(int, int);  

int main() 

   int x = 5, y = 2; 

   cout << divint(x, y); 

   x =3; y = 0; 

   cout << divint(x, y); 

   return 0; 


int divint(int a, int b) 

   return a / b; 



Now, to debug the same, the program has to be complied with -g option.

$g++ -g -o crash 

Floating point exception (core dumped) 

$gdb crash 

# Gdb prints summary information and then the (gdb) prompt

(gdb) r 

Program received signal SIGFPE, Arithmetic exception. 

0x08048681 in divint(int, int) (a=3, b=0) at 

21        return a / b; 

# ‘r’ runs the program inside the debugger 

# In this case the program crashed and gdb prints out some 

# relevant information.  In particular, it crashed trying 

# to execute line 21 of  The function parameters 

# ‘a’ and ‘b’ had values 3 and 0 respectively.  

(gdb) l 

# l is short for ‘list’.  Useful for seeing the context of 

# the crash, lists code lines near around 21 of  

(gdb) where 

#0  0x08048681 in divint(int, int) (a=3, b=0) at 

#1  0x08048654 in main () at 

# Equivalent to ‘bt’ or backtrace.  Produces what is known 

# as a ‘stack trace’.  Read this as follows:  The crash occurred 

# in the function divint at line 21 of  This, in turn, 

# was called from the function main at line 13 of  

(gdb) up 

# Move from the default level ‘0’ of the stack trace up one level 

# to level 1.  

(gdb) list 

# list now lists the code lines near line 13 of  

(gdb) p x 

# print the value of the local (to main) variable x 


It is imperative to understand the how and why of debugging the code. It ultimately helps to polish the code and make sure it does not yield bad results or crash while running. Certain line tracing techniques are often used to carry out the same. These techniques are important and much necessary to know for a programmer. 

  • Data Arrangement and Exploration

Data obtained to feed into the algorithm is almost always jumbled and messed up. There is no proper alignment if the same and reading this so-called Raw Data is a tedious process in itself.

This is where the Data Arrangement technique plays a huge role. Arranging data using proper methods help in obtaining great clarity and understanding of the data. It also makes the resulting data easier to work on and dissect. 

Arrays are an integral part of this process. A programmer must have in-depth knowledge as to why and how arrays could be used to represent data. This applies to both static and dynamic arrays.

  • The World of Functions, Queries, and Classes

Functions are a sequence of code that help execute a specific task. These are generally pre-defined in nature and could be utilized any number of times in a code depending on the need. Having said this, Functions could also be created in the code for temporary use. It all comes to what is required in the programming.

Queries are instances that help test ideas, explore patterns, and see connections between themes, topics, people, and places that exist in the project or program.

Classes hold a set of data together that needs to function as a unit. So, data could be segregated using this technique. This also makes it easier to view and visualize data to identify and predict the process flow and the outcome.

Important Tools to Master Data Science Coding

The best way to implement the theory on coding and programming is to use tools to analyze and work on them. Some of them are:

  • SAS
  • MatLab
  • Tableau
  • Python
  • BigML
  • Apache Spark
  • Excel
  • D3.js
  • Jupyter


Programming or coding is an intricate part of applying data science to various business areas. 

Almost all the businesses are on the lookout for data, from within the company and also from external sources. They need this data to understand their company and their performance better and thereby gain insights to improve.

Learning to code,  though seems difficult at the onset, could be learned effectively and efficiently through any of the best courses available. You could check out the Data Science course from GeekLurn.

Leave a Reply

Close Menu