index.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Introduction to Python\n",
    "\n",
    "## LxMLS 2019\n",
    "\n",
    "\n",
    "<div style=\"float:right\">\n",
    "Ramón Fernández Astudillo<br />\n",
    "IBM Research AI<br />\n",
    "ramon.astudillo@ibm.com<br />\n",
    "<br />\n",
    "Credit to: Luis Pedro Coelho   \n",
    "</div>\n",
    "\n",
    "![IBM](./ibm.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Interactive Notebooks Online\n",
    "\n",
    "- Click on the `launch binder` tag here: https://github.com/LxMLS/talk-python-intro\n",
    "- This will spin-up a machine with this notebook and code installed (will take some min)\n",
    "- you can play with it online with no need to install anything\n",
    "- you can also install it locally (no need for `rise`)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Python Language History\n",
    "\n",
    "- Python was started in the late 80's by Guido van Rossum\n",
    "- It was intended to be both _easy to teach_ and _industrial strength_.\n",
    "- It has become one of the most widely used languages (rank 3 TIOBE index).\n",
    "- Moderate execution speed, fast development speed (and fast teamwork!)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Python Language History\n",
    "\n",
    "- Two main versions `Python2` (2000) and `Python3` (2008) \n",
    "- Use `Python3`!, `Python2` is not supported any more after 2020\n",
    "- Ideal version to work with the labs is `3.6`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Working with the LxMLS Labs\n",
    "\n",
    "- Follow the guide install instructions http://lxmls.it.pt/2019/LxMLS_guide_2019.pdf\n",
    "- `Anaconda` if you are relatively new to Python\n",
    "- I like to use `virtualenv` and `pip`\n",
    "- Need to change Python version, no admin? I like `pyenv`\n",
    "- Consult the monitors!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Python(3) Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# More complicated example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [10, 7, 22, 14, 17]\n",
    "\n",
    "total = 0.0\n",
    "n = 0.0\n",
    "for val in numbers:\n",
    "    total = total + val\n",
    "    n = n + 1\n",
    "print(total / n)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "\"Python is executable pseudo-code.\"\n",
    "\n",
    "        —Python lore (often attributed to Bruce Eckel)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Using the Jupyter notebook\n",
    "\n",
    "Cells of code & text.\n",
    "\n",
    "There is a **single context** and it changes _as you execute cells_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you really get confused, restart everything (school notebooks have auto-restart)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python types\n",
    "\n",
    "## Basic types\n",
    "\n",
    "- Numbers (integers and floating point)\n",
    "- Strings\n",
    "- Lists and tuples\n",
    "- Dictionaries and sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Python Types\n",
    "## Numbers I: Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "c = 3\n",
    "a + b * c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Python Types\n",
    "## Numbers II: Floats\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1.2\n",
    "b = 2.4\n",
    "c = 3.6\n",
    "\n",
    "a + b *c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Python Types\n",
    "## Numbers III: Mixing Integers & Floats\n",
    "\n",
    "When you mix, it all gets converted to floats:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "a = 2\n",
    "b = 2.5\n",
    "c = 4.4\n",
    "\n",
    "a + b*c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Python Types\n",
    "\n",
    "## Numbers IV: Operations\n",
    "\n",
    "- Addition: `a + b`\n",
    "- Subtraction: `a - b`\n",
    "- Multiplication: `a * b`\n",
    "- Exponentiation: `a ** b`\n",
    "- Unary Minus: `-a`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about division?\n",
    "\n",
    "What is 9 divided by 3?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "What is 10 divided by 3?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Two types of division\n",
    "\n",
    "- integer division: `a // b`\n",
    "- floating point division: `a / b`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "b = 3\n",
    "\n",
    "print(a // b)\n",
    "print(a / float(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a / b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Python Types\n",
    "\n",
    "## Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first = 'John'\n",
    "last = \"Doe\"\n",
    "full = first + \" \" + last\n",
    "\n",
    "full"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## String rules\n",
    "\n",
    "- Short string literals are delimited by (`\"`) or (`'`).\n",
    "- Short string literals are one line only.\n",
    "- Special characters are input using escape sequences (`\\n` for newline,...).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Line 1\\nLine 2\\n\")\n",
    "print('Line 1\\nLine 2\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# String Formatting\n",
    "\n",
    "## New style\n",
    "\n",
    "We use a method called `format` to replace placeholders in a string. Placeholders are denoted by `{}`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Username {0}\".format('Guido'))\n",
    "print(\"Username {0} (last login: {1})\".format('Guido', 'yesterday'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "You can also leave the numbers out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Username {}\".format('Guido'))\n",
    "print(\"Username {} (last login: {})\".format('Guido', 'yesterday'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Old style Formatting\n",
    "\n",
    "You should not use this in new code, but you may still see it in old code: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Username %s\" % 'Guido')\n",
    "print(\"Username %s (last login: %s)\" % ('Guido', 'yesterday'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Python types: Long strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "long = '''Tell me, is love\n",
    "Still a popular suggestion\n",
    "Or merely an obsolete art?\n",
    "\n",
    "Forgive me, for asking,\n",
    "This simple question,\n",
    "I am unfamiliar with his heart.'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(long)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Lists\n",
    "\n",
    "A python list is written with square brackets and commas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = [1, 2, 5, 10]\n",
    "\n",
    "print(values[0]) # <- first element\n",
    "print(values[1]) # <- second element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(values[-1])\n",
    "print(len(values))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# List methods\n",
    "\n",
    "We call a method with the `<object>.<method>()` syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = [\"Pineapple\", \"Banana\", \"Apple\"]\n",
    "fruits.sort()\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits.append(\"Orange\")\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Aside: getting help\n",
    "\n",
    "Add a `?` at the end of an object to get help inside the notebook:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fruits.sort? <-- SHOULD WORK   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Python lists can contain mixed types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits.append(123)\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "even other lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1,2,3]\n",
    "fruits.append(numbers)\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "emails = {\n",
    "    'Luis' : 'luis@luispedro.org',\n",
    "    'Rita' : 'rita@gmail.com',\n",
    "}\n",
    "\n",
    "print(\"Luis' email is {}\".format(emails['Luis']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "emails['Petra'] = 'petra@gmail.com' # <- add a new element\n",
    "emails['Luis'] = 'coelho@embl.de' # <- replace an element\n",
    "\n",
    "print(emails)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(emails)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# None type\n",
    "\n",
    "There is something called `None`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's like a null pointer."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python Control Structures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MIN_GRADE = 0.5\n",
    "student = \"Rita\"\n",
    "grade = 0.7\n",
    "\n",
    "if grade > MIN_GRADE:\n",
    "    print(\"{} passed\".format(student))\n",
    "    print(\"Congratulations\")\n",
    "else:\n",
    "    print(\"{} needs to take the test again\".format(student))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Blocks are defined by indentation\n",
    "\n",
    "Unlike almost all other modern programming languages, Python uses **indentation** to delimit blocks!\n",
    "\n",
    "(This is sometimes called the [off-side rule](https://en.wikipedia.org/wiki/Off-side_rule)).\n",
    "\n",
    "- you can use any number of spaces, but you should use **4 spaces**.\n",
    "- you can use TABs, but please don't (remap `tab` to 4 spaces)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    if <condition>:\n",
    "        <statement 1>\n",
    "        <statement 2>\n",
    "        <statement 3>\n",
    "    <statement after the if>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Conditions\n",
    "\n",
    "\n",
    "- `a == b`\n",
    "- `a != b`\n",
    "- `a < b`\n",
    "- `a > b`\n",
    "- `a >= b`\n",
    "- `a in lst`\n",
    "- `a not in lst`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Else clause and friends\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2\n",
    "if a > 3:\n",
    "    print(\"Greater than 3\")\n",
    "elif a > 2:\n",
    "    print(\"Greater than 2\")\n",
    "elif a > 1:\n",
    "    print(\"Greater than 1\")\n",
    "else:\n",
    "    print(\"Kind of small\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Loops\n",
    "\n",
    "## for loop\n",
    "\n",
    "In Python, the `for` loop is over a \"sequence\":\n",
    "\n",
    "    for <name> in <sequence>:\n",
    "        <block>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "students = ['Luis', \"Ece\", \"Rita\"]\n",
    "\n",
    "for st in students:\n",
    "    print(st)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Loops\n",
    "\n",
    "## for loop\n",
    "\n",
    "We can also loop over dictionaries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "for n in emails:\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# while loop\n",
    "\n",
    "By now, you can probably guess the syntax:\n",
    "\n",
    "    while <condition>:\n",
    "        <block>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# poor man's division\n",
    "a = 2325250\n",
    "b = 23\n",
    "\n",
    "c = a\n",
    "i = 0\n",
    "while c > b:\n",
    "    c -= b\n",
    "    i += 1\n",
    "    \n",
    "print(\"{} // {} = {}\".format(a, b, i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# More loopy stuff\n",
    "\n",
    "In many other languages, for loops are over integers (0, 1, 2, ... , N). How can we achieve the same in Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "range(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(i**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Conditions\n",
    "\n",
    "We have seen comparisons already (e.g., `a < b`), they return booleans (either `True` or `False`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 2\n",
    "print(a < b)\n",
    "print(a == b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use booleans as values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "condition = True\n",
    "if condition:\n",
    "    print(\"Yep\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Other Conditions\n",
    "\n",
    "- Many things can be evaluated as conditions\n",
    "  - lists (the empty list gets evaluated as `False`, otherwise `True`)\n",
    "  - dicts (same)\n",
    "  - strings (empty string evaluates to `False`, otherwise `True`)\n",
    "  - numbers (zero is `False`, else `True`)\n",
    "- Several other objects can be evaluated in conditions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if fruits:\n",
    "    print(\"Fruity\")\n",
    "else:\n",
    "    print(\"Nope\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Break and continue\n",
    "\n",
    "Like in other languages, in a loop `break` exits the loop and `continue` goes to the next iteration immediately:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 6, -13, -4, 2]\n",
    "\n",
    "total = 0\n",
    "n = 0.0\n",
    "\n",
    "for v in numbers:\n",
    "    if v < 0:\n",
    "        continue\n",
    "    total += v\n",
    "    n += 1\n",
    "total/n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def double(x):\n",
    "    '''\n",
    "    Returns the double of its argument\n",
    "    '''\n",
    "    return 2 * x\n",
    "\n",
    "double(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Is that a comment?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "It's a documentation string.\n",
    "\n",
    "Try `double?`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Calling a function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 4\n",
    "double(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "double(2.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "double(double(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Functions with default arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet(name, greeting=\"Hello\"):\n",
    "    print(\"{} {}\".format(greeting, name))\n",
    "    \n",
    "greet(\"Mario\")\n",
    "greet(\"Mario\", \"Goodbye\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also specify the argument names (and then the order does not matter):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greet(greeting=\"Howdy\", name=\"Mario\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is very helpful for functions with >10 arguments!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Breakpoint\n",
    "\n",
    "Questions up to this point?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# NUMPY\n",
    "\n",
    "Unlike R/MATLAB, Python relies on libraries for numerics.\n",
    "\n",
    "- No builtin types for numeric computation\n",
    "- However, packages like `numpy` are _quasi-standard_\n",
    "- compatible with `Pytorch`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Basic array array type\n",
    "\n",
    "`numpy.array`, which is a multi-dimensional array of numbers.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np # <- import a library, like include/require in other languages\n",
    "\n",
    "A = np.array([\n",
    "    [0,1,2],\n",
    "    [2,3,4],\n",
    "    [4,5,6],\n",
    "    [6,7,8]])\n",
    "print(A[0,0])\n",
    "print(A[0,1])\n",
    "print(A[1,0])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Why do we need numpy?\n",
    "\n",
    "Couldn't we just use lists?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([1,2,3])\n",
    "B = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. numpy arrays have extra numeric methods.\n",
    "2. efficiency\n",
    "3. expressiveness\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "You can also use numeric operations with arrays, they work **element-wise**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Operations with two arrays also work **element-wise**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.array([1,1,2])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A + B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A * B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Matrix/vector operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([\n",
    "            [1,0,1],\n",
    "            [0,2,0],\n",
    "            [0,0,1],\n",
    "        ])\n",
    "B = np.array([1,2,3])\n",
    "np.dot(A,B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Numpy arrays can be very efficient\n",
    "\n",
    "A list in Python is an array of pointers to objects:\n",
    "\n",
    "\n",
    "![python list](./python-list.svg)\n",
    "\n",
    "while a numpy array really does hold its data in memory:\n",
    "\n",
    "![numpy array](./numpy-array.svg)\n",
    "\n",
    "Computers are **really good** at processing contiguous blocks of memory.\n",
    "\n",
    "These arrays can also be passed to other libraries (including those written in C or FORTRAN)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Timing measurements\n",
    "\n",
    "One simple example (using the magic command `%timeit`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = range(1024)\n",
    "%timeit sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.arange(1024)\n",
    "%timeit b.sum() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Actually, not that big of a difference, but the difference gets larger for larger arrays and more complex operations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a = range(1024*1024)\n",
    "%timeit sum(v*v for v in a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "b = np.arange(1024*1024)\n",
    "%timeit (b**2).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, it starts to matter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Numpy arrays are *homogeneous*\n",
    "\n",
    "- All members of an array have the same type\n",
    "- Either integer or floating pooint\n",
    "- Defined **when you first create the array**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([0, 1, 2]) # <- IMPLICIT TYPE\n",
    "A.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.array([0.5, 1.1, 2.1])\n",
    "B.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C = np.array([0, 1, 2], dtype=np.float64) # <- EXPLICIT TYPE\n",
    "C.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Besides the speed, it is also more expressive."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Numpy data types\n",
    "\n",
    "- `np.int8`, `np.int16`, `np.int32`, `np.int64`\n",
    "- `np.uint8`, `np.uint16`, `np.uint32`, `np.uint64`\n",
    "- `np.float32`, `np.float64`, `np.float16`, (and, sometimes, `np.float128`)\n",
    "- `np.bool`\n",
    "\n",
    "Note that these can over/underflow:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([1,2,3], np.uint8)\n",
    "A - 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Reduce along axis operations\n",
    "\n",
    "If you have a multidimensional array, you can reduce it along one of its axis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([\n",
    "    [0,0,1],\n",
    "    [1,2,3],\n",
    "    [2,4,2],\n",
    "    [1,0,1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.max(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.max(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([\n",
    "    [0,1,2],\n",
    "    [2,3,4],\n",
    "    [4,5,6],\n",
    "    [6,7,8]])\n",
    "\n",
    "A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[:2,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Slices share memory!\n",
    "\n",
    "A slice is a *view* into another array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([\n",
    "    [0,1,2],\n",
    "    [2,3,4],\n",
    "    [4,5,6],\n",
    "    [6,7,8]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = A[0]\n",
    "B[0] = -1\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Argument passing is by reference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def double_array(A):\n",
    "    A *= 2\n",
    "A = np.arange(20)\n",
    "double_array(A)\n",
    "\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You need to be careful, but you can always make a copy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.arange(20)\n",
    "B = A.copy()\n",
    "double_array(B)\n",
    "print(A)\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Logical Arrays\n",
    "\n",
    "Arrays of booleans:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([-1,0,1,2,-2,3,4,-2])\n",
    "A > 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "( (A > 0) & (A < 3) ).mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Logical indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[A < 0] = 0\n",
    "# or\n",
    "\n",
    "A *= (A > 0)\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Some helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.zeros((10,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ones(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([1,2,3,4,5])\n",
    "B = np.zeros_like(A)\n",
    "B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Numpy and Pytorch share operations\n",
    "\n",
    "- `Pytorch` is is a computational graph tookit.\n",
    "- Has many of `numpy`'s operations (sometimes with different names).\n",
    "- Also stores information to compute gradients of composed operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Matplotlib\n",
    "\n",
    "- Matplotlib is a plotting library.\n",
    "- Very flexible.\n",
    "- Very active project.\n",
    "- Ugly plots by default (next version will fix this)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import style\n",
    "\n",
    "style.use('fivethirtyeight')\n",
    "X = np.linspace(-4, 4, 1000)\n",
    "plt.plot(X, X**2*np.cos(X**2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Ok, that was disappointing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "How can we see the plot?\n",
    "\n",
    "Using a magic command:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Now, we try again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = np.linspace(-4, 4, 1000)\n",
    "plt.plot(X, X**2*np.cos(X**2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Interactive exploration\n",
    "\n",
    "Personally, this is the killer feature of the notebooks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ipywidgets import interact\n",
    "\n",
    "@interact(power=(1,10))\n",
    "def plot_cos(power=n):\n",
    "    plt.plot(X, X**power*np.cos(X**power))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Interactive exploration\n",
    "\n",
    "- You can do complicated things with complicated code, but 95% of the time, the simple ones work\n",
    "- bools -> checkbox\n",
    "- int/floats -> slider\n",
    "- dict -> selectbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@interact(power=(1,3.), function={'sin' : np.sin, 'cos': np.cos}, multiply=True)\n",
    "def plot_cos_more(power, function, multiply):\n",
    "    Y = function(X ** power)\n",
    "    if multiply:\n",
    "        Y *= X**power\n",
    "    plt.plot(X, Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# What if I don't like this notebook thing\n",
    "\n",
    "Then, don't use it!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Find yourself a proper editor/debugger!\n",
    "\n",
    "At some point in the labs, notebooks will not be enough (day2, probably)\n",
    "\n",
    "1. A text editor (vim, emacs, nano...)\n",
    "2. An IDE (Pycharm, Spyder)\n",
    "3. Learn to use `pdb` (`ipdb` for your eyes sake) \n",
    "4. My choice `vim+ipdb` (steepest learning curve)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Example of pdb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def nested_function(argument):\n",
    "    print(\"this died\")\n",
    "\n",
    "def complicated_function(first_value, second_value):\n",
    "    if first_value is None:\n",
    "        import pdb;pdb.set_trace()\n",
    "        nested_function(second_value)\n",
    "        \n",
    "complicated_function(None, 3)        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Documentation:\n",
    "\n",
    "- Guide: http://lxmls.it.pt/2019/LxMLS_guide_2019.pdf \n",
    "- Numpy docs: [http://docs.scipy.org/doc/](http://docs.scipy.org/doc/)\n",
    "- Matplotlib: [http://matplotlib.org](http://matplotlib.org)\n",
    "- Python docs: [http://docs.python.org](http://docs.python.org)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.1"
  },
  "widgets": {
   "state": {
    "0c2d34b168834959a416a71a175d512b": {
     "views": [
      {
       "cell_index": 168
      }
     ]
    },
    "5db507fe394f4be4a3f06fffa4929be6": {
     "views": [
      {
       "cell_index": 170
      }
     ]
    }
   },
   "version": "1.2.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}