pythonic-code-and-numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tips For Easier Python and NumPy Code\n",
    "\n",
    "## Pythonic Code\n",
    "\n",
    "It is possible to write Java-style and C-style code in Python, but it is usually much easier to write (and read!) Python-style code. Such code is called 'pythonic'.\n",
    "\n",
    "For example, if you wanted to sum up the squares of the numbers from 1 to 10, you *could* write it like this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "385"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 0\n",
    "i = 1\n",
    "\n",
    "while i <= 10:\n",
    "    s += i**2\n",
    "    i += 1\n",
    "    \n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It works perfectly well, but the while loop can be replaced with a simpler for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "385"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 0\n",
    "\n",
    "for i in range(1, 11):\n",
    "    s += i**2\n",
    "    \n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To decide which type of loop to use, the rules are:\n",
    "* `for` loops are used when the number of iterations is known,\n",
    "* `while` are used when the number of iterations isn't known.\n",
    "\n",
    "The loop can be entirely removed with a \"list comprehension\". Once we have a list of squares, the `sum` function will automatically add up the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 4, 9, 16, 25, 36, 49, 64, 81, 100], 385)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [i**2 for i in range(1, 11)]\n",
    "s = sum(squares)\n",
    "\n",
    "squares, s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a final simplifying step, we can eliminate the intermediate list by turning the list comprehension into a \"generator\" which is input directly into `sum`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "385"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = sum(i**2 for i in range(1, 11))\n",
    "\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I hope you agree that this easier to write and read (once you know what everything means).\n",
    "\n",
    "It's worth noting that Python doesn't even create the intermediate list with the last method! It generates (hence \"generator\") one value at a time and updates the sum. That doesn't matter in such a small example, but it can make a difference if your program has to work with lists of thousands or millions of values.\n",
    "\n",
    "## NumPy Arrays\n",
    "\n",
    "The core feature of NumPy is the array. Arrays differ from Python lists because an array has a fixed length, and usually contains only numbers. NumPy is filled with tools to make working with arrays easy. For example `linspace` creates an array of evenly spaced numbers between two points. For example, an array of 20 numbers from 0 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  0.55555556,  1.11111111,  1.66666667,  2.22222222,\n",
       "        2.77777778,  3.33333333,  3.88888889,  4.44444444,  5.        ])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = np.linspace(0, 5, 10)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You probably expected the array `[0. 0.5 1. 1.5 2. 2.5 3. 3.5 4. 4.5 5.]`. However, if you count that array you'll find it has 11 numbers in it, not 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5,  5. ])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.linspace(0, 5, 11)\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adding, subtracting, and multiplying arrays works much like with vectors in math."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0.,   1.,   2.,   3.,   4.,   5.,   6.,   7.,   8.,   9.,  10.])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 10. ,  11.5,  13. ,  14.5,  16. ,  17.5,  19. ,  20.5,  22. ,\n",
       "        23.5,  25. ])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.linspace(10, 20, 11)\n",
    "\n",
    "x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most NumPy functions work nicely on arrays. Applying a function to an array simply applies the function to each element of the array. For example, NumPy's `power` function computes a power of a number and applying it to a list computes the power of each element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0.  ,   0.25,   1.  ,   2.25,   4.  ,   6.25,   9.  ,  12.25,\n",
       "        16.  ,  20.25,  25.  ])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.power(x, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}