1_Numpy_ndarray_object.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1) Getting started with Numpy\n",
    "\n",
    "1) Numpy arrays can be created in a number of ways. One of the simplest ways of creating arrays is using the np.array().\n",
    "\n",
    "2) We pass a list of lists to the array() function and those lists should be equal in length\n",
    "\n",
    "3) Each list in the list became a row in the array and the elements of these lists populated the columns of the resulting array\n",
    "\n",
    "4) As the level of nesting in the below cell is two, the resulting array is two-dimensional, so it can be indexed with a set of two integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [2 3 4]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.array(\n",
    "    [\n",
    "        [1,2,3],\n",
    "        [2,3,4]\n",
    "    ]\n",
    ")\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Calculate the dimensionality of array\n",
    "def get_dimensions(arr):\n",
    "    return arr.ndim\n",
    "\n",
    "print(get_dimensions(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# Get the shape of array\n",
    "def get_shape(arr):\n",
    "    return arr.shape\n",
    "\n",
    "print(get_shape(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## 2) Array indexing and slicing\n",
    "1) Indexing NumPy arrays is very similary to indexing lists or tuples\n",
    "\n",
    "Start with creating array that has 100 x 100 dimensions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8322376255169754\n",
      "[0.28827779 0.18333284 0.51602473 0.80540336 0.16620221 0.51675642\n",
      " 0.22875876 0.71806177 0.07373745 0.58014316 0.58102138 0.36944622\n",
      " 0.25830443 0.50036783 0.54033875 0.6320219  0.03377041 0.93208106\n",
      " 0.81645902 0.33362042 0.31832955 0.91093155 0.19793072 0.40271133\n",
      " 0.24947846 0.85744852 0.32409706 0.66470956 0.89553756 0.22849306\n",
      " 0.09312623 0.66495211 0.32982682 0.27266983 0.01650151 0.42332553\n",
      " 0.09928792 0.75442452 0.02506674 0.23124316 0.72534917 0.14728873\n",
      " 0.2351095  0.08517124 0.31662342 0.6574294  0.25648767 0.98764207\n",
      " 0.83544678 0.74728383 0.51616173 0.89539985 0.03904205 0.75025119\n",
      " 0.76082245 0.59570489 0.72814062 0.46289996 0.31242527 0.98984584\n",
      " 0.13295097 0.8399446  0.66001393 0.46608922 0.13469832 0.65816456\n",
      " 0.03834099 0.10098593 0.17988976 0.68043123 0.19539625 0.25339605\n",
      " 0.53455816 0.68084495 0.27495861 0.46547353 0.74071541 0.28188631\n",
      " 0.31367541 0.31474896 0.9670067  0.15858175 0.22502195 0.57030446\n",
      " 0.61630769 0.87946337 0.14255022 0.19620254 0.66575874 0.84440482\n",
      " 0.18280746 0.99883772 0.93831617 0.44170998 0.66698447 0.24827582\n",
      " 0.26766124 0.38210635 0.45126241 0.83796496]\n"
     ]
    }
   ],
   "source": [
    "x = np.random.random((100, 100))\n",
    "# Get value in the 42nd row and 87th column\n",
    "print(x[42, 87])\n",
    "\n",
    "# Print 5th row of the x matrix\n",
    "print(x[5, :])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3) Memory layout of ndarray\n",
    "Memory layout of numpy array object can be obtained by accesing the flags property of the object. The following shows the memory layout"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  C_CONTIGUOUS : True\n",
      "  F_CONTIGUOUS : False\n",
      "  OWNDATA : True\n",
      "  WRITEABLE : True\n",
      "  ALIGNED : True\n",
      "  WRITEBACKIFCOPY : False\n",
      "  UPDATEIFCOPY : False\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(x.flags)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The C_CONTIGUOUS field in the output indicates whether the array was a C-style array. This means that the indexing of this array is done like a C array. This is also called row-major indexing in the case of 2D arrays.\n",
    "\n",
    "Similarly, the F_CONTIGUOUS attribute indicates if the array is a Fortran-style array. Such an array is said to have column-major indexing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a C Array\n",
    "c_array = np.random.rand(10000, 10000)\n",
    "\n",
    "# Creating a Fortran Array\n",
    "f_array = np.asfortranarray(c_array)\n",
    "\n",
    "# Create functions to return sum of  elements in first row and first column respectively\n",
    "\n",
    "def sum_row(x):\n",
    "    '''\n",
    "    Given an array `x`, return the sum of its zeroth row\n",
    "    '''\n",
    "    return np.sum(x[0, :])\n",
    "\n",
    "def sum_col(x):\n",
    "    '''\n",
    "    Given an array `x`, return the sum of its zeroth column\n",
    "    '''\n",
    "    return np.sum(x[:, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20.7 µs ± 1.49 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "# Test the performance of sum functions using both C and Fortran arrays\n",
    "%timeit sum_row(c_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "276 µs ± 37.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit sum_row(f_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "299 µs ± 8.6 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit sum_col(c_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21.4 µs ± 827 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit sum_col(f_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4) Views and Copies\n",
    "There are two ways of accessing data by slicing and indexing. They are called copies and views.\n",
    "\n",
    "View is reference to the original array and so modifying a view modifies the original array. This is not true for copies.\n",
    "\n",
    "The `may_share_memory` function in NumPy can be used to determine if two arrays are copies or views of each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "# Create a random array\n",
    "x = np.random.rand(100, 10)\n",
    "\n",
    "# Extract first five rows of the array and assign them to variable y\n",
    "y = x[:5, :]\n",
    "\n",
    "# Check if x and y share memory\n",
    "np.may_share_memory(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# Modify the array y and see how it effects x. Set all elements of y to zero\n",
    "y[:] = 0\n",
    "print(x[:5, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "# Let us create a copy of x\n",
    "x = np.random.rand(100, 10)\n",
    "y = np.empty([5, 10])\n",
    "y[:] = x[:5, :]\n",
    "np.may_share_memory(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.92705145 0.0795733  0.10390091 0.86068226 0.5243067  0.6358185\n",
      "  0.30324646 0.71094334 0.96894352 0.67766897]\n",
      " [0.52613503 0.35204925 0.41229782 0.48706471 0.01065627 0.58868265\n",
      "  0.39864159 0.40269144 0.79038759 0.27420396]\n",
      " [0.40929584 0.40030423 0.97979546 0.26077878 0.51330602 0.82109734\n",
      "  0.33991895 0.35061904 0.25181099 0.28814262]\n",
      " [0.28380411 0.97879298 0.98537801 0.56715169 0.81851254 0.98989342\n",
      "  0.86653276 0.74442839 0.06866418 0.75511973]\n",
      " [0.03568511 0.07841995 0.74112896 0.08324871 0.73378934 0.37526977\n",
      "  0.00815115 0.81623386 0.14949728 0.57838414]]\n"
     ]
    }
   ],
   "source": [
    "# Alter y and check x\n",
    "y[:] = 0\n",
    "print(x[:5, :])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5) Creating arrays from lists\n",
    "The simplest way to create an array is using the array function. To create a valid array object, we can pass in a list as argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an np.array() with list as argument\n",
    "x = np.array([1, 2, 3])\n",
    "y = np.array(['hello', 'world'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# One handy ways to creating lists is to use range() function and use that as input to np.array() function\n",
    "x = range(5)\n",
    "y = np.array(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "# Numpy has a convenient function, called arange that combines the functionality of range and array functions\n",
    "x = np.arange(5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "(4, 3)\n",
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "# For multidimensional arrays, the input lists simply have to be nested as follows:\n",
    "x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\n",
    "print(x.ndim)\n",
    "print(x.shape)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6) Array data types\n",
    "The data type of a NumPy array can be found by simply checking the dtype attribute of the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n"
     ]
    }
   ],
   "source": [
    "\n",
    "x = np.random.random((10, 10))\n",
    "print(x.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "print(x.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('<U5')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "x = np.array(['hello', 'world'])\n",
    "x.dtype"
   ]
  },
  {
   "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.6"
  },
  "pycharm": {
   "stem_cell": {
    "cell_type": "raw",
    "metadata": {
     "collapsed": false
    },
    "source": [
     "{\n",
     " \"cells\": [\n",
     "  {\n",
     "   \"cell_type\": \"markdown\",\n",
     "   \"metadata\": {},\n",
     "   \"source\": [\n",
     "    \"### 1) Getting started with numpy.ndarray\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"markdown\",\n",
     "   \"metadata\": {},\n",
     "   \"source\": [\n",
     "    \"1) Numpy arrays can be created in a number of ways. One of the simplest ways of creating arrays is using the np.array().\\n\",\n",
     "    \"\\n\",\n",
     "    \"2) We pass a list of lists to the array() function and those lists should be equal in length\\n\",\n",
     "    \"\\n\",\n",
     "    \"3) Each list in the list became a row in the array and the elements of these lists populated the columns of the resulting array\\n\",\n",
     "    \"\\n\",\n",
     "    \"4) As the level of nesting in the below cell is two, the resulting array is two-dimensional, so it can be indexed with a set of two integers\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 2,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"[[1 2 3]\\n\",\n",
     "      \" [2 3 4]]\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"import numpy as np\\n\",\n",
     "    \"x = np.array(\\n\",\n",
     "    \"    [\\n\",\n",
     "    \"        [1,2,3],\\n\",\n",
     "    \"        [2,3,4]\\n\",\n",
     "    \"    ]\\n\",\n",
     "    \")\\n\",\n",
     "    \"print(x)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 3,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"2\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"# Calculate the dimensionality of array\\n\",\n",
     "    \"def get_dimensions(arr):\\n\",\n",
     "    \"    return arr.ndim\\n\",\n",
     "    \"\\n\",\n",
     "    \"print(get_dimensions(x))\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 4,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"(2, 3)\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"# Get the shape of array\\n\",\n",
     "    \"def get_shape(arr):\\n\",\n",
     "    \"    return arr.shape\\n\",\n",
     "    \"\\n\",\n",
     "    \"print(get_shape(x))\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"markdown\",\n",
     "   \"metadata\": {},\n",
     "   \"source\": [\n",
     "    \"## 2) Array indexing and slicing\\n\",\n",
     "    \"1) Indexing NumPy arrays is very similary to indexing lists or tuples\\n\",\n",
     "    \"\\n\",\n",
     "    \"Start with creating array that has 100 x 100 dimensions:\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 6,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"0.3745335516612841\\n\",\n",
     "      \"[0.43740983 0.97221473 0.01452344 0.04714688 0.94273948 0.18348423\\n\",\n",
     "      \" 0.54958469 0.68154161 0.66528339 0.1976383  0.75435296 0.22832715\\n\",\n",
     "      \" 0.26787832 0.93241043 0.17833415 0.64933906 0.88894908 0.19621437\\n\",\n",
     "      \" 0.21795383 0.88106555 0.23107744 0.66680006 0.45201097 0.37727069\\n\",\n",
     "      \" 0.16740771 0.85307458 0.71681073 0.58097453 0.05860926 0.55157005\\n\",\n",
     "      \" 0.56138582 0.92590277 0.58755967 0.13090143 0.35940495 0.26045211\\n\",\n",
     "      \" 0.74142737 0.10519329 0.79928532 0.53112935 0.17019278 0.57267396\\n\",\n",
     "      \" 0.15441372 0.42863051 0.82427501 0.58192151 0.05062063 0.14961436\\n\",\n",
     "      \" 0.30278089 0.77556729 0.21150188 0.20439679 0.04859488 0.33971912\\n\",\n",
     "      \" 0.40631484 0.44915634 0.03041676 0.75056786 0.33140129 0.91380127\\n\",\n",
     "      \" 0.56679452 0.68370811 0.29337007 0.15707279 0.77436457 0.77050329\\n\",\n",
     "      \" 0.15728712 0.62053567 0.40016535 0.21476397 0.77530159 0.5163474\\n\",\n",
     "      \" 0.41017993 0.88732344 0.33249109 0.48337839 0.58177264 0.2517689\\n\",\n",
     "      \" 0.08898645 0.13790542 0.09649146 0.32280825 0.02607826 0.50059876\\n\",\n",
     "      \" 0.96599629 0.72988816 0.39896601 0.54662509 0.8504105  0.23099016\\n\",\n",
     "      \" 0.19063925 0.7684927  0.0455543  0.33086901 0.56045558 0.43413231\\n\",\n",
     "      \" 0.17156721 0.56122981 0.44922981 0.75838068]\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"x = np.random.random((100, 100))\\n\",\n",
     "    \"# Get value in the 42nd row and 87th column\\n\",\n",
     "    \"print(x[42, 87])\\n\",\n",
     "    \"\\n\",\n",
     "    \"# Print 5th row of the x matrix\\n\",\n",
     "    \"print(x[5, :])\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"attachments\": {\n",
     "    \"image.png\": {\n",
     "     \"image/png\": \"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\"\n",
     "    }\n",
     "   },\n",
     "   \"cell_type\": \"markdown\",\n",
     "   \"metadata\": {},\n",
     "   \"source\": [\n",
     "    \"Here is a very concise overview of different slicing and indexing techniques:\\n\",\n",
     "    \"![image.png](attachment:image.png)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"markdown\",\n",
     "   \"metadata\": {},\n",
     "   \"source\": [\n",
     "    \"## 3) Memory layout of ndarray\\n\",\n",
     "    \"Memory layout of numpy array object can be obtained by accesing the flags property of the object.\\n\",\n",
     "    \"The following shows the memory layout\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 7,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"  C_CONTIGUOUS : True\\n\",\n",
     "      \"  F_CONTIGUOUS : False\\n\",\n",
     "      \"  OWNDATA : True\\n\",\n",
     "      \"  WRITEABLE : True\\n\",\n",
     "      \"  ALIGNED : True\\n\",\n",
     "      \"  WRITEBACKIFCOPY : False\\n\",\n",
     "      \"  UPDATEIFCOPY : False\\n\",\n",
     "      \"\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"print(x.flags)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"markdown\",\n",
     "   \"metadata\": {},\n",
     "   \"source\": [\n",
     "    \"The C_CONTIGUOUS field in the output indicates whether the array was a  C-style array. This means that the indexing of this array is done like a C array. This is also called row-major indexing in the case of 2D arrays.\\n\",\n",
     "    \"\\n\",\n",
     "    \"Similarly, the F_CONTIGUOUS attribute indicates if the array is a Fortran-style array. Such an array is said to have column-major indexing. \"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 8,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [],\n",
     "   \"source\": [\n",
     "    \"# Creating a C Array\\n\",\n",
     "    \"c_array = np.random.rand(10000, 10000)\\n\",\n",
     "    \"\\n\",\n",
     "    \"# Creating a Fortran Array\\n\",\n",
     "    \"f_array = np.asfortranarray(c_array)\\n\",\n",
     "    \"\\n\",\n",
     "    \"# Create functions to return sum of  elements in first row and first column respectively\\n\",\n",
     "    \"\\n\",\n",
     "    \"def sum_row(x):\\n\",\n",
     "    \"    '''\\n\",\n",
     "    \"    Given an array `x`, return the sum of its zeroth row\\n\",\n",
     "    \"    '''\\n\",\n",
     "    \"    return np.sum(x[0, :])\\n\",\n",
     "    \"\\n\",\n",
     "    \"def sum_col(x):\\n\",\n",
     "    \"    '''\\n\",\n",
     "    \"    Given an array `x`, return the sum of its zeroth column\\n\",\n",
     "    \"    '''\\n\",\n",
     "    \"    return np.sum(x[:, 0])\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 9,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"9.58 µs ± 457 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"# Test the performance of sum functions using both C and Fortran arrays\\n\",\n",
     "    \"%timeit sum_row(c_array)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 10,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"133 µs ± 1.85 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"%timeit sum_row(f_array)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 11,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"134 µs ± 1.5 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"%timeit sum_col(c_array)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 12,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"8.99 µs ± 72 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"%timeit sum_col(f_array)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"markdown\",\n",
     "   \"metadata\": {},\n",
     "   \"source\": [\n",
     "    \"## 4) Views and Copies\\n\",\n",
     "    \"There are two ways of accessing data by slicing and indexing. They are called copies and views.\\n\",\n",
     "    \"\\n\",\n",
     "    \"View is reference to the original array and so modifying a view modifies the original array. This is not true for copies.\\n\",\n",
     "    \"\\n\",\n",
     "    \"The `may_share_memory` function in NumPy can be used to determine if two arrays are copies or views of each other.\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 13,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"data\": {\n",
     "      \"text/plain\": [\n",
     "       \"True\"\n",
     "      ]\n",
     "     },\n",
     "     \"execution_count\": 13,\n",
     "     \"metadata\": {},\n",
     "     \"output_type\": \"execute_result\"\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"# Create a random array\\n\",\n",
     "    \"x = np.random.rand(100, 10)\\n\",\n",
     "    \"\\n\",\n",
     "    \"# Extract first five rows of the array and assign them to variable y\\n\",\n",
     "    \"y = x[:5, :]\\n\",\n",
     "    \"\\n\",\n",
     "    \"# Check if x and y share memory\\n\",\n",
     "    \"np.may_share_memory(x, y)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 15,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\\n\",\n",
     "      \" [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\\n\",\n",
     "      \" [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\\n\",\n",
     "      \" [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\\n\",\n",
     "      \" [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"# Modify the array y and see how it effects x. Set all elements of y to zero\\n\",\n",
     "    \"y[:] = 0\\n\",\n",
     "    \"print(x[:5, :])\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 16,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"data\": {\n",
     "      \"text/plain\": [\n",
     "       \"False\"\n",
     "      ]\n",
     "     },\n",
     "     \"execution_count\": 16,\n",
     "     \"metadata\": {},\n",
     "     \"output_type\": \"execute_result\"\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"# Let us create a copy of x\\n\",\n",
     "    \"x = np.random.rand(100, 10)\\n\",\n",
     "    \"y = np.empty([5, 10])\\n\",\n",
     "    \"y[:] = x[:5, :]\\n\",\n",
     "    \"np.may_share_memory(x, y)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 17,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"[[0.32829958 0.99924937 0.52174069 0.21695196 0.33283674 0.95640919\\n\",\n",
     "      \"  0.73903541 0.3226267  0.68308868 0.23589071]\\n\",\n",
     "      \" [0.53505263 0.30747688 0.81136594 0.20104909 0.03635514 0.07754055\\n\",\n",
     "      \"  0.35930922 0.06441659 0.29379091 0.14753942]\\n\",\n",
     "      \" [0.98873846 0.61656157 0.39572951 0.97063685 0.88276459 0.38521613\\n\",\n",
     "      \"  0.114758   0.88493903 0.43190089 0.72660016]\\n\",\n",
     "      \" [0.87248442 0.23600899 0.73182046 0.58209333 0.93169495 0.15424073\\n\",\n",
     "      \"  0.73650922 0.43750521 0.22566365 0.22465965]\\n\",\n",
     "      \" [0.25802568 0.61098484 0.44928538 0.0225477  0.81161105 0.60908349\\n\",\n",
     "      \"  0.246493   0.13867082 0.49225145 0.5609964 ]]\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"# Alter y and check x\\n\",\n",
     "    \"y[:] = 0\\n\",\n",
     "    \"print(x[:5, :])\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"markdown\",\n",
     "   \"metadata\": {},\n",
     "   \"source\": [\n",
     "    \"## 5) Creating arrays from lists\\n\",\n",
     "    \"The simplest way to create an array is using the array function. To create a valid array object, we can pass in a list as argument.\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 18,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [],\n",
     "   \"source\": [\n",
     "    \"# Create an np.array() with list as argument\\n\",\n",
     "    \"x = np.array([1, 2, 3])\\n\",\n",
     "    \"y = np.array(['hello', 'world'])\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 19,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"[0 1 2 3 4]\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"# One handy ways to creating lists is to use range() function and use that as input to np.array() function\\n\",\n",
     "    \"x = range(5)\\n\",\n",
     "    \"y = np.array(x)\\n\",\n",
     "    \"print(y)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 20,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"[0 1 2 3 4]\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"# Numpy has a convenient function, called arange that combines the functionality of range and array functions\\n\",\n",
     "    \"x = np.arange(5)\\n\",\n",
     "    \"print(x)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 22,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"2\\n\",\n",
     "      \"(4, 3)\\n\",\n",
     "      \"[[ 1  2  3]\\n\",\n",
     "      \" [ 4  5  6]\\n\",\n",
     "      \" [ 7  8  9]\\n\",\n",
     "      \" [10 11 12]]\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"# For multidimensional arrays, the input lists simply have to be nested as follows:\\n\",\n",
     "    \"x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\\n\",\n",
     "    \"print(x.ndim)\\n\",\n",
     "    \"print(x.shape)\\n\",\n",
     "    \"print(x)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"markdown\",\n",
     "   \"metadata\": {},\n",
     "   \"source\": [\n",
     "    \"## 6) Array data types\\n\",\n",
     "    \"The data type of a NumPy array can be found by simply checking the dtype attribute of the array.\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 23,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"float64\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"x = np.random.random((10, 10))\\n\",\n",
     "    \"print(x.dtype)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 24,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"name\": \"stdout\",\n",
     "     \"output_type\": \"stream\",\n",
     "     \"text\": [\n",
     "      \"int32\\n\"\n",
     "     ]\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"x = np.arange(10)\\n\",\n",
     "    \"print(x.dtype)\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": 26,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [\n",
     "    {\n",
     "     \"data\": {\n",
     "      \"text/plain\": [\n",
     "       \"dtype('<U5')\"\n",
     "      ]\n",
     "     },\n",
     "     \"execution_count\": 26,\n",
     "     \"metadata\": {},\n",
     "     \"output_type\": \"execute_result\"\n",
     "    }\n",
     "   ],\n",
     "   \"source\": [\n",
     "    \"x = np.array(['hello', 'world'])\\n\",\n",
     "    \"x.dtype\"\n",
     "   ]\n",
     "  },\n",
     "  {\n",
     "   \"cell_type\": \"code\",\n",
     "   \"execution_count\": null,\n",
     "   \"metadata\": {},\n",
     "   \"outputs\": [],\n",
     "   \"source\": []\n",
     "  }\n",
     " ],\n",
     " \"metadata\": {\n",
     "  \"kernelspec\": {\n",
     "   \"display_name\": \"Python 3\",\n",
     "   \"language\": \"python\",\n",
     "   \"name\": \"python3\"\n",
     "  },\n",
     "  \"language_info\": {\n",
     "   \"codemirror_mode\": {\n",
     "    \"name\": \"ipython\",\n",
     "    \"version\": 3\n",
     "   },\n",
     "   \"file_extension\": \".py\",\n",
     "   \"mimetype\": \"text/x-python\",\n",
     "   \"name\": \"python\",\n",
     "   \"nbconvert_exporter\": \"python\",\n",
     "   \"pygments_lexer\": \"ipython3\",\n",
     "   \"version\": \"3.6.8\"\n",
     "  }\n",
     " },\n",
     " \"nbformat\": 4,\n",
     " \"nbformat_minor\": 4\n",
     "}\n"
    ]
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}