Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(15)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]\n",
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]]\n"
     ]
    }
   ],
   "source": [
    "b = a.reshape(3,5)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(15,)\n",
      "(3, 5)\n"
     ]
    }
   ],
   "source": [
    "print(a.shape)\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(15, 1)\n",
      "[[ 0]\n",
      " [ 1]\n",
      " [ 2]\n",
      " [ 3]\n",
      " [ 4]\n",
      " [ 5]\n",
      " [ 6]\n",
      " [ 7]\n",
      " [ 8]\n",
      " [ 9]\n",
      " [10]\n",
      " [11]\n",
      " [12]\n",
      " [13]\n",
      " [14]]\n",
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(15)\n",
    "c = a.reshape(15,1)\n",
    "print(c.shape)\n",
    "print(c)\n",
    "d = c.reshape(15,)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.ndim #number of axis, ie.e the number of dimensions, you can get it from shape too"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print(c.ndim)\n",
    "print(d.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1  2  3]\n",
      "  [ 4  5  6  7]]\n",
      "\n",
      " [[ 8  9 10 11]\n",
      "  [12 13 14 15]]]\n"
     ]
    }
   ],
   "source": [
    "c = np.arange(16).reshape(2,2,4)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 2, 4)\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(c.shape)\n",
    "print(c.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15 18 21 24 27]\n",
      "[10 35 60]\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(b, axis =0)) # sum down the column\n",
    "print(np.sum(b, axis =1)) # sum down the rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "columns [[ 8 10 12 14]\n",
      " [16 18 20 22]]\n",
      "rowns [[ 4  6  8 10]\n",
      " [20 22 24 26]]\n",
      "the third dimension [[ 6 22]\n",
      " [38 54]]\n"
     ]
    }
   ],
   "source": [
    "print(\"columns\", np.sum(c, axis =0))\n",
    "print(\"rowns\", np.sum(c, axis =1))\n",
    "print(\"the third dimension\", np.sum(c, axis =2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1]\n",
      " [1 1 1]]\n",
      "[[9 9 9]\n",
      " [9 9 9]]\n"
     ]
    }
   ],
   "source": [
    "np_array_1s = np.array([[1,1,1],[1,1,1]])\n",
    "np_array_9s = np.array([[9,9,9],[9,9,9]])\n",
    "print(np_array_1s)\n",
    "print(np_array_9s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1]\n",
      " [1 1 1]\n",
      " [9 9 9]\n",
      " [9 9 9]]\n"
     ]
    }
   ],
   "source": [
    "conc = np.concatenate([np_array_1s, np_array_9s], axis = 0)\n",
    "print(conc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4, 3)\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "print(conc.shape)\n",
    "print(np_array_1s.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1 9 9 9]\n",
      " [1 1 1 9 9 9]]\n",
      "(2, 6)\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "concv = np.concatenate([np_array_1s, np_array_9s], axis =1)\n",
    "print(concv)\n",
    "print(concv.shape)\n",
    "print(concv.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32\n"
     ]
    }
   ],
   "source": [
    "print(b.dtype.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concv.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conc.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# similar to a.dtype.itemsize, returns datatype size in bytes i.e. 32/8 = 4 bytes\n",
    "a.itemsize\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "concv.size # number of items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48\n"
     ]
    }
   ],
   "source": [
    "# total bytes taken\n",
    "tot_byte = concv.size * concv.itemsize\n",
    "print(tot_byte)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(concv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n",
      "int32\n"
     ]
    }
   ],
   "source": [
    "# Array Creation\n",
    "a = np.array([2,3,4])\n",
    "b = np.array([3.4,4.1,4.5])\n",
    "print(b.dtype)\n",
    "print(a.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "array() takes from 1 to 2 positional arguments but 3 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-34-9e38e98da52c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# wrong way\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: array() takes from 1 to 2 positional arguments but 3 were given"
     ]
    }
   ],
   "source": [
    "# wrong way\n",
    "c = np.array(2,3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n"
     ]
    }
   ],
   "source": [
    "c = np.array([1,2.3,3.3,1])\n",
    "print(c.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.5 2.  3. ]\n",
      " [4.  5.  6. ]]\n",
      "(2, 3)\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "b = np.array([(1.5,2,3), (4,5,6)])\n",
    "print(b)\n",
    "print(b.shape)\n",
    "print(b.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.+2.j 2.+0.j]\n",
      " [3.+0.j 4.+0.j]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "c = np.array( [ [2j,2], [3,4] ], dtype=complex )\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0.])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "z =np.zeros([3,4])\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1 1]\n",
      " [1 1 1]\n",
      " [1 1 1]]\n",
      "int16\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "a = np.ones([3,3], dtype = np.int16)  #we can add data type too\n",
    "print(a)\n",
    "print(a.dtype)\n",
    "print(a.itemsize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.25844432e-047, 2.48482102e+184, 1.13039161e-042],\n",
       "       [9.41532186e-067, 4.94782283e+173, 7.32093170e-198]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# empty with garbadge values, here these prviously stored values, output of cell 38\n",
    "np.empty([2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 15, 20, 25])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange( 10, 30, 5 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange( 0, 2, 0.3 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.  , 0.25, 0.5 , 0.75, 1.  , 1.25, 1.5 , 1.75, 2.  ])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace( 0, 2, 9 )  # nine numbers from 0 to 2, we can use this to evaluate any function with lots of points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.6981317  1.3962634  2.0943951  2.7925268  3.4906585\n",
      " 4.1887902  4.88692191 5.58505361 6.28318531]\n"
     ]
    }
   ],
   "source": [
    "from numpy import pi\n",
    "x = np.linspace(0,2*pi,10)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.00000000e+00  6.42787610e-01  9.84807753e-01  8.66025404e-01\n",
      "  3.42020143e-01 -3.42020143e-01 -8.66025404e-01 -9.84807753e-01\n",
      " -6.42787610e-01 -2.44929360e-16]\n"
     ]
    }
   ],
   "source": [
    "f = np.sin(x)\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0 10 20 30 40 50 60 70 80 90]\n",
      "[  0.  10.  20.  30.  40.  50.  60.  70.  80.  90. 100.]\n"
     ]
    }
   ],
   "source": [
    "print(np.arange(0,100,10))\n",
    "print(np.linspace(0,100,11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0]\n",
      "[0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556\n",
      " 0.66666667 0.77777778 0.88888889 1.        ]\n"
     ]
    }
   ],
   "source": [
    "print(np.arange(0,1,10))\n",
    "print(np.linspace(0,1,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(15).reshape(3,5)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0 0]\n",
      " [0 0 0 0 0]\n",
      " [0 0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "b =np.zeros_like(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# similar case with ones_likes, empty_likes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5715733 , 0.71905908],\n",
       "       [0.69134552, 0.93021815],\n",
       "       [0.23041034, 0.97190496]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand(3,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.06008956,  0.2980215 ],\n",
       "       [ 1.07257461,  0.6229768 ],\n",
       "       [-0.56513023, -0.98202476]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Return a sample (or samples) from the “standard normal” distribution.\n",
    "np.random.randn(3,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True, False, False],\n",
       "       [False,  True, False]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The fromfunction() function is used to construct an array by executing a function over each coordinate.\n",
    "# The resulting array therefore has a value fn(x, y, z) at coordinate (x, y, z).\n",
    "# numpy.fromfunction(function, shape, *, dtype=<class 'float'>, **kwargs)[source]\n",
    "np.fromfunction(lambda i, j: i == j, (2, 3), dtype=int)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [1, 2, 3],\n",
       "       [2, 3, 4]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20 30 40 50]\n",
      "[0 1 2 3]\n",
      "[20 29 38 47]\n"
     ]
    }
   ],
   "source": [
    "# Basic operations, elementwise\n",
    "a = np.array( [20,30,40,50] )\n",
    "b = np.arange( 4 )\n",
    "print(a)\n",
    "print(b)\n",
    "c = a-b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 4, 9], dtype=int32)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10*np.sin(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True, False, False])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = a<35"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 1]\n",
      " [0 1]]\n",
      "[[2 0]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array( [[1,1],[0,1]] )\n",
    "B = np.array( [[2,0],[3,4]] )\n",
    "print(A)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 0],\n",
       "       [0, 4]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A*B  #elementwise multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 4],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for matrix product use @ or dot\n",
    "A@B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 4],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# or\n",
    "A.dot(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 3, 3],\n",
       "       [3, 3, 3]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "a = np.ones((2,3), dtype=int)\n",
    "b = np.random.random((2,3))\n",
    "a *= 3\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6.12845882, 6.84398549, 6.38881696],\n",
       "       [6.77060221, 6.23145008, 6.26645838]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b+=a  # b = b+a \n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "ename": "UFuncTypeError",
     "evalue": "Cannot cast ufunc 'add' output from dtype('float64') to dtype('int32') with casting rule 'same_kind'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUFuncTypeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-21-b0f7d0e94841>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mUFuncTypeError\u001b[0m: Cannot cast ufunc 'add' output from dtype('float64') to dtype('int32') with casting rule 'same_kind'"
     ]
    }
   ],
   "source": [
    "a += b  #  a= a+ b\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'float64'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.dtype.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'float64'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = a+b\n",
    "c.dtype.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.93234077-0.36158082j, -0.92310531-0.38454725j,\n",
       "        -0.80438332-0.59411066j],\n",
       "       [-0.99696667-0.07782973j, -0.81325598-0.5819061j ,\n",
       "        -0.78078937-0.62479433j]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = np.exp(c*1j)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'complex128'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.dtype.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.35702631, 0.16972541, 0.86778503],\n",
       "       [0.74053792, 0.71511039, 0.64117285]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# \"The only difference is in how the arguments are handled. With numpy.random.rand(), \n",
    "# the length of each dimension of the output array is a separate argument. \n",
    "#With numpy.random.random(), the shape argument is a single tuple\"\n",
    "a = np.random.random((2,3))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.4913579125653"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.sum()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8677850337389671\n",
      "0.16972541355676773\n"
     ]
    }
   ],
   "source": [
    "print(a.max())\n",
    "print(a.min())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "b = np.arange(12).reshape(3,4)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12, 15, 18, 21])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.sum(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6, 22, 38])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.sum(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 4, 8])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.min(axis=1)  # min value from each row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  3,  6],\n",
       "       [ 4,  9, 15, 22],\n",
       "       [ 8, 17, 27, 38]], dtype=int32)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.cumsum(axis=1)  # cumulative sum on each row"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2]\n",
      "[1.         2.71828183 7.3890561 ]\n",
      "Sqrt [0.         1.         1.41421356]\n"
     ]
    }
   ],
   "source": [
    "#Universal Functions\n",
    "B = np.arange(3)\n",
    "print(B)\n",
    "print(np.exp(B))\n",
    "print(\"Sqrt\", np.sqrt(B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2. 0. 6.]\n"
     ]
    }
   ],
   "source": [
    "C = np.array([2., -1., 4.])\n",
    "print(np.add(B,C)) # temp = B + C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  0   1   8  27  64 125 216 343 512 729]\n"
     ]
    }
   ],
   "source": [
    "# Indexing, Slicing and Iterating\n",
    "import numpy as np\n",
    "a = np.arange(10)**3\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "[ 8 27 64]\n",
      "[ 0  8 64]\n"
     ]
    }
   ],
   "source": [
    "print(a[2])\n",
    "print(a[2:5])\n",
    "print(a[:6:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1000     1 -1000    27 -1000   125   216   343   512   729]\n"
     ]
    }
   ],
   "source": [
    "a[:6:2] = -1000\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  729   512   343   216   125 -1000    27 -1000     1 -1000]\n"
     ]
    }
   ],
   "source": [
    "print(a[ : :-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nan\n",
      "1.0\n",
      "nan\n",
      "3.0\n",
      "nan\n",
      "4.999999999999999\n",
      "5.999999999999999\n",
      "6.999999999999999\n",
      "7.999999999999999\n",
      "8.999999999999998\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "e:\\python\\lib\\site-packages\\ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in power\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "    print(i**(1/3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [10 11 12 13]\n",
      " [20 21 22 23]\n",
      " [30 31 32 33]\n",
      " [40 41 42 43]]\n"
     ]
    }
   ],
   "source": [
    "# From functions\n",
    "def f(x,y):\n",
    "    return 10*x+y\n",
    "b = np.fromfunction(f,(5,4),dtype=int)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n",
      "[ 1 11 21 31 41]\n",
      "[[0 1 2 3]]\n",
      "[[10 11 12 13]\n",
      " [20 21 22 23]]\n"
     ]
    }
   ],
   "source": [
    "print(b[2,3])\n",
    "print(b[0:5, 1])\n",
    "print(b[: 1])\n",
    "print(b[1:3, : ])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The dots (...) represent as many colons as needed to produce a complete indexing tuple. For example, if x is an\n",
    "# array with 5 axes, then x[1,2,...] is equivalent to x[1,2,:,:,:],\n",
    "# x[...,3] to x[:,:,:,:,3] and x[4,...,5,:] to x[4,:,:,5,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[  0   1   2]\n",
      "  [ 10  12  13]]\n",
      "\n",
      " [[100 101 102]\n",
      "  [110 112 113]]]\n"
     ]
    }
   ],
   "source": [
    "c = np.array( [[[ 0, 1, 2], [ 10, 12, 13]], [[100,101,102], [110,112,113]]])\n",
    "c.shape\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[100 101 102]\n",
      " [110 112 113]]\n"
     ]
    }
   ],
   "source": [
    "print(c[1,...])  #equivalent to c[1,:,:] or c[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  2,  13],\n",
       "       [102, 113]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c[...,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3]\n",
      "[10 11 12 13]\n",
      "[20 21 22 23]\n",
      "[30 31 32 33]\n",
      "[40 41 42 43]\n"
     ]
    }
   ],
   "source": [
    "# Iterating over multidimensional arrays is done with respect to the first axis\n",
    "for row in b:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n",
      "30\n",
      "31\n",
      "32\n",
      "33\n",
      "40\n",
      "41\n",
      "42\n",
      "43\n"
     ]
    }
   ],
   "source": [
    "for element in b.flat:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4. 6. 7. 1.]\n",
      " [5. 1. 1. 3.]\n",
      " [7. 4. 7. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# Shape Manipulation\n",
    "a = np.floor(10*np.random.random((3,4)))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.59486824 0.51458559 0.60642782 0.39224903]\n",
      " [0.17848979 0.01096234 0.55642329 0.08095662]\n",
      " [0.58960643 0.66149849 0.64745966 0.59230634]]\n"
     ]
    }
   ],
   "source": [
    "a = np.random.random((3,4))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5.9486824  5.1458559  6.06427823 3.9224903 ]\n",
      " [1.78489794 0.10962341 5.56423294 0.80956623]\n",
      " [5.89606427 6.61498491 6.4745966  5.92306343]]\n"
     ]
    }
   ],
   "source": [
    "a =a*10\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5. 5. 6. 3.]\n",
      " [1. 0. 5. 0.]\n",
      " [5. 6. 6. 5.]]\n"
     ]
    }
   ],
   "source": [
    "b= np.floor(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 4)\n",
      "[5. 5. 6. 3. 1. 0. 5. 0. 5. 6. 6. 5.]\n"
     ]
    }
   ],
   "source": [
    "print(b.shape)\n",
    "print(b.ravel())  #flattened the matrix in to a vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12,)\n"
     ]
    }
   ],
   "source": [
    "print(b.ravel().shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5. 5.]\n",
      " [6. 3.]\n",
      " [1. 0.]\n",
      " [5. 0.]\n",
      " [5. 6.]\n",
      " [6. 5.]]\n"
     ]
    }
   ],
   "source": [
    "d = b.reshape(6,2)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5. 1. 5.]\n",
      " [5. 0. 6.]\n",
      " [6. 5. 6.]\n",
      " [3. 0. 5.]]\n",
      "[[5. 6. 1. 5. 5. 6.]\n",
      " [5. 3. 0. 0. 6. 5.]]\n"
     ]
    }
   ],
   "source": [
    "# Transpose\n",
    "print(b.T)\n",
    "print(d.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5. 5. 6. 3. 1. 0.]\n",
      " [5. 0. 5. 6. 6. 5.]]\n"
     ]
    }
   ],
   "source": [
    "# reshpes returns a modified copy\n",
    "# resize modifies the original one\n",
    "b.resize((2,6))\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5., 5., 6., 3.],\n",
       "       [1., 0., 5., 0.],\n",
       "       [5., 6., 6., 5.]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#If a dimension is given as -1 in a reshaping operation, the other dimensions are automatically calculated:\n",
    "# i like to convert it into 3 rows, the remaining columns will be calculated by the machine itself\n",
    "b.reshape(3,-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[8. 4.]\n",
      " [7. 8.]]\n",
      "[[3. 5.]\n",
      " [5. 1.]]\n",
      "[[8. 4.]\n",
      " [7. 8.]\n",
      " [3. 5.]\n",
      " [5. 1.]]\n",
      "[[8. 4. 3. 5.]\n",
      " [7. 8. 5. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# Stacking together different arrays\n",
    "# adding new axis to matrix\n",
    "import numpy as np\n",
    "\n",
    "a = np.floor(10*np.random.random((2,2)))\n",
    "b = np.floor(10*np.random.random((2,2)))\n",
    "print(a)\n",
    "print(b)\n",
    "print(np.vstack((a,b)))\n",
    "print(np.hstack((a,b)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8., 4., 3., 5.],\n",
       "       [7., 8., 5., 1.]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# column_stack stacks 1D arrays as columns into a 2D array\n",
    "np.column_stack((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4., 3.],\n",
       "       [2., 8.]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([4.,2.])\n",
    "b = np.array([3.,8.])\n",
    "np.column_stack((a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4. 2. 3. 8.]\n"
     ]
    }
   ],
   "source": [
    "print(np.hstack((a,b)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4. 2.]\n",
      " [3. 8.]]\n"
     ]
    }
   ],
   "source": [
    "print(np.vstack((a,b)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.],\n",
       "       [2.]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy import newaxis\n",
    "a[:,newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4., 3.],\n",
       "       [2., 8.]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.column_stack((a[:,newaxis],b[:,newaxis]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4., 3.],\n",
       "       [2., 8.]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack((a[:,newaxis],b[:,newaxis]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "row_stack is equivalent to vstack for any input arrays. In general, for arrays\n",
    "with more than two dimensions, hstack stacks along their second axes, vstack stacks along their first axes, and\n",
    "concatenate allows for an optional arguments giving the number of the axis along which the concatenation should\n",
    "happen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 0, 4])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# In complex cases, r_ and c_ are useful for creating arrays by stacking numbers along one axis\n",
    "np.r_[1:4,0,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix a\n",
      " [[4. 1. 4. 9. 2. 9. 5. 1. 8. 3. 7. 7.]\n",
      " [7. 8. 9. 8. 9. 0. 1. 6. 5. 7. 4. 0.]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[array([[4., 1., 4., 9.],\n",
       "        [7., 8., 9., 8.]]),\n",
       " array([[2., 9., 5., 1.],\n",
       "        [9., 0., 1., 6.]]),\n",
       " array([[8., 3., 7., 7.],\n",
       "        [5., 7., 4., 0.]])]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Splitting one array into several smaller ones\n",
    "a = np.floor(10*np.random.random((2,12)))\n",
    "print(\"Matrix a\\n\", a)\n",
    "np.hsplit(a,3) # Split a into 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[4., 1., 4.],\n",
       "        [7., 8., 9.]]),\n",
       " array([[9.],\n",
       "        [8.]]),\n",
       " array([[2., 9., 5., 1., 8., 3., 7., 7.],\n",
       "        [9., 0., 1., 6., 5., 7., 4., 0.]])]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hsplit(a,(3,4)) # Split a after the third and the fourth column"
   ]
  },
  {
   "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}