Lesson 9 -- 2020 May 15.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".     We have previously written a program that takes a single word from the user and translates it into Pig Latin. I now want you to take an entire sentence from the user (all lower-case letters, and without punctuation) and print the translation of each word into Pig Latin. So if the user enters this is a test, the output will be histay isway away esttay."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: this is a test\n",
      "histay isway away esttay\n"
     ]
    }
   ],
   "source": [
    "sentence = input(\"Enter a sentence: \").strip()\n",
    "all_words = sentence.split()\n",
    "\n",
    "output = []\n",
    "for word in all_words:\n",
    "    if word[0] in 'aeiou':\n",
    "        output.append(f'{word}way')\n",
    "    else:\n",
    "        output.append(f'{word[1:]}{word[0]}ay')\n",
    "print(' '.join(output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence = input(\"Enter a sentence: \").strip()\n",
    "\n",
    "output = []\n",
    "for word in sentence.split():\n",
    "    if word[0] in 'aeiou':\n",
    "        output.append(f'{word}way')\n",
    "    else:\n",
    "        output.append(f'{word[1:]}{word[0]}ay')\n",
    "print(' '.join(output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: this is a test\n",
      "histay isway away esttay\n"
     ]
    }
   ],
   "source": [
    "all_words = input(\"Enter a sentence: \").split()\n",
    "\n",
    "output = []\n",
    "for word in all_words:\n",
    "    if word[0] in 'aeiou':\n",
    "        output.append(f'{word}way')\n",
    "    else:\n",
    "        output.append(f'{word[1:]}{word[0]}ay')\n",
    "print(' '.join(output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "output = []\n",
    "for word in input(\"Enter a sentence: \").split():\n",
    "    if word[0] in 'aeiou':\n",
    "        output.append(f'{word}way')\n",
    "    else:\n",
    "        output.append(f'{word[1:]}{word[0]}ay')\n",
    "print(' '.join(output))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".     Ask the user to enter several words separated by whitespace. Print those words separated by * characters. So if the user enters this is a test, the program should print this*is*a*test. You should not use str.replace, but rather str.split and str.join."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: this        is  a    test\n",
      "this*is*a*test\n"
     ]
    }
   ],
   "source": [
    "s = input(\"Enter a sentence: \").strip()\n",
    "\n",
    "words = s.split()\n",
    "print('*'.join(words))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: this is a better test\n",
      "this*is*a*better*test\n"
     ]
    }
   ],
   "source": [
    "s = input(\"Enter a sentence: \").strip()\n",
    "\n",
    "print('*'.join(s.split()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# strip -- removes whitespace from the edges of a string, and returns a new string\n",
    "# split -- returns a list of strings, based on a string\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".     Ask the user to enter numbers, separated by spaces, on a single line. Append each number to one of two lists, evens or odds. Then print the even numbers, one per line (i.e., \\n characters between each) and then the odd numbers, one per line. This will require not just str.join and str.split, but also some moving between int and str, so you have been warned!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter numbers, separated by spaces: 10 11 12 abcd 1a 15 16 17\n",
      "abcd is not numeric; ignoring\n",
      "1a is not numeric; ignoring\n"
     ]
    }
   ],
   "source": [
    "evens = []\n",
    "odds = []\n",
    "\n",
    "numbers = input(\"Enter numbers, separated by spaces: \").split()\n",
    "\n",
    "for one_number in numbers:\n",
    "    if not one_number.isdigit():\n",
    "        print(f'{one_number} is not numeric; ignoring')\n",
    "        continue\n",
    "        \n",
    "    one_number = int(one_number)\n",
    "    \n",
    "    if one_number % 2 == 0:\n",
    "        evens.append(str(one_number))\n",
    "    else:\n",
    "        odds.append(str(one_number))\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['10', '12', '16']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "evens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['11', '15', '17']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "odds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "12\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "print('\\n'.join(evens))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "15\n",
      "17\n"
     ]
    }
   ],
   "source": [
    "print('\\n'.join(odds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcd'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = ['abcd', 'efgh', 'ijkl']\n",
    "\n",
    "mylist[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'efgh'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ijkl'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "person = ['Reuven', 'Lerner', 46]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Reuven'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Lerner'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "46"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionaries: like lists, but we can use either ints or strings as the keys/indexes\n",
    "\n",
    "# key-value pairs\n",
    "# name-value pairs\n",
    "\n",
    "d = {'first':'Reuven',  'last':'Lerner',  'shoesize':46}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'first': 'Reuven', 'last': 'Lerner', 'shoesize': 46}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Reuven'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['first']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Lerner'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['last']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "46"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['shoesize']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'email'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-32-74f52dfb546b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'email'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'email'"
     ]
    }
   ],
   "source": [
    "d['email']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-33-6706501c86e1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmylist\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m999\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "mylist[999]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'first': 'Reuven', 'last': 'Lerner', 'shoesize': 46}"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' in 'aeiou'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 in [10, 20, 30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'first': 'Reuven', 'last': 'Lerner', 'shoesize': 46}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Reuven' in d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# searching in dicts happens on the keys ONLY\n",
    "'first' in d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {}        # empty dict\n",
    "d['a'] = 100  # added the key-value pair 'a':100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 100}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 100, 'b': 200}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['b'] = 200\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 999, 'b': 200}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['a'] = 999  # replace the value associated with 'a'\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 999, 'b': 200, 'x': 123, 'q': 456}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['x'] = 123\n",
    "d['q'] = 456\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['r'] = [10, 20, 30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 999, 'b': 200, 'x': 123, 'q': 456, 'r': [10, 20, 30]}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 999, 'b': 200, 'x': 123, 'q': 456, 'r': [10, 20, 30]}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "999"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.pop('a')  # removes the key 'a', and returns its value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b': 200, 'x': 123, 'q': 456, 'r': [10, 20, 30]}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "country_codes = {'USA':1,\n",
    "                'Israel':972,\n",
    "                'UK':44}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter country name: Israel\n",
      "Code for Israel is 972\n",
      "Enter country name: France\n",
      "No info for country France\n",
      "Enter country name: \n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    country_name = input(\"Enter country name: \").strip()\n",
    "    \n",
    "    if not country_name:   # meaning: blank country name? exit the loop!\n",
    "        break\n",
    "        \n",
    "    if country_name in country_codes:\n",
    "        print(f'Code for {country_name} is {country_codes[country_name]}')\n",
    "        \n",
    "    else:\n",
    "        print(f'No info for country {country_name}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 10\n",
      "Enter a number: 11\n",
      "Enter a number: 12\n",
      "Enter a number: 14\n",
      "Enter a number: 16\n",
      "Enter a number: 18\n",
      "Enter a number: \n"
     ]
    }
   ],
   "source": [
    "counts = {'evens':0,\n",
    "         'odds':0}\n",
    "\n",
    "while True:\n",
    "    n = input(\"Enter a number: \").strip()\n",
    "    \n",
    "    if not n:  # if empty/blank, then break\n",
    "        break\n",
    "        \n",
    "    if not n.isdigit():\n",
    "        print(f'{n} is not an integer. Try again.')\n",
    "        continue\n",
    "        \n",
    "    n = int(n)\n",
    "    \n",
    "    if n % 2 == 0:\n",
    "        counts['evens'] += 1\n",
    "    else:\n",
    "        counts['odds'] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'evens': 5, 'odds': 1}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n",
    "\n",
    "50 in mylist    # O(n) -- search speed is proportional to the lists's length\n",
    "                #  the longer the list, the longer you'll wait"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}\n",
    "\n",
    "'c' in d     # O(1) -- constant time!\n",
    "             # no matter how big or small, it'll take the same time to find something in d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# hash function makes it all possible!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# in other languages, \"dictionaries\" are called:\n",
    "# - hash tables\n",
    "# - hashes\n",
    "# - associative arrays\n",
    "# - maps\n",
    "# - hashmaps\n",
    "# - (JavaScript) objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A = 1\n",
    "# B = 2\n",
    "# C = 3\n",
    "\n",
    "# S = 19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: this is a test\n",
      "{'t': 3, 'h': 1, 'i': 2, 's': 3, ' ': 3, 'a': 1, 'e': 1}\n"
     ]
    }
   ],
   "source": [
    "counts = {}\n",
    "\n",
    "s = input(\"Enter a string: \").strip()\n",
    "\n",
    "for one_character in s:\n",
    "    if one_character in counts:\n",
    "        counts[one_character] += 1\n",
    "    else:\n",
    "        counts[one_character] = 1\n",
    "        \n",
    "print(counts)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t\n",
      "h\n",
      "i\n",
      "s\n",
      " \n",
      "a\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "for one_item in counts:  # iterating over a dict gives you the *keys*\n",
    "    print(one_item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t: 3\n",
      "h: 1\n",
      "i: 2\n",
      "s: 3\n",
      " : 3\n",
      "a: 1\n",
      "e: 1\n"
     ]
    }
   ],
   "source": [
    "for key in counts:\n",
    "    print(f'{key}: {counts[key]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('t', 3)\n",
      "('h', 1)\n",
      "('i', 2)\n",
      "('s', 3)\n",
      "(' ', 3)\n",
      "('a', 1)\n",
      "('e', 1)\n"
     ]
    }
   ],
   "source": [
    "# the \"items\" method returns a key-value tuple with each iteration\n",
    "for one_thing in counts.items():\n",
    "    print(one_thing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t: 3\n",
      "h: 1\n",
      "i: 2\n",
      "s: 3\n",
      " : 3\n",
      "a: 1\n",
      "e: 1\n"
     ]
    }
   ],
   "source": [
    "for key, value in counts.items():\n",
    "    print(f'{key}: {value}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[' ', 'a', 'e', 'h', 'i', 's', 't']"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://www.youtube.com/watch?v=QR9W81P7yTw\n",
    "    \n",
    "# FunctionDissectionLab.com"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: this is test number 3 for my program\n",
      "digits: 1\n",
      "vowels: 8\n",
      "other: 27\n"
     ]
    }
   ],
   "source": [
    "# ask the user to enter a sentence / words /whatever\n",
    "# count how many (a) digits, (b) vowels, and (c) other characters are\n",
    "#  in the user's input\n",
    "# keep track of them in a dict\n",
    "# print each count when we're done\n",
    "\n",
    "\n",
    "counts = {'digits':0,\n",
    "         'vowels':0,\n",
    "         'other':0}\n",
    "\n",
    "s = input(\"Enter a sentence: \").strip()\n",
    "\n",
    "for one_character in s:\n",
    "    if one_character.isdigit():\n",
    "        counts['digits'] += 1\n",
    "    elif one_character in 'aeiou':\n",
    "        counts['vowels'] += 1\n",
    "    else:\n",
    "        counts['other'] += 1\n",
    "        \n",
    "for key, value in counts.items():\n",
    "    print(f'{key}: {value}')"
   ]
  },
  {
   "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}