numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Science with Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Numpy\n",
    "\n",
    "    NumPy is a Python package. It stands for 'Numerical Python'. It is a library consisting of multidimensional array objects and a collection of routines for processing of array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 1. Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 2. Ndarray Object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One dimensional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([1, 2, 3])\n",
    "print arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More than one dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1, 2], [3, 4]])\n",
    "print arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 3. dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    Data types: bool, int(8, 16, 32, 64), uint(8, 16, 32, 64), float(8, 16, 32, 64), complex(64, 128)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 4. Array Attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create empty array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  0.]\n",
      " [ 0.  0.]\n",
      " [ 0.  0.]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.empty([3, 2], dtype=float)\n",
    "print arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create an array filled with zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.  0.  0.  0.  0.]\n",
      "[[0 0]\n",
      " [0 0]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.zeros(5) # default dtype is float\n",
    "print arr\n",
    "\n",
    "arr = np.zeros([2, 2], dtype=int)\n",
    "print arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create array filled with ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.  1.  1.  1.  1.]\n",
      "[[1 1]\n",
      " [1 1]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.ones(5)\n",
    "print arr\n",
    "\n",
    "arr = np.ones([2, 2],dtype=int)\n",
    "print arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create array from existing data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.  2.]\n",
      " [ 3.  4.]]\n"
     ]
    }
   ],
   "source": [
    "a = [[1, 2], [3, 4]]\n",
    "\n",
    "arr = np.asarray(a, dtype=float)\n",
    "print arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create array with sequence with starting and ending and step size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.  3.  5.  7.  9.]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10, 2, dtype=float) # (start, stop, step, data_type)\n",
    "print arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create array with sequence with starting and ending with number of intervals\n",
    "and values will be evenly spread in intervals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(array([  1. ,   2.8,   4.6,   6.4,   8.2,  10. ]), 1.8)\n"
     ]
    }
   ],
   "source": [
    "arr = np.linspace(1, 10, 6, dtype=float, retstep=True) # retstep for interval size\n",
    "print arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ndarray.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1,2,3],[4,5,6]])\n",
    "print arr.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Resize the ndarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1,2,3],[4,5,6]])\n",
    "arr.shape = (3, 2)\n",
    "print arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Resize the ndarray with reshape function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1,2,3],[4,5,6]])\n",
    "re_arr = arr.reshape(3, 2)\n",
    "print re_arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get the dimension of array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 288,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re_arr.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 5. Indexing and slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inbuilt slice function, slice(start_index, stop_index, step)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8 9]\n",
      "[3 5 7]\n",
      "[3 5 7]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10)\n",
    "sliced = slice(2, 7, 2)\n",
    "print arr\n",
    "print arr[sliced]\n",
    "\n",
    "# another way\n",
    "print arr[2:7:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing a single item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "print arr[4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing item starting from index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "print arr[2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing staring_index and stop_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 4 5]\n"
     ]
    }
   ],
   "source": [
    "print arr[2:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing ndimensional array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array: \n",
      "[[1 2 3]\n",
      " [3 4 5]\n",
      " [4 5 6]] \n",
      "\n",
      "Getting items in second row: \n",
      "[3 4 5] \n",
      "\n",
      "Getting till second row: \n",
      "[[3 4 5]\n",
      " [4 5 6]] \n",
      "\n",
      "Getting items in second column only: \n",
      "[2 4 5] \n",
      "\n",
      "Getting items from second column onwards: \n",
      "[[2 3]\n",
      " [4 5]\n",
      " [5 6]] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([[1,2,3],[3,4,5],[4,5,6]])\n",
    "print 'Array: '\n",
    "print arr, '\\n'\n",
    "\n",
    "print 'Getting items in second row: '\n",
    "print arr[1,], '\\n' # or print arr[1,...]\n",
    "\n",
    "print 'Getting till second row: '\n",
    "print arr[1:], '\\n'\n",
    "\n",
    "print 'Getting items in second column only: '\n",
    "print arr[...,1], '\\n'\n",
    "\n",
    "print 'Getting items from second column onwards: '\n",
    "print arr[...,1:], '\\n'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 5]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2], [3, 4], [5, 6]]) \n",
    "y = x[[0,1,2], [0,1,0]] \n",
    "print y #selecting values (0,0), (1,1), (2,x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing and Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our array is:\n",
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n",
      "\n",
      "\n",
      "After slicing, our array becomes:\n",
      "[[ 4  5]\n",
      " [ 7  8]\n",
      " [10 11]]\n",
      "\n",
      "\n",
      "Slicing using advanced index for column:\n",
      "[[ 4  5]\n",
      " [ 7  8]\n",
      " [10 11]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]]) \n",
    "\n",
    "print 'Our array is:' \n",
    "print x \n",
    "print '\\n'  \n",
    "\n",
    "# slicing \n",
    "z = x[1:4,1:3] \n",
    "\n",
    "print 'After slicing, our array becomes:' \n",
    "print z \n",
    "print '\\n'  \n",
    "\n",
    "# using advanced index for column \n",
    "y = x[1:4,[1,2]] \n",
    "\n",
    "print 'Slicing using advanced index for column:' \n",
    "print y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conditioning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our array is:\n",
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n",
      "\n",
      "\n",
      "The items greater than 5 are:\n",
      "[ 6  7  8  9 10 11]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[ 0,  1,  2],[ 3,  4,  5],[ 6,  7,  8],[ 9, 10, 11]]) \n",
    "\n",
    "print 'Our array is:' \n",
    "print x \n",
    "print '\\n'  \n",
    "\n",
    "# Now we will print the items greater than 5 \n",
    "print 'The items greater than 5 are:' \n",
    "print x[x > 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Removing NaN values from array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our array is:  [ nan   1.   2.   3.  nan   4.   5.]\n",
      "Equivalent boolean:  [ True False False False  True False False]\n",
      "Array without NaN:  [ 1.  2.  3.  4.  5.]\n"
     ]
    }
   ],
   "source": [
    "arr = np.array([np.nan, 1, 2, 3, np.nan, 4, 5])\n",
    "print 'Our array is: ', arr\n",
    "\n",
    "print 'Equivalent boolean: ',np.isnan(arr)\n",
    "\n",
    "print 'Array without NaN: ',arr[~np.isnan(arr)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 6. Broadcasting\n",
    "    Broadcasting is a powerful mechanism that allows numpy to work with arrays of different shapes when performing arithmetic operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6 \\\\7 & 8 & 9 \\\\10 & 11 & 12\\end{bmatrix} + \n",
    "\\begin{bmatrix}1 & 0 & 1\\end{bmatrix} =\n",
    "\\begin{bmatrix}2 & 2 & 4 \\\\5 & 5 & 7 \\\\8 & 8 & 10 \\\\11 & 11 & 13\\end{bmatrix}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3], [4,5,6], [7,8,9],[10,11,12]], dtype=int)\n",
    "b = np.array([1,0,1])\n",
    "c = a + b\n",
    "print c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3])\n",
    "b = np.array([4,5,6])\n",
    "c = a * b\n",
    "print c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4  5]\n",
      " [ 8 10]\n",
      " [12 15]]\n"
     ]
    }
   ],
   "source": [
    "# Compute outer product of vectors\n",
    "v = np.array([1,2,3])  # v has shape (3,)\n",
    "w = np.array([4,5])    # w has shape (2,)\n",
    "# To compute an outer product, we first reshape v to be a column\n",
    "# vector of shape (3, 1); we can then broadcast it against w to yield\n",
    "# an output of shape (3, 2), which is the outer product of v and w:\n",
    "# [[ 4  5]\n",
    "#  [ 8 10]\n",
    "#  [12 15]]\n",
    "print(np.reshape(v, (3, 1)) * w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 4 6]\n",
      " [5 7 9]]\n"
     ]
    }
   ],
   "source": [
    "# Add a vector to each row of a matrix\n",
    "x = np.array([[1,2,3], [4,5,6]])\n",
    "# x has shape (2, 3) and v has shape (3,) so they broadcast to (2, 3),\n",
    "# giving the following matrix:\n",
    "# [[2 4 6]\n",
    "#  [5 7 9]]\n",
    "print(x + v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 7. Iterating over array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Row-wise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1,5).reshape([2,2])\n",
    "\n",
    "for elmt in np.nditer(arr):\n",
    "    print elmt,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Column-wise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 3 2 4 \n",
      "1 2 3 4\n"
     ]
    }
   ],
   "source": [
    "# First converting array to column wise then printing\n",
    "arr = arr.copy(order='F')\n",
    "\n",
    "for elmt in np.nditer(arr):\n",
    "    print elmt,\n",
    "    \n",
    "print ''    \n",
    "# or to just print column wise\n",
    "# printing column wise ordered array in row wise\n",
    "for elmt in np.nditer(arr, order='C'):\n",
    "    print elmt,\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifying array values while iterating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 4]\n",
      " [6 8]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1,5).reshape([2,2])\n",
    "\n",
    "for elmt in np.nditer(arr, op_flags=['readwrite']):\n",
    "    elmt[...] = elmt*2\n",
    "    \n",
    "print arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "External loop in while iterating"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 7] [2 5 8] [3 6 9]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1,10).reshape([3,3])\n",
    "\n",
    "for elmt in np.nditer(arr, flags=['external_loop'], order='F'):\n",
    "    print elmt,"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### 8. Array Manipluation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Our Array is:\n",
      "[1 2 3 4 5 6 7 8 9] \n",
      "whose shape is  (9,)\n",
      "\n",
      "Our Array after changing shape is: \n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]] \n",
      " whose shape is  (3, 3)\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10)\n",
    "print 'Our Array is:\\n',arr, '\\nwhose shape is ',arr.shape\n",
    "\n",
    "arr = arr.reshape([3,3])\n",
    "print '\\nOur Array after changing shape is: \\n',arr, '\\n whose shape is ',arr.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "flat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10).reshape([3,3])\n",
    "print np.array(arr.flat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "flatten"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array flatten:\n",
      "[1 2 3 4 5 6 7 8 9]\n",
      "Array flatten column wise\n",
      "[1 4 7 2 5 8 3 6 9]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10).reshape([3,3])\n",
    "\n",
    "print 'Array flatten:'\n",
    "print arr.flatten()\n",
    "print 'Array flatten column wise'\n",
    "print arr.flatten(order='F')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "transpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using transpose function:\n",
      "[[1 4 7]\n",
      " [2 5 8]\n",
      " [3 6 9]]\n",
      "Using numpy.ndarray.T:\n",
      "[[1 4 7]\n",
      " [2 5 8]\n",
      " [3 6 9]]\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(1, 10).reshape([3,3])\n",
    "\n",
    "print 'Using transpose function:'\n",
    "print np.transpose(arr)\n",
    "\n",
    "print 'Using numpy.ndarray.T:'\n",
    "print arr.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sqeeze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array X:\n",
      "[[[0 1 2]\n",
      "  [3 4 5]\n",
      "  [6 7 8]]]\n",
      "\n",
      "\n",
      "Array Y:\n",
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n",
      "\n",
      "\n",
      "The shapes of X and Y array:\n",
      "(1, 3, 3) (3, 3)\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(9).reshape(1,3,3) \n",
    "\n",
    "print 'Array X:' \n",
    "print x \n",
    "print '\\n'  \n",
    "y = np.squeeze(x) \n",
    "\n",
    "print 'Array Y:' \n",
    "print y \n",
    "print '\\n'  \n",
    "\n",
    "print 'The shapes of X and Y array:' \n",
    "print x.shape, y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "concatenate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First array:\n",
      "[[1 2]\n",
      " [3 4]]\n",
      "\n",
      "\n",
      "Second array:\n",
      "[[5 6]\n",
      " [7 8]]\n",
      "\n",
      "\n",
      "Joining the two arrays along axis 0:\n",
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]\n",
      " [7 8]]\n",
      "\n",
      "\n",
      "Joining the two arrays along axis 1:\n",
      "[[1 2 5 6]\n",
      " [3 4 7 8]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2],[3,4]]) \n",
    "\n",
    "print 'First array:' \n",
    "print a \n",
    "print '\\n'  \n",
    "b = np.array([[5,6],[7,8]]) \n",
    "\n",
    "print 'Second array:' \n",
    "print b \n",
    "print '\\n'  \n",
    "# both the arrays are of same dimensions \n",
    "\n",
    "print 'Joining the two arrays along axis 0:' \n",
    "print np.concatenate((a,b)) \n",
    "print '\\n'  \n",
    "\n",
    "print 'Joining the two arrays along axis 1:' \n",
    "print np.concatenate((a,b),axis = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "stack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Array:\n",
      "[[1 2]\n",
      " [3 4]]\n",
      "\n",
      "\n",
      "Second Array:\n",
      "[[5 6]\n",
      " [7 8]]\n",
      "\n",
      "\n",
      "Stack the two arrays along axis 0:\n",
      "[[[1 2]\n",
      "  [3 4]]\n",
      "\n",
      " [[5 6]\n",
      "  [7 8]]]\n",
      "\n",
      "\n",
      "Stack the two arrays along axis 1:\n",
      "[[[1 2]\n",
      "  [5 6]]\n",
      "\n",
      " [[3 4]\n",
      "  [7 8]]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2],[3,4]]) \n",
    "\n",
    "print 'First Array:' \n",
    "print a \n",
    "print '\\n'\n",
    "b = np.array([[5,6],[7,8]]) \n",
    "\n",
    "print 'Second Array:' \n",
    "print b\n",
    "print '\\n'  \n",
    "\n",
    "print 'Stack the two arrays along axis 0:' \n",
    "print np.stack((a,b),0)\n",
    "print '\\n'  \n",
    "\n",
    "print 'Stack the two arrays along axis 1:' \n",
    "print np.stack((a,b),1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "hstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First array:\n",
      "[[1 2]\n",
      " [3 4]]\n",
      "\n",
      "\n",
      "Second array:\n",
      "[[5 6]\n",
      " [7 8]]\n",
      "\n",
      "\n",
      "Horizontal stacking:\n",
      "[[1 2 5 6]\n",
      " [3 4 7 8]]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2],[3,4]]) \n",
    "\n",
    "print 'First array:' \n",
    "print a \n",
    "print '\\n'  \n",
    "b = np.array([[5,6],[7,8]]) \n",
    "\n",
    "print 'Second array:' \n",
    "print b \n",
    "print '\\n'  \n",
    "\n",
    "print 'Horizontal stacking:' \n",
    "c = np.hstack((a,b)) \n",
    "print c \n",
    "print '\\n'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "vstack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First array:\n",
      "[[1 2]\n",
      " [3 4]]\n",
      "\n",
      "\n",
      "Second array:\n",
      "[[5 6]\n",
      " [7 8]]\n",
      "\n",
      "\n",
      "Horizontal stacking:\n",
      "[[1 2 5 6]\n",
      " [3 4 7 8]]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2],[3,4]]) \n",
    "\n",
    "print 'First array:' \n",
    "print a \n",
    "print '\\n'  \n",
    "b = np.array([[5,6],[7,8]]) \n",
    "\n",
    "print 'Second array:' \n",
    "print b \n",
    "print '\\n'  \n",
    "\n",
    "print 'Horizontal stacking:' \n",
    "c = np.hstack((a,b)) \n",
    "print c \n",
    "print '\\n'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}