2_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy Basics\n",
    "__[NumPy](http://www.numpy.org/)__ is probably the most used package for scientific computing with Python.\n",
    "\n",
    "## The main entity\n",
    "\n",
    "NumPy’s main object is the homogeneous multidimensional array. It is a table of elements (usually numbers), all of the same type, indexed by a tuple of positive integers. In NumPy dimensions are called axes. NumPy’s array class is called `ndarray`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "myNumpyArray = np.array([[1, 1, 2],\n",
    "                         [3, 5, 8]])\n",
    "\n",
    "print(\"the numpy array: \", myNumpyArray)\n",
    "\n",
    "print(\"the shape (similar to matlab's size): \", myNumpyArray.shape)\n",
    "\n",
    "print(\"the number of dimensions: \", myNumpyArray.ndim)\n",
    "\n",
    "print(\"the number of elements: \", myNumpyArray.size)\n",
    "\n",
    "print(\"the type of the elements: \", myNumpyArray.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Array Creation\n",
    "NumPy provides handy functions to initialize arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# zeros\n",
    "zeros = np.zeros((2, 3))\n",
    "print(\"zeros: \", zeros)\n",
    "\n",
    "# ones\n",
    "ones = np.ones((3, 2))\n",
    "print(\"ones: \", ones)\n",
    "\n",
    "# arange\n",
    "arange = np.arange(1, 10, 2)\n",
    "print(\"arange: \", arange)\n",
    "\n",
    "# linspace\n",
    "linspace = np.linspace(1, 10, 3)\n",
    "print(\"linspace: \", linspace)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operations\n",
    "In NumPy all operations on `ndarray` are element-wise operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([[1, 2],\n",
    "              [3, 4]])\n",
    "\n",
    "b = np.array([[5, 6],\n",
    "              [7, 8]])\n",
    "\n",
    "# addition\n",
    "print(\"a + b: \", a + b)\n",
    "\n",
    "# substraction\n",
    "print(\"a - b: \", a - b)\n",
    "\n",
    "# multiplication\n",
    "print(\"a * b: \", a * b)\n",
    "\n",
    "# division\n",
    "print(\"a / b: \", a / b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for matrix multiplication one needs to use **.dot**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# matrix multiplication\n",
    "print(\"a.dot(b): \", a.dot(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mathematical Operations\n",
    "NumPy provides implementations for the operations we commonly use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.arange(1, 5)\n",
    "b = np.arange(-2, 3)\n",
    "\n",
    "# exponentiation\n",
    "print(\"a**2: \", a**2)\n",
    "print(\"np.exp(a): \", np.exp(a))\n",
    "\n",
    "# square root\n",
    "print(\"np.sqrt(a): \", np.sqrt(a))\n",
    "\n",
    "# positive part\n",
    "print(\"positive part of b: \", b.clip(0, np.inf))\n",
    "\n",
    "# negative part\n",
    "print(\"negative part of b: \", b.clip(-np.inf, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reduction Operations\n",
    "NumPy also provides implementations for the usual reduction operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.arange(1, 5)\n",
    "\n",
    "# sum\n",
    "print(\"sum: \", a.sum())\n",
    "print(\"sum: \", np.sum(a))\n",
    "\n",
    "# mean\n",
    "print(\"mean: \", a.mean())\n",
    "print(\"mean: \", np.mean(a))\n",
    "\n",
    "# standard deviation\n",
    "print(\"standard deviation: \", a.std())\n",
    "print(\"standard deviation: \", np.std(a))\n",
    "\n",
    "# max/min\n",
    "print(\"max: \", a.max())\n",
    "print(\"min: \", np.min(a))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shape Manipulation Operations\n",
    "NumPy provides as well handy operations to play with the shape of an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.array([[1, 2, 3],\n",
    "              [4, 5, 6]])\n",
    "\n",
    "# transpose\n",
    "print(\"a transposed: \", a.T)\n",
    "print(\"a transposed shape: \", a.T.shape)\n",
    "\n",
    "# flatten\n",
    "print(\"a flattened: \", a.ravel())\n",
    "\n",
    "# reshape\n",
    "print(\"a reshaped to (3,2): \", a.reshape(3,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Number Generator\n",
    "NumPy offers different functions for random sampling in its **random** module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# uniform in [0,1)\n",
    "print(\"uniform in [0,1]: \", np.random.rand(2,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# standard normal\n",
    "print(\"standard normal: \", np.random.randn(2,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# discrete uniform\n",
    "print(\"discrete uniform: \", np.random.randint(-1, 5, (2,1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It provides as well sampling from many of the usual distributions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "# binomial\n",
    "print(\"binomial: \", np.random.binomial(2, 0.5))\n",
    "\n",
    "# exponential\n",
    "lambda_parameter = 2\n",
    "print(\"exponential: \", np.random.exponential(1/lambda_parameter))\n",
    "\n",
    "# poisson\n",
    "print(\"poisson: \", np.random.poisson(lambda_parameter))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other Resources\n",
    "* __[NumPy Reference Guide](https://docs.scipy.org/doc/numpy/reference/index.html)__\n",
    "* __[SciPy Reference Guide](https://docs.scipy.org/doc/scipy/reference/)__. It's an open source library, from the same ecosystem as NumPy, that contains more advanced algorithms. For example it provides routines for numerical integration and optimization."
   ]
  },
  {
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}