numpy/create_array_matrix.ipynb

{
 "metadata": {
  "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.9.1"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3",
   "language": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Create a Numpy array\n",
    "\n",
    "* Create an array or matrix from a list\n",
    "* Create an array or matrix filled with 0's\n",
    "* Create an array or matrix filled with 1's\n",
    "* Create an array or matrix with speed\n",
    "* Create an array with range\n",
    "* Create an array with linear space\n",
    "* Create an array or matrix with random generator\n",
    "    * random.random.default_rng()\n",
    "    * array of samples from N(3, 6.25)\n",
    "    * array or matrix of random integers [2, 10)\n",
    "\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "source": [
    "## Create an array or matrix from a list"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "metadata": {},
     "execution_count": 4
    }
   ],
   "source": [
    "np.array([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "metadata": {},
     "execution_count": 43
    }
   ],
   "source": [
    "np.array([[1, 2], [3, 4], [5, 6]])"
   ]
  },
  {
   "source": [
    "## Create an array or matrix filled with 0's"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([0., 0., 0.])"
      ]
     },
     "metadata": {},
     "execution_count": 8
    }
   ],
   "source": [
    "np.zeros(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "metadata": {},
     "execution_count": 37
    }
   ],
   "source": [
    "np.zeros((3, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[[0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.]]])"
      ]
     },
     "metadata": {},
     "execution_count": 41
    }
   ],
   "source": [
    "np.zeros((2, 2, 3))"
   ]
  },
  {
   "source": [
    "## Create an array or matrix filled with 1's"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1.])"
      ]
     },
     "metadata": {},
     "execution_count": 11
    }
   ],
   "source": [
    "np.ones(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "metadata": {},
     "execution_count": 13
    }
   ],
   "source": [
    "np.ones((2, 4))"
   ]
  },
  {
   "source": [
    "## Create an array or matrix with speed\n",
    "\n",
    "The function `empty` creates an array whose initial content is random and depends on the **state of the memory**. \n",
    "\n",
    "The reason to use `empty` over `zeros` (or something similar) is **speed** - just make sure to fill every element afterwards!"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[1.12176055e-311, 1.77863633e-322],\n",
       "       [0.00000000e+000, 0.00000000e+000],\n",
       "       [8.48798316e-313, 8.24777728e-071],\n",
       "       [1.77289997e+160, 5.33241712e-091],\n",
       "       [2.05998359e+184, 3.67145801e+228]])"
      ]
     },
     "metadata": {},
     "execution_count": 27
    }
   ],
   "source": [
    "np.empty((5, 2))"
   ]
  },
  {
   "source": [
    "## Create an array with range"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "metadata": {},
     "execution_count": 28
    }
   ],
   "source": [
    "np.arange(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([2, 5, 8])"
      ]
     },
     "metadata": {},
     "execution_count": 30
    }
   ],
   "source": [
    "np.arange(2, 10, 3)  # start, end, step"
   ]
  },
  {
   "source": [
    "## Create an array with linear space"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([ 5.        ,  7.36842105,  9.73684211, 12.10526316, 14.47368421,\n",
       "       16.84210526, 19.21052632, 21.57894737, 23.94736842, 26.31578947,\n",
       "       28.68421053, 31.05263158, 33.42105263, 35.78947368, 38.15789474,\n",
       "       40.52631579, 42.89473684, 45.26315789, 47.63157895, 50.        ])"
      ]
     },
     "metadata": {},
     "execution_count": 35
    }
   ],
   "source": [
    "np.linspace(5, 50, 20)  # start, end, num of elements"
   ]
  },
  {
   "source": [
    "## Create an array or matrix with random generator"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "### random.random.default_rng()\n",
    "\n",
    "https://numpy.org/doc/stable/reference/random/generator.html"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[0.77395605, 0.43887844, 0.85859792, 0.69736803],\n",
       "       [0.09417735, 0.97562235, 0.7611397 , 0.78606431]])"
      ]
     },
     "metadata": {},
     "execution_count": 69
    }
   ],
   "source": [
    "rng = np.random.default_rng(seed=42)\n",
    "rng.random((2, 4))"
   ]
  },
  {
   "source": [
    "### array of samples from N(3, 6.25)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[ 4.69728391,  3.16894767,  3.7227985 ,  4.57822056],\n",
       "       [-0.64288955,  2.20082196,  1.82406836,  1.40280538]])"
      ]
     },
     "metadata": {},
     "execution_count": 83
    }
   ],
   "source": [
    "# \n",
    "rng.normal(3, 2.5, size=(2, 4))             # same\n",
    "3 + 2.5 * rng.standard_normal(size=(2, 4))  # same"
   ]
  },
  {
   "source": [
    "### array or matrix of random integers from [2, 10)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "array([[3, 6],\n",
       "       [6, 8],\n",
       "       [9, 7],\n",
       "       [5, 5],\n",
       "       [5, 8],\n",
       "       [4, 3],\n",
       "       [4, 2],\n",
       "       [2, 2],\n",
       "       [8, 7],\n",
       "       [7, 5]], dtype=int64)"
      ]
     },
     "metadata": {},
     "execution_count": 89
    }
   ],
   "source": [
    "rng.integers(low=2, high=10, size=(10, 2))"
   ]
  }
 ]
}