NumPy; Basics of ndarrays.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = np.array([1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5,)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "Y = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9],[10, 11, 12]])\n",
    "print(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 3)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello' 'World']\n"
     ]
    }
   ],
   "source": [
    "x = np.array(['Hello', 'World'])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "shape: (2,)\n",
      "type: <class 'numpy.ndarray'>\n",
      "dtype: <U5\n"
     ]
    }
   ],
   "source": [
    "print('shape:', x.shape)\n",
    "print('type:', type(x))\n",
    "print('dtype:', x.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1' '2' 'World']\n",
      "shape: (3,)\n",
      "type: <class 'numpy.ndarray'>\n",
      "dtype: <U11\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2, 'World']) #Numpy arrays must contain elements of only one type\n",
    "print(x)\n",
    "print('shape:', x.shape)\n",
    "print('type:', type(x))\n",
    "print('dtype:', x.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Upcasting: As all elements must be of the same type, numpy selects the most restrictive**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.  2.5 4. ] float64\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2.5, 4]) \n",
    "print(x, x.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Specifiying explicitly the type of the numpy array:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 7]\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2.5, 7], dtype= np.int64)\n",
    "print(x)\n",
    "print('dtype:', x.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Saving arrays as files for later reuse:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([1, 2, 4, 5, 6])\n",
    "np.save('my_array', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "y = np.load('my_array.npy')\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Creating matrix filled with ones or zeroes**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 0 0]\n",
      " [0 0 0 0]\n",
      " [0 0 0 0]]\n",
      "int32\n"
     ]
    }
   ],
   "source": [
    "x = np.zeros((3, 4), dtype= int)\n",
    "print(x)\n",
    "print(x.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n",
      "float64\n"
     ]
    }
   ],
   "source": [
    "x = np.ones((3, 4))\n",
    "print(x)\n",
    "print(x.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3.14 3.14 3.14 3.14]\n",
      " [3.14 3.14 3.14 3.14]\n",
      " [3.14 3.14 3.14 3.14]]\n",
      "float64\n"
     ]
    }
   ],
   "source": [
    "x = np.full((3, 4), 3.14)\n",
    "print(x)\n",
    "print(x.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Working with matrix diagonals**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0. 0. 0.]\n",
      " [0. 1. 0. 0. 0.]\n",
      " [0. 0. 1. 0. 0.]\n",
      " [0. 0. 0. 1. 0.]\n",
      " [0. 0. 0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.eye(5)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10  0  0  0]\n",
      " [ 0 20  0  0]\n",
      " [ 0  0 30  0]\n",
      " [ 0  0  0 50]]\n"
     ]
    }
   ],
   "source": [
    "x = np.diag([10, 20, 30, 50])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The np.arange function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(10)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(4,10)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  4  7 10 13]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(1, 14, 3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The linspace function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.          2.77777778  5.55555556  8.33333333 11.11111111 13.88888889\n",
      " 16.66666667 19.44444444 22.22222222 25.        ]\n"
     ]
    }
   ],
   "source": [
    "#Create a 10 evenly spaced list of points from 0 to 25, including start and end points.\n",
    "x = np.linspace(0, 25, 10) \n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.   2.5  5.   7.5 10.  12.5 15.  17.5 20.  22.5]\n"
     ]
    }
   ],
   "source": [
    "#Create a 10 evenly spaced list of points from 0 to 25 not including the endpoint\n",
    "x = np.linspace(0, 25, 10, endpoint=False)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The reshape function**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(20)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "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",
      " [15 16 17 18 19]]\n"
     ]
    }
   ],
   "source": [
    "x = np.reshape(x, (4,5))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1]\n",
      " [ 2  3]\n",
      " [ 4  5]\n",
      " [ 6  7]\n",
      " [ 8  9]\n",
      " [10 11]\n",
      " [12 13]\n",
      " [14 15]\n",
      " [16 17]\n",
      " [18 19]]\n"
     ]
    }
   ],
   "source": [
    "x = np.reshape(x, (10,2))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Concatenating Numpy functions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4  5  6  7  8  9]\n",
      " [10 11 12 13 14 15 16 17 18 19]]\n"
     ]
    }
   ],
   "source": [
    "Y = np.arange(20).reshape(2,10)\n",
    "print(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.  5.]\n",
      " [10. 15.]\n",
      " [20. 25.]\n",
      " [30. 35.]\n",
      " [40. 45.]]\n"
     ]
    }
   ],
   "source": [
    "X = np.linspace(0, 50, 10, endpoint=False).reshape(5,2)\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Working with the random function***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.88142035 0.65001791 0.79430999]\n",
      " [0.50324941 0.30499364 0.14327731]\n",
      " [0.21164622 0.58801544 0.66977788]]\n"
     ]
    }
   ],
   "source": [
    "X = np.random.random((3,3))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4  4]\n",
      " [14 12]\n",
      " [ 9 11]]\n"
     ]
    }
   ],
   "source": [
    "X = np.random.randint(4, 15,(3,2))\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.20225583  0.06874325  0.02804736 ...  0.09628163 -0.03099073\n",
      "  -0.06435806]\n",
      " [ 0.04120436  0.1253146   0.04219623 ... -0.06364922  0.09706397\n",
      "   0.06402995]\n",
      " [-0.07692276  0.10750924  0.2777837  ...  0.05773654 -0.00223061\n",
      "   0.02390317]\n",
      " ...\n",
      " [-0.03611866  0.13414393 -0.07636551 ...  0.16167191 -0.17493731\n",
      "  -0.07197934]\n",
      " [-0.02603448 -0.19511226 -0.10865406 ... -0.03143301 -0.07604886\n",
      "   0.006139  ]\n",
      " [ 0.12369496  0.19881138  0.01653122 ... -0.07013893  0.11952909\n",
      "   0.03659229]]\n"
     ]
    }
   ],
   "source": [
    "X = np.random.normal(0, 0.1, size= (1000,1000))\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.linespace("
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [default]",
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}