D1 Introduction [answers].ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 1 - Introduction\n",
    "\n",
    "Welcome to the Python crash course for climate scientists. I'm glad you're here. \n",
    "\n",
    "During this course we'll give you an overview of how you can use Python in your projects. No-one can become fluent in Python in three days. Instead, we aim to show you a range of tools, how to use them and how they fit together.\n",
    "\n",
    "For this first session we're first going to cover the fundamentals of Python. Next, you'll be given tasks to complete on your own."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basics\n",
    "* Math, variables\n",
    "* Logic\n",
    "* Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# math/variables\n",
    "print('math/variables:')\n",
    "a = 1 + 4\n",
    "print(a)\n",
    "a += 2\n",
    "print(a)\n",
    "b = 3 / 2 # note floating point division\n",
    "print(b)\n",
    "c = 3 // 2 # note integer division\n",
    "print(c)\n",
    "d = a + b\n",
    "print(d)\n",
    "print()\n",
    "\n",
    "# logic\n",
    "print('logic:')\n",
    "a = 10\n",
    "cond = a == 10\n",
    "print('a is equal to 10', cond)\n",
    "cond = a is 10 # alternative comparison\n",
    "print(cond)\n",
    "print()\n",
    "\n",
    "# strings\n",
    "print('strings:')\n",
    "s = 'foo' # strings use ' or \"\n",
    "s += 'bar' # strings are concatenated via addition\n",
    "print(s)\n",
    "\n",
    "# string indexing\n",
    "print('first character of s is', s[0]) # you can index into strings\n",
    "print('first 2 characters of s are', s[:2]) # slice indexing\n",
    "print('final 3 characters of s are', s[-3:]) # negative indexing\n",
    "\n",
    "s1 = 'foo'\n",
    "s2 = 'bar'\n",
    "# s = ''.join([foo, bar])\n",
    "print('joining two strings:', s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Collections\n",
    "* Lists\n",
    "* Tuples\n",
    "* Dictionaries\n",
    "* Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lists\n",
    "print('lists:')\n",
    "l = [1, 2, 3] # lists are created with square brackets\n",
    "print(l)\n",
    "l = [1, 2.0, 'foo'] # collections can contain arbitrary objects\n",
    "print(l)\n",
    "print('indexing works like with strings', l[0], l[1])\n",
    "print('slice indexing', l[1:3])\n",
    "print('negative indexing', l[-1], l[-2:])\n",
    "print('get the number of elements using len:', len(l))\n",
    "\n",
    "l1 = [1, 2, 3]\n",
    "l2 = ['foo', 'bar']\n",
    "l3 = l1 + l2 # list concatenation\n",
    "print(l3)\n",
    "\n",
    "l = [1, 2, 3]\n",
    "l.append('baz') # appending\n",
    "print(l)\n",
    "print()\n",
    "\n",
    "# tuples\n",
    "print('tuples:')\n",
    "t = (1, 2, 3) # like lists but immutable, i.e., can't be changed\n",
    "print(t)\n",
    "a, b, c = t # tuple unpacking (works with lists too!)\n",
    "print('a=', a, 'b=', b, 'c=', c)\n",
    "print()\n",
    "\n",
    "# dictionaries\n",
    "print('dictionaries:')\n",
    "d = {1: 'foo', 'baz': 2} # maps keys to values. both can be of any type.\n",
    "print(d)\n",
    "print('key', 1, 'maps to value', d[1]) # indexing via square brackets\n",
    "d[2] = 3 # add key-valye pairs by assigning the value to d[key]\n",
    "print('dict after adding 2=>3 mapping', d)\n",
    "cond = 2 in d # check if key 2 is in the dict\n",
    "print('dict contains key 2:', cond)\n",
    "if 2 in d:\n",
    "    print('d contains key 2')\n",
    "    \n",
    "if 3 not in d: # negating the statement\n",
    "    print('d does not contain key 3')\n",
    "print()\n",
    "\n",
    "# sets\n",
    "print('sets:')\n",
    "s = {1, 2, 'foo'} # like dicts, but only contains keys\n",
    "print(s)\n",
    "cond = 'foo' in s # check for members, like dicts\n",
    "print('set contains foo:', cond)\n",
    "s1 = {1, 2, 3}\n",
    "s2 = {3, 4, 5}\n",
    "print('sets support fast intersection/union')\n",
    "print('intersection of s1 and s2:', s1.intersection(s2))\n",
    "print('union of s1 and s2:', s1.union(s2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control Flow\n",
    "* If\n",
    "* For\n",
    "* While"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if\n",
    "print('if:')\n",
    "a = 10\n",
    "if a == 10: # note the colon\n",
    "    print('a has value 10') # meaningful indentation\n",
    "    \n",
    "b = 20\n",
    "if a == 10 and b == 20: # no Java-esque && ;)\n",
    "    print('a has value 10 and b has value 20')\n",
    "    \n",
    "c = 30\n",
    "if a == 3.14 or c == 30:\n",
    "    print('a is 3.14 or c is 30')\n",
    "print()\n",
    "\n",
    "# for\n",
    "print('for:')\n",
    "n = 4\n",
    "for i in range(n): # iterate over indices 0 to n-1\n",
    "    print(i)\n",
    "   \n",
    "print()\n",
    "l = [1, 'bar', 3.14, 'baz']\n",
    "print('iterate over members of a collection')\n",
    "for v in l: # iterate over the member of a collection\n",
    "    print(v)\n",
    "    \n",
    "print()\n",
    "print('works for any collection')\n",
    "d = {1: 'foo', 'baz': 2} # dict\n",
    "for k in d: # iterating over a dict gives the keys\n",
    "    print(k, 'maps to value', d[k])\n",
    "print()\n",
    "\n",
    "# while\n",
    "print('Python also has while loops')\n",
    "i = 0\n",
    "while i < n:\n",
    "    i += 1\n",
    "    print(i)\n",
    "    \n",
    "import random # using a library\n",
    "v = 0\n",
    "while v < 0.5:\n",
    "    v = random.random() # uniform random value between 0 and 1\n",
    "    print('v=', v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "* Functions definitions\n",
    "* The `None` value\n",
    "* Assertions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(): # note def keyword and colon\n",
    "    print('print from f')\n",
    "    return 10\n",
    "\n",
    "rv = f()\n",
    "print(rv)\n",
    "\n",
    "def g(a, b): # arguments\n",
    "    return a + b\n",
    "\n",
    "rv = g(10, 4)\n",
    "print(rv)\n",
    "\n",
    "rv = g('foo', 'bar') # arguments can be of any type\n",
    "print(rv)\n",
    "\n",
    "def u(a):\n",
    "    print('u was called with argument', a)\n",
    "    \n",
    "rv = u(10)\n",
    "print(rv) # functions without an explicit return value return None\n",
    "\n",
    "def elementwise_max(l1, l2):\n",
    "    assert len(l1) == len(l2), 'l1 and l2 must be of equal length'\n",
    "    rv = list()\n",
    "    for i in range(len(l1)):\n",
    "        rv.append(max(l1[i], l2[i]))\n",
    "    return rv\n",
    "\n",
    "# a more pythonic version\n",
    "def elementwise_max(l1, l2):\n",
    "    assert len(l1) == len(l2), 'l1 and l2 must be of equal length'\n",
    "    rv = list()\n",
    "    for v1, v2 in zip(l1, l2):\n",
    "        rv.append(max(v1, v2))\n",
    "    return rv\n",
    "\n",
    "# an even more pythonic version\n",
    "def elementwise_max(l1, l2):\n",
    "    assert len(l1) == len(l2), 'l1 and l2 must be of equal length'\n",
    "    return [max(v1, v2) for v1, v2 in zip(l1, l2)] # list comprehension\n",
    " \n",
    "l1 = [1,2,3]\n",
    "l2 = [3,2,1]\n",
    "l = elementwise_max(l1, l2)\n",
    "print('elementwise_max:', l)\n",
    "\n",
    "def f1():\n",
    "    print('print from f1')\n",
    "    \n",
    "def f2():\n",
    "    print('print from f2')\n",
    "    \n",
    "# first-class functions\n",
    "print('functions in Python are first class, i.e., they can be treated like variables')\n",
    "f = f1\n",
    "f()\n",
    "f = f2\n",
    "f()\n",
    "\n",
    "print('giving functions as arguments')\n",
    "def g(f):\n",
    "    print('print from g')\n",
    "    f()\n",
    "g(f1)\n",
    "print()\n",
    "g(f2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comprehension\n",
    "Python has very compact syntax for creating lists, dictionaries, and sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list comprehension\n",
    "l = [i*2 for i in range(2, 10)]\n",
    "print(l)\n",
    "\n",
    "# dictionary comprehension\n",
    "d = {i: i*2 for i in range(2, 10)}\n",
    "print(d)\n",
    "\n",
    "# set comprehension\n",
    "s = {v for v in l if v < 10}\n",
    "print(s)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Your Problems\n",
    "* **These problems are for you to solve on your own**. We'll give you a few minutes on each problem before showing you how we would have solved them. We're using **test-driven development**. This means that we've written code that tests your code for you. **You've solved the problem once all tests pass.**\n",
    "* The point here is for you to **start thinking in Python abstractions** (lists, dicts, functions, etc.), not to produce perfect code, i.e., **don't worry if you don't have time to solve every problem.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Sum 2\n",
    "* Write a function `sum2(a, b)` that returns the sum of its two arguments `a` and `b`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum2(a, b):\n",
    "    '''returns the sum of a and b.'''\n",
    "    return a + b\n",
    "\n",
    "# tests of your function. make no changes below this line.\n",
    "ans = sum2(1, 2)\n",
    "correct = 3\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = sum2(3.0, 2)\n",
    "correct = 5.0\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = sum2('foo', 'bar')\n",
    "correct = 'foobar'\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "print('all tests pass')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: List of Numbers\n",
    "* Write a function that returns a list of all numbers from a to b (inclusive)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def arange(a, b):\n",
    "    '''return a list of the integers from a to b (inclusive).'''\n",
    "    rv = list()\n",
    "    for i in range(a, b+1):\n",
    "        rv.append(i)\n",
    "    return rv\n",
    "\n",
    "# tests of your function. make no changes below this line.\n",
    "ans = arange(0, 3)\n",
    "correct = [0, 1, 2, 3]\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = arange(2, 3)\n",
    "correct = [2, 3]\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = arange(-3, 2)\n",
    "correct = [-3, -2, -1, 0, 1, 2]\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "print('all tests pass')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Memoization\n",
    "* Create a function that returns a dict mapping the integers in a list to their squares. Caching computed results in this way is referred to as memoization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "def memoize_squares(l):\n",
    "    '''return a dict mapping the values in l to their square roots.'''\n",
    "    rv = dict()\n",
    "    for v in l:\n",
    "        rv[v] = math.pow(v, 2)\n",
    "    return rv\n",
    "\n",
    "# tests of your function. make no changes below this line.\n",
    "ans = memoize_squares([1, 2, 3])\n",
    "correct = {1: 1, 2: 4, 3: 9}\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = memoize_squares([])\n",
    "correct = {}\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = memoize_squares([-1, 2, 3])\n",
    "correct = {-1: 1, 2: 4, 3: 9}\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "print('all tests pass')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Filtered Sum\n",
    "* Create a function that returns the sum of values in a list that are larger than some value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filtered_sum(l, a):\n",
    "    '''return the sum of all values in l larger than a.'''\n",
    "    rv = 0\n",
    "    for v in l:\n",
    "        if v > a:\n",
    "            rv += v\n",
    "    return rv\n",
    "\n",
    "# tests of your function. make no changes below this line.\n",
    "ans = filtered_sum([1, 2, 3], 1)\n",
    "correct = 5\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = filtered_sum([1, 2, 3], 3)\n",
    "correct = 0\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = filtered_sum([1, -3, -1], -2)\n",
    "correct = 0\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "print('all tests pass')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Max\n",
    "* Write a function `mymax(l)` that takes a list `l` as its argument and returns the largest value in that list.\n",
    "* Use a for loop to iterate over the values in the list.\n",
    "* If the list is empty (contains zero elements), return `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mymax(l):\n",
    "    '''Return the largest value in l, or None if l is empty.\n",
    "    \n",
    "    '''\n",
    "    if not len(l):\n",
    "        return None\n",
    "    rv = l[0]\n",
    "    for v in l:\n",
    "        rv = max(rv, v)\n",
    "    return rv\n",
    " \n",
    "# tests of your function. make no changes below this line.\n",
    "ans = mymax([1, 2, 3, 0])\n",
    "correct = 3\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = mymax([-1, -2, -3, 0])\n",
    "correct = 0\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = mymax([1])\n",
    "correct = 1\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = mymax([])\n",
    "correct = None\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "print('all tests pass')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Character Occurences\n",
    "* Write a function `occurrences(s)` that takes a string `s` as its argument and returns a dict mapping each character to the number of times it occurrs in `s`.\n",
    "* Use a for loop to iterate over the characters in `s` and a dict to count the number of occurrences.\n",
    "* Improvement: Use the `get` method on a `dict` instead of using an if statement to handle new occurrences.\n",
    "* Improvement: Use a `defaultdict` from the [collections module](https://docs.python.org/3.3/library/collections.html) instead of a regular dict to avoid having to use an if statement or the `get` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def occurrences(s):\n",
    "    '''return a dict mapping each character in s to the number of times it occurrs in s.\n",
    "    \n",
    "    For example, if s = \"foo\", {\"f\": 1, \"o\": 2} is returned.\n",
    "    \n",
    "    '''\n",
    "    rv = dict()\n",
    "    for c in s:\n",
    "        if c not in rv:\n",
    "            rv[c] = 0\n",
    "        rv[c] += 1\n",
    "    return rv\n",
    "\n",
    "# tests of your function. make no changes below this line.\n",
    "ans = occurrences('foobar')\n",
    "correct = {'f': 1, 'o': 2, 'b': 1, 'a': 1, 'r': 1}\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = occurrences('')\n",
    "correct = {}\n",
    "assert ans == correct, f'expected {correct}, but got {ans}'\n",
    "\n",
    "print('all tests pass')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: Dict Key Overlap\n",
    "* Write a function that takes two dictionaries as its arguments and returns a set composed of the keys that exist in both dictionaries.\n",
    "* Improvement: Do it in 1 line of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def keys_in_both(d1, d2):\n",
    "    '''return a set composed of the keys that exist in both d1 and d2.\n",
    "    \n",
    "    for example, if d1 = {\"f\": 1, \"o\": 2} and d2 = {\"o\": 10, \"bar\": 3}, {\"o\"} is returned.\n",
    "    \n",
    "    '''\n",
    "    return set(d1.keys()).intersection(set(d2.keys()))\n",
    "\n",
    "# tests of your function. make no changes below this line.\n",
    "ans = keys_in_both({\"f\": 1, \"o\": 2}, {\"o\": 10, \"bar\": 3})\n",
    "correct = {\"o\"}\n",
    "assert correct == ans, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = keys_in_both({\"f\": 1}, {\"o\": 10, \"bar\": 3})\n",
    "correct = set()\n",
    "assert correct == ans, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = keys_in_both({\"bar\": 100, \"f\": 1, \"o\": 2}, {\"o\": 10, \"bar\": 3})\n",
    "correct = {\"o\", \"bar\"}\n",
    "assert correct == ans, f'expected {correct}, but got {ans}'\n",
    "\n",
    "print('all tests pass')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise: String Multiplexing\n",
    "* Write a function that takes as input a list of strings and returns a new string that combines all input strings by taking one character from each input string at a time. See the examples in the docstring below for further information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiplex_strings(strings):\n",
    "    '''return a new string created by multiplexing all input strings.\n",
    "    \n",
    "    for example, if the input is [\"foo\", \"bar\"], the returned string is \"fboaor\".\n",
    "    each character of a string is only used once. for example, if the input is\n",
    "    [\"foo\", \"bar\", \"G\"], the returned string is \"fbGoaor\".\n",
    "    \n",
    "    '''\n",
    "    result = ''\n",
    "    remaining_strings = len(strings)\n",
    "    while remaining_strings > 0:\n",
    "        for i, string in enumerate(strings):\n",
    "            if string is None:\n",
    "                continue\n",
    "            if string == \"\":\n",
    "                remaining_strings -= 1\n",
    "                strings[i] = None\n",
    "                continue\n",
    "            result += string[0]\n",
    "            strings[i] = string[1:]\n",
    "    return result\n",
    "\n",
    "# tests of your function. make no changes below this line.\n",
    "ans = multiplex_strings([\"foo\", \"bar\"])\n",
    "correct = \"fboaor\"\n",
    "assert correct == ans, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = multiplex_strings([\"foo\", \"bar\", \"G\"])\n",
    "correct = \"fbGoaor\"\n",
    "assert correct == ans, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = multiplex_strings([\"foo\"])\n",
    "correct = \"foo\"\n",
    "assert correct == ans, f'expected {correct}, but got {ans}'\n",
    "\n",
    "ans = multiplex_strings([])\n",
    "correct = \"\"\n",
    "assert correct == ans, f'expected {correct}, but got {ans}'\n",
    "\n",
    "print('all tests pass')"
   ]
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": "6cf04316a4e64149865c8cd5e38f3956",
   "lastKernelId": "d665e690-7e07-4349-8a36-81cd5fc2298d"
  },
  "kernelspec": {
   "display_name": "dynpie3-2020a",
   "language": "python",
   "name": "dynpie3-2020a"
  },
  "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
}