Python - Numpy Guide.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python - Numpy Guide\n",
    "\n",
    "\n",
    "#### Priyaranjan Mohanty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 4 # Its a comment\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy : what is it ?\n",
    "\n",
    "Numpy is the most basic and a powerful package for working with data in python.\n",
    "\n",
    "If you are going to work on data analysis or machine learning projects, then having a solid understanding of numpy is nearly mandatory.\n",
    "\n",
    "Because other packages for data analysis (like pandas) is built on top of numpy and the scikit-learn package which is used to build machine learning applications works heavily with numpy as well.\n",
    "\n",
    "So what does numpy provide?\n",
    "\n",
    "At the core, numpy provides the excellent ndarray objects, short for n-dimensional arrays.\n",
    "\n",
    "In a ‘ndarray’ object, aka ‘array’, you can store multiple items of the same data type. It is the facilities around the array object that makes numpy so convenient for performing math and data manipulations.\n",
    "\n",
    "You might wonder, ‘I can store numbers and other objects in a python list itself and do all sorts of computations and manipulations through list comprehensions, for-loops etc. What do I need a numpy array for?’\n",
    "\n",
    "Well, there are very significant advantages of using numpy arrays overs lists.\n",
    "\n",
    "To understand this, let’s first see how to create a numpy array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to create NDArray ( Numpy Array )\n",
    "\n",
    "There are multiple ways to create a numpy array. \n",
    "\n",
    "However one of the most common ways is to create one from a list or a list like an object by passing it to the np.array function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: numpy in c:\\users\\itzpr\\anaconda3\\lib\\site-packages (1.16.3)\n"
     ]
    }
   ],
   "source": [
    "# Install Numpy \n",
    "\n",
    "!pip install numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import Numpy \n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an 1 dimensional array from a list\n",
    "\n",
    "list1 = [0,1,2,3,4]\n",
    "\n",
    "Arr_1d = np.array(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "\n",
      "\n",
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# Print the array and its type\n",
    "print(type(Arr_1d))\n",
    "\n",
    "print(\"\\n\")\n",
    "\n",
    "print(Arr_1d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5,)\n"
     ]
    }
   ],
   "source": [
    "# Print the shape of the Array\n",
    "\n",
    "print(Arr_1d.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The key difference between an array and a list is, arrays are designed to handle vectorized operations while a python list is not.\n",
    "\n",
    "That means, if you apply a function it is performed on every item in the array, rather than on the whole array object.\n",
    "\n",
    "Let’s suppose you want to add the number 2 to every item in the list. The intuitive way to do it is something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "print(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate list (not \"int\") to list",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-a66ed14c8eee>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mlist1\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate list (not \"int\") to list"
     ]
    }
   ],
   "source": [
    "list1 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Arr_1d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Arr_1d + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Next Step - Lets create 2 Dimensional Array \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a 2d array from a list of lists\n",
    "\n",
    "list_2D = [[0,1,2,3], \n",
    "           [4,5,6,7], \n",
    "           [8,9,10,11]]\n",
    "\n",
    "Arr_2D = np.array(list_2D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Arr_2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(Arr_2D))\n",
    "\n",
    "print(\"\\n\")\n",
    "\n",
    "print(Arr_2D)\n",
    "\n",
    "print(\"\\n\")\n",
    "\n",
    "print(Arr_2D.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also create a 2-D Array from a flat list ( Not a nested list )\n",
    "\n",
    "List_Num = [0,1,2,3,4,5,6,7,8,9,10,11]\n",
    "\n",
    "# Array_1D_2 = np.array(List_Num)\n",
    "\n",
    "# Array_2D_2 = Array_1D_2.reshape(3,4)\n",
    "\n",
    "Array_2D_2 = np.array(List_Num).reshape(3,4)\n",
    "\n",
    "Array_2D_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Array_2D_2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Array_2D_3 = Array_2D_2.reshape(6,2)\n",
    "\n",
    "Array_2D_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also specify the datatype by setting the dtype argument. \n",
    "\n",
    "Some of the most commonly used numpy dtypes are: 'float', 'int', 'bool', 'str'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Arr_2D_2 = np.array(list_2D)\n",
    "\n",
    "print(Arr_2D_2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a float 2d array\n",
    "\n",
    "Arr_2D_2 = np.array(list_2D, dtype='float')\n",
    "\n",
    "print(Arr_2D_2)\n",
    "\n",
    "print(Arr_2D_2.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note -\n",
    "\n",
    "A numpy array must have all items to be of the same data type, unlike lists. This is another significant difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note :\n",
    "\n",
    "We can always convert a Numpy Array back to List "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Arr_1d)\n",
    "\n",
    "print(type(Arr_1d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert an ndarray to list \n",
    "\n",
    "print(Arr_1d.tolist())\n",
    "\n",
    "print(\"\\n\")\n",
    "\n",
    "print(type(Arr_1d.tolist()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Arr_2D)\n",
    "\n",
    "print(\"\\n\")\n",
    "\n",
    "print(type(Arr_2D))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert 2-d array to list \n",
    "\n",
    "print(Arr_2D.tolist())\n",
    "\n",
    "print(\"\\n\")\n",
    "\n",
    "print(type(Arr_2D.tolist()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### To summarise, \n",
    "\n",
    "The main differences with python lists are:\n",
    "\n",
    "Arrays support vectorised operations, while lists don’t.\n",
    "\n",
    "Once an array is created, you cannot change its size. You will have to create a new array or overwrite the existing one.\n",
    "\n",
    "Every array has one and only one dtype. All items in it should be of that dtype.\n",
    "\n",
    "An equivalent numpy array occupies much less space than a python list of lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some Functions , Methods or Attributes associates with Numpy Array Object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Arr_2D)\n",
    "\n",
    "print(Arr_2D.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the number of dimensions of a Numpy array using ndim attribute\n",
    "\n",
    "print(Arr_2D.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the shape of the numpy array object\n",
    "\n",
    "print(Arr_2D.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the size of the numpy array object\n",
    "\n",
    "print(Arr_2D.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the data type of the numpy array object\n",
    "\n",
    "print(Arr_2D.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if I try to create an Array from a list containing hetrogenous data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "List_var = [1,2,'a','b']\n",
    "\n",
    "Array_2D_3 = np.array(List_var).reshape(2,2)\n",
    "\n",
    "print(Array_2D_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Extracting specific items from an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Arr_1d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Arr_1d[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Arr_1d[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Arr_1d[-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extracting elements from a multi dimensional array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Arr_2D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "List_2_Var = [[ 0 , 1 , 2 , 3] ,  [ 4 , 5 , 6 , 7] ,  [ 8 , 9 ,10 , 11]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Arr_2D[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract the element which is in 2nd row and 1st column of the array \n",
    "\n",
    "Arr_2D[1,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract the elements which are in 2nd row ( all columns )\n",
    "\n",
    "print(Arr_2D[1,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract the elements which are in 1st column ( all rows )\n",
    "\n",
    "Arr_2D[:,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract the elements which are in 1st & 2nd row of column 1\n",
    "\n",
    "Arr_2D[:2,0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additionally, numpy arrays support boolean indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Arr_2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Bool_Idx = Arr_2D > 5\n",
    "\n",
    "print(Bool_Idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Arr_2D[Bool_Idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(Arr_2D[Bool_Idx]))\n",
    "\n",
    "print(Arr_2D[Bool_Idx].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifying / updating the contents of an array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Arr_2D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Arr_2D[2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Update the last element in last row of the array\n",
    "\n",
    "Arr_2D[2,1] = 99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Arr_2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute mean, min, max on the ndarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "print(Arr_2D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean value is:  5.5\n",
      "Max value is:  11\n",
      "Min value is:  0\n"
     ]
    }
   ],
   "source": [
    "# mean, max and min\n",
    "\n",
    "print(\"Mean value is: \", Arr_2D.mean())\n",
    "\n",
    "print(\"Max value is: \", Arr_2D.max())\n",
    "\n",
    "print(\"Min value is: \", Arr_2D.min())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### However, if we want to compute the minimum values row wise or column wise, \n",
    "\n",
    "use the np.amin version instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Column wise minimum:  [0 1 2 3]\n",
      "Row wise minimum:  [0 4 8]\n"
     ]
    }
   ],
   "source": [
    "# Row wise and column wise min\n",
    "\n",
    "print(\"Column wise minimum: \", np.amin(Arr_2D, axis=0))\n",
    "\n",
    "print(\"Row wise minimum: \", np.amin(Arr_2D, axis=1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Row wise and column wise max\n",
    "\n",
    "print(\"Column wise minimum: \", np.amax(Arr_2D, axis=0))\n",
    "\n",
    "print(\"Row wise minimum: \", np.amax(Arr_2D, axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How to create a new array from an existing array?\n",
    "\n",
    "\n",
    "If you just assign a portion of an array to another array, the new array you just created actually refers to the parent array in memory.\n",
    "\n",
    "That means, if you make any changes to the new array, it will reflect in the parent array as well.\n",
    "\n",
    "So to avoid disturbing the parent array, you need to make a copy of it using copy(). All numpy arrays come with the copy() method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original 2-d Array :\n",
      " [[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "\n",
      "\n",
      "Copied 2-d Array :\n",
      " [[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "# Assign one array to another new array \n",
    "\n",
    "Arr_2D_Cpy = Arr_2D\n",
    "\n",
    "print(\"Original 2-d Array :\\n\" ,Arr_2D)\n",
    "print('\\n')\n",
    "print(\"Copied 2-d Array :\\n\" ,Arr_2D_Cpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Making a change in the value of copied array will have the change reflected in the original array as well.\n",
    "\n",
    "Which shows that the copied Array and Original Array are both referring to same memory location."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[100   1   2   3]\n",
      " [  4   5   6   7]\n",
      " [  8   9  10  11]]\n"
     ]
    }
   ],
   "source": [
    "# Making changes in the copied Array and printing the content of original array \n",
    "\n",
    "Arr_2D_Cpy[0, 0] = 100  # 100 will reflect in arr2\n",
    "\n",
    "print(Arr_2D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now , how do we 'Really' create a copy of an Array with the copy of the array having its own memory allocation.\n",
    "\n",
    "We use array.copy() method to create a copy of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[100   1   2   3]\n",
      " [  4   5   6   7]\n",
      " [  8   9  10  11]]\n",
      "\n",
      "\n",
      "[[100   1   2   3]\n",
      " [  4   5   6   7]\n",
      " [  8   9  10  11]]\n"
     ]
    }
   ],
   "source": [
    "# creating a copy of new array from another array \n",
    "\n",
    "Arr_2D_Cpy2_23424 = Arr_2D.copy()\n",
    "\n",
    "print(Arr_2D)\n",
    "print('\\n')\n",
    "print(Arr_2D_Cpy2_23424)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now , lets modify the value of the element in first row and first column of Copied Array and see if that change gets effected in the original array as well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[100   1   2   3]\n",
      " [  4   5   6   7]\n",
      " [  8   9  10  11]]\n",
      "\n",
      "\n",
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "Arr_2D_Cpy2_23424[0, 0] = 0  # 100 will reflect in arr2\n",
    "\n",
    "print(Arr_2D)\n",
    "print('\\n')\n",
    "print(Arr_2D_Cpy2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Combining / Concatenating Arrays "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concatenating 1 dimensional Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "[11 22 33 44 55]\n"
     ]
    }
   ],
   "source": [
    "# Concatenating 1 dimensional Arrays\n",
    "\n",
    "Array_1D_1 = np.array([1,2,3,4])\n",
    "print(Array_1D_1)\n",
    "\n",
    "Array_1D_2 = np.array([11,22,33,44,55])\n",
    "print(Array_1D_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  4, 11, 22, 33, 44, 55])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate([Array_1D_1, Array_1D_2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concatenating 2 dimensional Arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "\n",
      "\n",
      "[[11 22 33]\n",
      " [44 55 66]]\n"
     ]
    }
   ],
   "source": [
    "Array_2D_1 = np.array([1,2,3,4,5,6]).reshape(2,3)\n",
    "print(Array_2D_1)\n",
    "\n",
    "print(\"\\n\")\n",
    "\n",
    "Array_2D_2 = np.array([11,22,33,44,55,66]).reshape(2,3)\n",
    "print(Array_2D_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When Concatenating 2 Dimensional Array , the concatenation could of 1 of 2 possible types -\n",
    "\n",
    "Type 1 : Concatenating by rows \n",
    "\n",
    "Type 2 : Concatenating by columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concatenating by rows "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3],\n",
       "       [ 4,  5,  6],\n",
       "       [11, 22, 33],\n",
       "       [44, 55, 66]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# concatenate along the first axis ( Row )\n",
    "\n",
    "np.concatenate([Array_2D_1, Array_2D_2],\n",
    "              axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3, 11, 22, 33],\n",
       "       [ 4,  5,  6, 44, 55, 66]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# concatenate along the second axis ( column )\n",
    "\n",
    "np.concatenate([Array_2D_1, Array_2D_2],\n",
    "              axis = 1)"
   ]
  },
  {
   "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}