DataAnalytics by Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "my_dictionary ={\"red\":\"2\", \"blue\" : \"3\", \"green\" : \"4\"}\n",
    "print(my_dictionary[\"red\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Functions\n",
    "*note : Python uses indentation to group lines of code or to determine scope*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n"
     ]
    }
   ],
   "source": [
    "# function defnition\n",
    "def greetings():\n",
    " print(\"Hello world\")\n",
    "    \n",
    "# function call    \n",
    "greetings()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sum function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "103"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([1,2,100])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### range function\n",
    "*range(start, stop, step)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n",
      "range(5)\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for n in range(1,10, 2):\n",
    " print(n)\n",
    "print(\"range(5)\")\n",
    "for n in range(5):\n",
    " print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numpy functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "103"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.sum([1,2,100])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### unique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1, 2, 3, 5]), array([2, 2, 2, 1]))"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique([1,2,3,3,2,1,5], return_counts=True) # returns unique data with thier counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists and accessing it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BLUE\n",
      "YELLOW\n",
      "RED\n",
      "GREEN\n",
      "ORANGE\n"
     ]
    }
   ],
   "source": [
    "color = {\"RED\", \"BLUE\", \"GREEN\", \"YELLOW\", \"ORANGE\"}\n",
    "for c in color:\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "input_values = [1, 2, 3, 4, 5]\n",
    "output_values = [1.5, 5, 9, 16, 25]\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(input_values, output_values, linewidth=3)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pandas Basics\n",
    " *A library to handle data*\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Google' 'OYO']\n",
      "Google\n",
      "0       OYO\n",
      "1    Google\n",
      "2    Google\n",
      "Name: Company, dtype: object\n",
      "\n",
      "\n",
      "  Company Department Name Location\n",
      "1  Google              AI       US\n",
      "2  Google         Quantum       US\n",
      "Index(['wmc', 'dit', 'noc', 'cbo', 'rfc', 'lcom', 'ca', 'ce', 'npm', 'lcom3',\n",
      "       'loc', 'dam', 'moa', 'mfa', 'cam', 'ic', 'cbm', 'amc', 'max_cc',\n",
      "       'avg_cc'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# Creating a dataframe with dictionary \n",
    "\n",
    "COMPANY_INFO = {\n",
    "         'Company' : ['OYO', 'Google', 'Google'],\n",
    "         'Department Name' : ['Registration', 'AI', 'Quantum'],\n",
    "         'Location' : ['Bangalore', 'US', 'US']\n",
    "        }\n",
    "\n",
    "COMPANY_INFO_DATA = pd.DataFrame(COMPANY_INFO)\n",
    "\n",
    "elements, count = np.unique(COMPANY_INFO['Company'], return_counts=True)\n",
    "print(elements)\n",
    "print(elements[0])\n",
    "print(COMPANY_INFO_DATA['Company'])\n",
    "\n",
    "print('\\n')\n",
    "# A complex query of dataframe\n",
    "print(COMPANY_INFO_DATA.where(COMPANY_INFO_DATA['Company'] == elements[0]).dropna()) # droping NaN\n",
    " \n",
    "\n",
    "# Creating dataframe from file\n",
    "\n",
    "FILE_PATH = './ant-1.3/ant-1.3.csv'\n",
    "df = None\n",
    "try:\n",
    " df = pd.read_csv(FILE_PATH)\n",
    " print(df.columns[3:23])\n",
    "except FileNotFoundError:\n",
    " print(\"Exception : FileNotFounfError, hence file could not be read\")\n",
    "\n",
    "# Saving file  as CSV\n",
    "DEST_FILE_PATH = 'lab_new.csv'\n",
    "if df is not None :\n",
    " df.to_csv(DEST_FILE_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " hello\n",
      " hi\n",
      " hello\n",
      " hi\n",
      " hello\n",
      " hi\n",
      " hello\n",
      " hi\n",
      " hello\n",
      " hi\n",
      "Scope outside for\n"
     ]
    }
   ],
   "source": [
    "flag = ['1','2','3','4','5']\n",
    "for i in flag:\n",
    "  print(' hello')\n",
    "    \n",
    "  print(' hi')  \n",
    "print(\"Scope outside for\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eucledian distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.123105625617661"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy import linalg as LA\n",
    "#c = np.array([[1,2],[1,2]])\n",
    "a = np.array([5, 3])\n",
    "b = np.array([1,2])\n",
    "LA.norm(a-b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Eucledian distance using scipy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.123105625617661\n"
     ]
    }
   ],
   "source": [
    "from scipy.spatial import distance\n",
    "# a = (5,3)\n",
    "# b = (1,2)\n",
    "a = np.array([5, 3])\n",
    "b = np.array([1,2])\n",
    "dst = distance.euclidean(a, b)\n",
    "print(dst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Vector subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "By method 1  [ 1 -1]\n",
      "By method 2  [1, -1]\n"
     ]
    }
   ],
   "source": [
    "# method 1\n",
    "a = np.array([1,0])\n",
    "b = np.array([0,1])\n",
    "z = a - b\n",
    "print(\"By method 1 \", z)\n",
    "\n",
    "# method 2, requires more lines of code which can be done by single line above\n",
    "a = np.array([1,0])\n",
    "b = np.array([0,1])\n",
    "z = []\n",
    "for n,m in zip(a, b):\n",
    "    z.append(n-m)\n",
    "print(\"By method 2 \", z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Dot product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dot product =  5\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2])\n",
    "b = np.array([3,1])\n",
    "print(\"Dot product = \", np.dot(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Ploting mathematical functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fdaf1161978>]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0, 2*np.pi, 100) # generates evenly spaced samples\n",
    "y = np.sin(x)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Calculation of mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean =  3.0\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3,4,5])\n",
    "print(\"Mean = \", a.mean())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element at position 1,2 =  8\n",
      "Slicing 0th column and getting elements from index 0 to index 3 excluding index 3 =  [ 1  6 11 16]\n",
      "Slicing 0th row and getting elements from index 0 to 4 excluding 4  = [1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20]])\n",
    "print(\"Element at position 1,2 = \", a[1][2])\n",
    "print(\"Slicing 0th column and getting elements from index 0 to index 3 excluding index 3 = \", a[0:4, 0])\n",
    "print(\"Slicing 0th row and getting elements from index 0 to 4 excluding 4  =\", a[0, 0:4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}