Numpy for the lazy beginner!.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy for the lazy beginner!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.12.1'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 4, 6, 8, 9])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1,3,4,6,8,9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.2,  4. ,  6. ,  9. ,  2.4])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([.2,4,6,9,2.4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.,   4.,   5.,   7.,  13.], dtype=float32)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1,4,5,7,13], dtype='float32')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5],\n",
       "       [ 5,  6,  7,  8,  9, 10],\n",
       "       [ 9, 10, 11, 12, 13, 14]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([range(i, i+6) for i in (0,5,9)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(10, dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1],\n",
       "       [1, 1, 1, 1],\n",
       "       [1, 1, 1, 1]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones([3,4], dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3.14,  3.14,  3.14,  3.14,  3.14],\n",
       "       [ 3.14,  3.14,  3.14,  3.14,  3.14],\n",
       "       [ 3.14,  3.14,  3.14,  3.14,  3.14]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full([3,5], 3.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  7, 14, 21, 28, 35, 42, 49])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0, 50, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 1, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.14114609,  0.98064775,  0.76761721],\n",
       "       [ 0.70084094,  0.72742762,  0.86458364],\n",
       "       [ 0.76275483,  0.43127351,  0.90287686]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.random([3,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.09860507, -0.03169911, -1.64011691],\n",
       "       [ 1.58492936, -0.73763235, -1.44347721],\n",
       "       [-0.55726846, -0.87956339,  1.09496824]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a 3x3 array of normally distributed random values \n",
    "# with mean 0 and standard deviation 1\n",
    "np.random.normal(0, 1, (3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 1, 3],\n",
       "       [5, 5, 0],\n",
       "       [9, 7, 2]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a 3x3 array of random integers in the interval [0, 10)\n",
    "np.random.randint(0, 10, (3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  0.,  0.],\n",
       "       [ 0.,  1.,  0.],\n",
       "       [ 0.,  0.,  1.]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a 3x3 identity matrix\n",
    "np.eye(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  1.,  1.])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create an uninitialized array of three integers\n",
    "# The values will be whatever happens to already exist at that # memory location\n",
    "np.empty(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Attributes of arrays:\n",
    "Determining the size, shape, memory consumption, and data types of arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(0) #seed for reproducebility\n",
    "x1 = np.random.randint(10, size=6) #One dimenion array\n",
    "x2 = np.random.randint(10, size=(3,4)) #Two dimension array\n",
    "x3 = np.random.randint(10, size=(2,4,6)) #Three dimension array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[8 1 5 9 8 9]\n",
      "  [4 3 0 3 5 0]\n",
      "  [2 3 8 1 3 3]\n",
      "  [3 7 0 1 9 9]]\n",
      "\n",
      " [[0 4 7 3 2 7]\n",
      "  [2 0 0 4 5 5]\n",
      "  [6 8 4 1 4 9]\n",
      "  [8 1 1 7 9 9]]]\n",
      "--------------\n",
      "Dimension: 3\n",
      "shape: (2, 4, 6)\n",
      "size: 48\n",
      "dtype: int64\n",
      "itemsize: 8\n",
      "Bytes: 384\n"
     ]
    }
   ],
   "source": [
    "print(x3)\n",
    "print('--------------')\n",
    "print('Dimension:', x3.ndim) #the number of dimensions\n",
    "print('shape:', x3.shape) #the size of each dimension\n",
    "print('size:', x3.size) #the total size of the array\n",
    "print('dtype:', x3.dtype) \n",
    "#itemsize: lists the size (in bytes) of each array element\n",
    "#nbytes: lists the total size (in bytes) of the array\n",
    "#In general, we expect that nbytes is equal to itemsize times size.\n",
    "print('itemsize:', x3.itemsize)\n",
    "print('Bytes:', x3.nbytes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indexing of arrays:\n",
    "Getting and setting the value of individual array elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x1:\n",
      "[5 0 3 3 7 9]\n",
      "5\n",
      "9\n",
      "--------------\n",
      "x2:\n",
      "[[3 5 2 4]\n",
      " [7 6 8 8]\n",
      " [1 6 7 7]]\n",
      "3\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "print('x1:')\n",
    "print(x1)\n",
    "print(x1[0])\n",
    "print(x1[-1])\n",
    "print('--------------')\n",
    "print('x2:')\n",
    "print(x2)\n",
    "print(x2[0,0])\n",
    "print(x2[2,-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slicing of arrays:\n",
    "Getting and setting smaller subarrays within a larger array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 0 3 3 7]\n",
      "[9]\n",
      "[3 7 9]\n",
      "[5 3 7]\n",
      "[5 3]\n"
     ]
    }
   ],
   "source": [
    "##One-dimensional subarrays\n",
    "print(x1[:5])\n",
    "print(x1[5:])\n",
    "print(x1[3:6])\n",
    "print(x1[::2])\n",
    "print(x1[0::3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x2[:3, :4]\n",
      "[[3 5 2 4]\n",
      " [7 6 8 8]\n",
      " [1 6 7 7]]\n",
      "--------------\n",
      "x2[:4, :3]\n",
      "[[3 5 2]\n",
      " [7 6 8]\n",
      " [1 6 7]]\n",
      "--------------\n",
      "x2[:-1, :-1]\n",
      "[[3 5 2]\n",
      " [7 6 8]]\n",
      "--------------\n",
      "x2[::-1, ::-1]\n",
      "[[7 7 6 1]\n",
      " [8 8 6 7]\n",
      " [4 2 5 3]]\n"
     ]
    }
   ],
   "source": [
    "##Multidimensional subarrays\n",
    "print('x2[:3, :4]')\n",
    "print(x2[:3, :4])\n",
    "print('--------------')\n",
    "print('x2[:4, :3]')\n",
    "print(x2[:4, :3])\n",
    "print('--------------')\n",
    "print('x2[:-1, :-1]')\n",
    "print(x2[:-1, :-1])\n",
    "print('--------------')\n",
    "print('x2[::-1, ::-1]')\n",
    "print(x2[::-1, ::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 7 1]\n",
      "[3 5 2 4]\n"
     ]
    }
   ],
   "source": [
    "##Accessing array rows and columns\n",
    "print(x2[:, 0]) # first column of x2\n",
    "print(x2[0, :]) # first row of x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 5 2 4]\n",
      " [7 6 8 8]\n",
      " [1 6 7 7]]\n",
      "--------------\n",
      "[[3 5]\n",
      " [7 6]]\n",
      "--------------\n",
      "[[99  5]\n",
      " [ 7  6]]\n",
      "--------------\n",
      "[[99  5  2  4]\n",
      " [ 7  6  8  8]\n",
      " [ 1  6  7  7]]\n"
     ]
    }
   ],
   "source": [
    "##Subarrays as no-copy views\n",
    "print(x2)\n",
    "print('--------------')\n",
    "x2_sub = x2[:2, :2] \n",
    "print(x2_sub)\n",
    "print('--------------')\n",
    "x2_sub[0, 0] = 99 \n",
    "print(x2_sub)\n",
    "print('--------------')\n",
    "print(x2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[99  5]\n",
      " [ 7  6]]\n",
      "--------------\n",
      "[[42  5]\n",
      " [ 7  6]]\n",
      "--------------\n",
      "[[99  5  2  4]\n",
      " [ 7  6  8  8]\n",
      " [ 1  6  7  7]]\n"
     ]
    }
   ],
   "source": [
    "##Creating copies of arrays\n",
    "x2_sub_copy = x2[:2, :2].copy() \n",
    "print(x2_sub_copy)\n",
    "print('--------------')\n",
    "x2_sub_copy[0, 0] = 42 \n",
    "print(x2_sub_copy)\n",
    "print('--------------')\n",
    "print(x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reshaping of arrays:\n",
    "Changing the shape of a given array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "grid = np.arange(1, 10).reshape((3, 3))\n",
    "print(grid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "--------------\n",
      "[[1 2 3]]\n",
      "--------------\n",
      "[[1]\n",
      " [2]\n",
      " [3]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1,2,3])\n",
    "print(x)\n",
    "print('--------------')\n",
    "print(x.reshape([1,3]))\n",
    "print('--------------')\n",
    "print(x.reshape([3,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Joining and splitting of arrays:\n",
    "Combining multiple arrays into one, and splitting one array into many"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  2,  3,  5,  6,  7,  9, 10, 11])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3 = np.array([1,2,3])\n",
    "x4 = np.array([5,6,7])\n",
    "np.concatenate([x3, x4])\n",
    "x5 = np.array([9, 10, 11])\n",
    "np.concatenate([x3, x4, x5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[99,  5,  2,  4],\n",
       "       [ 7,  6,  8,  8],\n",
       "       [ 1,  6,  7,  7],\n",
       "       [99,  5,  2,  4],\n",
       "       [ 7,  6,  8,  8],\n",
       "       [ 1,  6,  7,  7]])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate([x2,x2]) # concatenate along the first axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[99,  5,  2,  4, 99,  5,  2,  4],\n",
       "       [ 7,  6,  8,  8,  7,  6,  8,  8],\n",
       "       [ 1,  6,  7,  7,  1,  6,  7,  7]])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate([x2,x2], axis = 1) # concatenate along the second axis (zero-indexed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y1 = np.array([1,2,3])\n",
    "y2 = np.array([[4,5,6], [7,8,9]])\n",
    "np.vstack([y1,y2]) # vertically stack the arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  5,  6, 11],\n",
       "       [ 7,  8,  9, 12]])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y3 = np.array([[11],[12]])\n",
    "np.hstack([y2,y3]) # horizontally stack the arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 5 7]\n",
      "--------------\n",
      "[ 9 11 13]\n",
      "--------------\n",
      "[15]\n"
     ]
    }
   ],
   "source": [
    "y4 = np.array([1,3,5,7,9,11,13,15])\n",
    "z1, z2, z3 = np.split(y4, (4, 7)) #Split the array into multiple parts\n",
    "\n",
    "print(z1)\n",
    "print('--------------')\n",
    "print(z2)\n",
    "print('--------------')\n",
    "print(z3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]\n",
      " [12 13 14 15]]\n",
      "--------------\n",
      "[[ 0  1]\n",
      " [ 4  5]\n",
      " [ 8  9]\n",
      " [12 13]]\n",
      "[[ 2  3]\n",
      " [ 6  7]\n",
      " [10 11]\n",
      " [14 15]]\n",
      "--------------\n",
      "[[0 1 2 3]\n",
      " [4 5 6 7]]\n",
      "[[ 8  9 10 11]\n",
      " [12 13 14 15]]\n"
     ]
    }
   ],
   "source": [
    "grid = np.arange(16).reshape(4,4)\n",
    "print(grid)\n",
    "print('--------------')\n",
    "grid1, grid2 = np.hsplit(grid, [2])\n",
    "print(grid1)\n",
    "print(grid2)\n",
    "print('--------------')\n",
    "grid3, grid4 = np.vsplit(grid, [2])\n",
    "print(grid3)\n",
    "print(grid4)"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}