12. Tricks and Tips.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we give a list of short and useful tips."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### “Automatic” Reshaping\n",
    "To change the dimensions of an array, you can omit one of the sizes which will then be deduced automatically:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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 20 21 22 23\n",
      " 24 25 26 27 28 29] Arange funcation\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2],\n",
       "        [ 3,  4,  5],\n",
       "        [ 6,  7,  8],\n",
       "        [ 9, 10, 11],\n",
       "        [12, 13, 14]],\n",
       "\n",
       "       [[15, 16, 17],\n",
       "        [18, 19, 20],\n",
       "        [21, 22, 23],\n",
       "        [24, 25, 26],\n",
       "        [27, 28, 29]]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(30)\n",
    "print(a,\"Arange funcation\")\n",
    "a.shape = 2,-1,3  # -1 means \"whatever is needed\"\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2],\n",
       "        [ 3,  4,  5],\n",
       "        [ 6,  7,  8],\n",
       "        [ 9, 10, 11],\n",
       "        [12, 13, 14]],\n",
       "\n",
       "       [[15, 16, 17],\n",
       "        [18, 19, 20],\n",
       "        [21, 22, 23],\n",
       "        [24, 25, 26],\n",
       "        [27, 28, 29]]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape = 2,5,3\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 5, 3)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vector Stacking\n",
    "How do we construct a 2D array from a list of equally-sized row vectors? In MATLAB this is quite easy: if x and y are two vectors of the same length you only need do m=[x;y]. In NumPy this works via the functions column_stack, dstack, hstack and vstack, depending on the dimension in which the stacking is to be done. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 2 4 6 8] \n",
      " [0 1 2 3 4] \n",
      " [[0 2 4 6 8]\n",
      " [0 1 2 3 4]] \n",
      " [0 2 4 6 8 0 1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "x = np.arange(0,10,2)                     # x=([0,2,4,6,8])\n",
    "y = np.arange(5)                          # y=([0,1,2,3,4])\n",
    "m = np.vstack([x,y])                      # m=([[0,2,4,6,8],\n",
    "                                          #     [0,1,2,3,4]])\n",
    "xy = np.hstack([x,y])                     # xy =([0,2,4,6,8,0,1,2,3,4])\n",
    "print(x,\"\\n\",y,\"\\n\",m,\"\\n\",xy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The logic behind those functions in more than two dimensions can be strange."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Histograms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The NumPy histogram function applied to an array returns a pair of vectors: the histogram of the array and the vector of bins. Beware: matplotlib also has a function to build histograms (called hist, as in Matlab) that differs from the one in NumPy. The main difference is that pylab.hist plots the histogram automatically, while numpy.histogram only generates the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Build a vector of 10000 normal deviates with variance 0.5^2 and mean 2\n",
    "mu, sigma = 2, 0.5\n",
    "v = np.random.normal(mu,sigma,10000)\n",
    "\n",
    "\n",
    "# Plot a normalized histogram with 50 bins\n",
    "plt.hist(v, bins=1000, density=2)       # matplotlib version (plot)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compute the histogram with numpy and then plot it\n",
    "(n, bins) = np.histogram(v, bins=50, density=True)  # NumPy version (no plot)\n",
    "plt.plot(.5*(bins[1:]+bins[:-1]), n)\n",
    "plt.show()"
   ]
  },
  {
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}