Lesson 12 -- 2020 June 12.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a program that asks the user to enter sentences, one at a time. Stop asking when the user enters an empty string. Write each word that the user entered on a separate line of a file, followed by a space and the number of vowels that the user wrote.\n",
    "\n",
    "So if the user enters ‘this is a test’ and ‘only kidding’, then the file should look like:\n",
    "\n",
    "    this 1\n",
    "    is 1\n",
    "    a 1\n",
    "    test 1\n",
    "    only 1\n",
    "    kidding 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: this is a test\n",
      "Enter a sentence: this is a very important test\n",
      "Enter a sentence: a test should have no encyclopedias attached\n",
      "Enter a sentence: \n"
     ]
    }
   ],
   "source": [
    "with open('vowel_counts.txt', 'w') as outfile:\n",
    "    while True:\n",
    "        s = input(\"Enter a sentence: \").strip()\n",
    "        \n",
    "        if s == '':\n",
    "            break\n",
    "            \n",
    "        for one_word in s.split():\n",
    "            total = 0\n",
    "            \n",
    "            for one_letter in one_word:\n",
    "                if one_letter in 'aeiou':\n",
    "                    total += 1\n",
    "                    \n",
    "            outfile.write(f'{one_word} {total}\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: this this this test test test\n",
      "Enter a sentence: this this this also test test test\n",
      "Enter a sentence: \n"
     ]
    }
   ],
   "source": [
    "counts = {}\n",
    "\n",
    "while True:\n",
    "    s = input(\"Enter a sentence: \").strip()\n",
    "\n",
    "    if s == '':\n",
    "        break\n",
    "\n",
    "    for one_word in s.split():\n",
    "        total = 0\n",
    "\n",
    "        for one_letter in one_word:\n",
    "            if one_letter in 'aeiou':\n",
    "                total += 1\n",
    "\n",
    "        counts[one_word] = total\n",
    "        \n",
    "with open('dict-counts.txt', 'w') as outfile:\n",
    "    for key, value in counts.items():\n",
    "        outfile.write(f'{key} {value}\\n')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this 1\r\n",
      "test 1\r\n",
      "also 2\r\n"
     ]
    }
   ],
   "source": [
    "!cat dict-counts.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this 1\r\n",
      "is 1\r\n",
      "a 1\r\n",
      "test 1\r\n",
      "this 1\r\n",
      "is 1\r\n",
      "a 1\r\n",
      "very 1\r\n",
      "important 3\r\n",
      "test 1\r\n",
      "a 1\r\n",
      "test 1\r\n",
      "should 2\r\n",
      "have 2\r\n",
      "no 1\r\n",
      "encyclopedias 5\r\n",
      "attached 3\r\n"
     ]
    }
   ],
   "source": [
    "!cat vowel_counts.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s pretend that we’re creating a sales report for our company. Repeatedly ask the user to enter a product name and a number of units sold. (The products and units don’t matter, but should be separated by whitespace.) When the user enters a blank line, stop asking. Write this into a CSV-like file (i.e., with a comma separating the two pieces of information). If the file has a csv extension, see if you can open it with Excel on your computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter product and number: books 10\n",
      "Enter product and number: coffee 20\n",
      "Enter product and number: tea 25\n",
      "Enter product and number: computers 2\n",
      "Enter product and number: lamp 4\n",
      "Enter product and number: \n"
     ]
    }
   ],
   "source": [
    "with open('sales-report.csv', 'w') as outfile:\n",
    "    while True:\n",
    "        s = input(\"Enter product and number: \").strip()\n",
    "        \n",
    "        if s == '':\n",
    "            break\n",
    "            \n",
    "        product, number = s.split()   # unpacking!\n",
    "        \n",
    "        outfile.write(f'{product},{number}\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "books,10\r\n",
      "coffee,20\r\n",
      "tea,25\r\n",
      "computers,2\r\n",
      "lamp,4\r\n"
     ]
    }
   ],
   "source": [
    "!cat sales-report.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "!open sales-report.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter product and number: books 10\n",
      "Enter product and number: ice cream 20\n",
      "Enter product and number: \n"
     ]
    }
   ],
   "source": [
    "with open('sales-report.csv', 'w') as outfile:\n",
    "    while True:\n",
    "        s = input(\"Enter product and number: \").strip()\n",
    "        \n",
    "        if s == '':\n",
    "            break\n",
    "            \n",
    "        product, number = s.rsplit(None, 1) # split on whitespace (None), max of 1 time\n",
    "        \n",
    "        outfile.write(f'{product},{number}\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "books,10\r\n",
      "ice cream,20\r\n"
     ]
    }
   ],
   "source": [
    "!cat sales-report.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "!open sales-report.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ice cream 20'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ice', 'cream 20']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.split(None, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter product and number: books 10\n",
      "Enter product and number: ice cream 20\n",
      "Enter product and number: \n"
     ]
    }
   ],
   "source": [
    "with open('sales-report.csv', 'w') as outfile:\n",
    "    while True:\n",
    "        s = input(\"Enter product and number: \").strip()\n",
    "        \n",
    "        if s == '':\n",
    "            break\n",
    "            \n",
    "        sep_index = s.rfind(' ')\n",
    "        product = s[:sep_index]\n",
    "        number = s[sep_index+1:]\n",
    "        \n",
    "        outfile.write(f'{product},{number}\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "books,10\r\n",
      "ice cream,20\r\n"
     ]
    }
   ],
   "source": [
    "!cat sales-report.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# \"def\" defines a new function\n",
    "\n",
    "def hello():\n",
    "    print('Hello!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n"
     ]
    }
   ],
   "source": [
    "hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# redefine the function by using \"def\" and the same function name again\n",
    "# the previous version WILL NO LONGER BE AVAILABLE! \n",
    "\n",
    "def hello(name):   # \"name\" is a parameter, a variable that gets its value from the caller\n",
    "    print(f'Hello, {name}!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "hello('world')  # the value we pass to the function is an \"argument\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Reuven!\n"
     ]
    }
   ],
   "source": [
    "hello('Reuven')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "hello() missing 1 required positional argument: 'name'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-27-2789573353aa>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mhello\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m   \u001b[0;31m# no arguments\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: hello() missing 1 required positional argument: 'name'"
     ]
    }
   ],
   "source": [
    "hello()   # no arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = len('abcd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "x = hello('world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Don't print from your functions -- rather *return* values from your functions\n",
    "# (Except for debugging and when the function is meant to print things on the screen)\n",
    "\n",
    "def hello(name):   # \"name\" is a parameter, a variable that gets its value from the caller\n",
    "    return f'Hello, {name}!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = hello('world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, world!'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world!\n"
     ]
    }
   ],
   "source": [
    "print(hello('world'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, 5!'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello(5)  # can I pass an integer to this function as an argument?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, [10, 20, 30]!'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello([10, 20, 30])  # how about a list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Hello, {'a': 1, 'b': 2, 'c': 3}!\""
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello({'a':1, 'b':2, 'c':3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, <function hello at 0x10ec04550>!'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello(hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(3, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(10, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ab'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add('a', 'b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-46-e5b9339bc3c8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'a'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-42-17cbf0e59835>\u001b[0m in \u001b[0;36madd\u001b[0;34m(a, b)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "add('a', 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function len in module builtins:\n",
      "\n",
      "len(obj, /)\n",
      "    Return the number of items in a container.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "upper(self, /)\n",
      "    Return a copy of the string converted to uppercase.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(str.upper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function hello in module __main__:\n",
      "\n",
      "hello(name)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use a \"docstring\" to describe how your function should be used\n",
    "# That is: A string immediately after the \"def\" line in a function\n",
    "\n",
    "def hello(name):\n",
    "    \"\"\"This is the best function ever written.\n",
    "    \n",
    "    It's so great, it gets a two-line docstring!\n",
    "    \"\"\"\n",
    "    return f'Hello, {name}!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function hello in module __main__:\n",
      "\n",
      "hello(name)\n",
      "    This is the best function ever written.\n",
      "    \n",
      "    It's so great, it gets a two-line docstring!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# maintainer's manual -- Comments: Meant for the people who will MODIFY/MAINTAIN the function\n",
    "# owner's manual -- Docstring: Meant for people who will USE the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello(name):\n",
    "    \"\"\"A very friendly function that returns a greeting.\n",
    "    \n",
    "    Requires: Takes one argument, presumably a string\n",
    "    Modifies: Nothing\n",
    "    Returns: A string, with a pleasant greeting for people of all ages\n",
    "    \"\"\"\n",
    "    return f'Hello, {name}!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function hello in module __main__:\n",
      "\n",
      "hello(name)\n",
      "    A very friendly function that returns a greeting.\n",
      "    \n",
      "    Requires: Takes one argument, presumably a string\n",
      "    Modifies: Nothing\n",
      "    Returns: A string, with a pleasant greeting for people of all ages\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Triple-quoted strings can be ''' '''  or \"\"\" \"\"\"\n",
    "# however, they're traditionally done with \"\"\" \"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([10, 20, 30])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# can we write our own version of sum?\n",
    "# NOTE: DO NOT CALL IT \"sum\"\n",
    "\n",
    "def mysum(numbers):\n",
    "    \"\"\"Returns the sum of a list of numbers.\n",
    "    \n",
    "    Requires: A list of numbers passed as an argument\n",
    "    Modifies: Nothing\n",
    "    Returns: A number with the sum of the argument's elements    \n",
    "    \"\"\"\n",
    "    total = 0\n",
    "    \n",
    "    for one_number in numbers:\n",
    "        total += one_number\n",
    "        \n",
    "    return total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum([10, 20, 30])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    return a + b\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(10, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "add() missing 1 required positional argument: 'b'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-62-c7b811cdd403>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# can't the function assume that I want to add 2 to this?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: add() missing 1 required positional argument: 'b'"
     ]
    }
   ],
   "source": [
    "add(10)  # can't the function assume that I want to add 2 to this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(a, b=2):   # b is now an optional parameter -- if missing, it gets the value 2\n",
    "    return a + b\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(3, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'd', 'e']"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a b c d e'.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'd', 'e']"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a b c d e'.split(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'd e']"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a b c d e'.split(None, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on method_descriptor:\n",
      "\n",
      "split(self, /, sep=None, maxsplit=-1)\n",
      "    Return a list of the words in the string, using sep as the delimiter string.\n",
      "    \n",
      "    sep\n",
      "      The delimiter according which to split the string.\n",
      "      None (the default value) means split according to any whitespace,\n",
      "      and discard empty strings from the result.\n",
      "    maxsplit\n",
      "      Maximum number of splits to do.\n",
      "      -1 (the default value) means no limit.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(str.split)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise: Vowels in word\n",
    "\n",
    "Write a function, all_vowels, that takes a string as an argument.  It returns\n",
    "a list of the vowels in that string.\n",
    "\n",
    "Example:\n",
    "\n",
    "    all_vowels('hello')\n",
    "    \n",
    "Return value would be:\n",
    "\n",
    "    ['e', 'o']\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "def all_vowels(word):\n",
    "    output = []\n",
    "    \n",
    "    for one_letter in word:\n",
    "        if one_letter in 'aeiou':\n",
    "            output.append(one_letter)    \n",
    "    \n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['o', 'a', 'i', 'e']"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_vowels('container')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: test\n",
      "Enter a word: for\n",
      "Enter a word: the\n",
      "Enter a word: sake\n",
      "Enter a word: of\n",
      "Enter a word: testing\n",
      "Enter a word: encyclopedia\n",
      "Enter a word: elephant\n",
      "Enter a word: octopus\n",
      "Enter a word: \n"
     ]
    }
   ],
   "source": [
    "d = {}\n",
    "\n",
    "while True:\n",
    "    word = input(\"Enter a word: \").strip()\n",
    "    \n",
    "    if word == '':\n",
    "        break\n",
    "        \n",
    "    d[word] = all_vowels(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'test': ['e'],\n",
       " 'for': ['o'],\n",
       " 'the': ['e'],\n",
       " 'sake': ['a', 'e'],\n",
       " 'of': ['o'],\n",
       " 'testing': ['e', 'i'],\n",
       " 'encyclopedia': ['e', 'o', 'e', 'i', 'a'],\n",
       " 'elephant': ['e', 'e', 'a'],\n",
       " 'octopus': ['o', 'o', 'u']}"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_net_worth():\n",
    "    bank_balance = get_bank_balance()\n",
    "    house_value = get_house_value()\n",
    "    pensions = get_pensions()\n",
    "    \n",
    "    return bank_balance + house_value + pensions\n",
    "\n",
    "# Small Matter of Programming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_vat(price):\n",
    "    return price * 0.17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.0"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "price = 100\n",
    "\n",
    "calculate_vat(price)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "117.0"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def price_including_vat(price):\n",
    "    return price + calculate_vat(price)\n",
    "\n",
    "price_including_vat(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo():\n",
    "    asdfafafasfasfasfsaf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'asdfafafasfasfasfsaf' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-79-c19b6d9633cf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfoo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-78-7f8862a94584>\u001b[0m in \u001b[0;36mfoo\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfoo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0masdfafafasfasfasfsaf\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'asdfafafasfasfasfsaf' is not defined"
     ]
    }
   ],
   "source": [
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-80-6c52c84e7f64>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-80-6c52c84e7f64>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    asdfafafa\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "def foo():\n",
    "    asdfafaas\n",
    "     asdfafafa"
   ]
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}