Week_04.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 10, 15.2, 20]\n"
     ]
    }
   ],
   "source": [
    "# declaring a list of numbers\n",
    "\n",
    "nums = [5, 10, 15.2, 20]\n",
    "\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "15.2\n"
     ]
    }
   ],
   "source": [
    "# accessing elements within a list\n",
    "\n",
    "print(nums[1])          # will output the value at index 1 = 10\n",
    "\n",
    "num = nums[2]            # saves index value 2 into num\n",
    "\n",
    "print(num)              # prints value assigned to num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4.3, 'word', True]\n"
     ]
    }
   ],
   "source": [
    "# declaring a list of mixed data types\n",
    "\n",
    "num = 4.3\n",
    "\n",
    "data = [num, 'word', True]       # the power of data collection\n",
    "\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 'book', [34, 'hello'], True]\n",
      "[34, 'hello']\n"
     ]
    }
   ],
   "source": [
    "# understanding lists within lists\n",
    "\n",
    "data = [5, 'book', [34, 'hello'], True]     # lists can hold any type\n",
    "\n",
    "print(data)\n",
    "\n",
    "print(data[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "# using double bracket notation to access lists within lists\n",
    "\n",
    "print(data[2][0])        # will output 34\n",
    "\n",
    "inner_list = data[2]     # inner list will equal [34, 'hello']\n",
    "\n",
    "print(inner_list[1])     # will output 'hello'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 10, 15, 20]\n",
      "[100, 10, 15, 20]\n"
     ]
    }
   ],
   "source": [
    "# changing values in a list through index\n",
    "\n",
    "data = [5, 10, 15, 20]\n",
    "\n",
    "print(data)\n",
    "\n",
    "data[0] = 100         # change the value at index 0 - (5 to 100)\n",
    "\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: [5, 10]\t b: [5, 10]\n",
      "Location a[0]: 1977642176\t Location b[0]: 1977642176\n",
      "a: [20, 10]\t b: [20, 10]\n"
     ]
    }
   ],
   "source": [
    "# understanding how lists are stored\n",
    "\n",
    "a = [5, 10]\n",
    "\n",
    "b = a\n",
    "\n",
    "print('a: {}\\t b: {}'.format(a, b))\n",
    "\n",
    "print('Location a[0]: {}\\t Location b[0]: {}'.format(id(a[0]), id(b[0])))\n",
    "\n",
    "a[0] = 20              # re-declaring the value of a[0] also changes b[0]\n",
    "\n",
    "print('a: {}\\t b: {}'.format(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data: [50, 10, 15, 20]\t data_copy: [5, 10, 15, 20]\n"
     ]
    }
   ],
   "source": [
    "# using [:] to copy a list\n",
    "\n",
    "data = [5, 10, 15, 20]\n",
    "\n",
    "data_copy = data[:]       # a single colon copies the list\n",
    "\n",
    "data[0] = 50\n",
    "\n",
    "print('data: {}\\t data_copy: {}'.format(data, data_copy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# For Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value: 0\n",
      "Value: 1\n",
      "Value: 2\n",
      "Value: 3\n",
      "Value: 4\n"
     ]
    }
   ],
   "source": [
    "# writing your first for loop using range\n",
    "\n",
    "for num in range(5):\n",
    "    print('Value: {}'.format(num))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value: 2\n",
      "Value: 4\n",
      "Value: 6\n",
      "Value: 8\n"
     ]
    }
   ],
   "source": [
    "# providing the start, stop, and step for the range function\n",
    "\n",
    "for num in range(2, 10, 2):\n",
    "    print('Value: {}'.format(num))    # will print all evens between 2 and 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value: J\n",
      "Value: o\n",
      "Value: h\n",
      "Value: n\n",
      "Value:  \n",
      "Value: S\n",
      "Value: m\n",
      "Value: i\n",
      "Value: t\n",
      "Value: h\n"
     ]
    }
   ],
   "source": [
    "# printing all characters in a name using the 'in' keyword\n",
    "\n",
    "name = 'John Smith'\n",
    "\n",
    "for letter in name:\n",
    "    print('Value: {}'.format(letter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# using the continue statement within a for loop\n",
    "\n",
    "for num in range(5):\n",
    "    if num == 3:\n",
    "        continue\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# breaking out of a loop using the 'break' keyword\n",
    "\n",
    "for num in range(5):\n",
    "    if num == 3:\n",
    "        break\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# setting a placeholder using the 'pass' keyword\n",
    "\n",
    "for i in range(5):\n",
    "    # TODO: add code to print number\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# While Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# writing your first while loop\n",
    "\n",
    "health = 10\n",
    "\n",
    "while health > 0:\n",
    "    print(health)\n",
    "    health -= 1       # forgetting this line will result in infinite loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0\n",
      "0 1\n",
      "0 2\n",
      "1 0\n",
      "1 1\n",
      "1 2\n"
     ]
    }
   ],
   "source": [
    "# using two or more loops together is called a nested loop\n",
    "\n",
    "for i in range(2):    # outside loop\n",
    "    for j in range(3):     # inside loop\n",
    "        print(i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Working with Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "# checking the number of items within a list\n",
    "\n",
    "nums = [5, 10, 15]\n",
    "\n",
    "length = len(nums)        # len() returns an integer\n",
    "\n",
    "print(length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 15]\n",
      "[5, 10]\n",
      "[5, 15]\n",
      "[10, 15]\n"
     ]
    }
   ],
   "source": [
    "# accessing specific items of a list with slices\n",
    "\n",
    "print(nums[1:3])         # will output items in index 1 and 2\n",
    "\n",
    "print(nums[:2])          # will output items in index 0 and 1\n",
    "\n",
    "print(nums[::2])          # will print every other index - 0, 2, 4, etc.\n",
    "\n",
    "print(nums[-2:])          # will output the last two items in list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 5]\n"
     ]
    }
   ],
   "source": [
    "# adding an item to the back of a list using append\n",
    "\n",
    "nums = [10, 20]\n",
    "\n",
    "nums.append(5)\n",
    "\n",
    "print(nums)       # outputs [10, 20, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# adding a value to the beginning of the list\n",
    "\n",
    "words = ['ball', 'base']\n",
    "\n",
    "words.insert(0, 'glove')       # first number is the index, second is the value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 \n",
      " ['ball']\n"
     ]
    }
   ],
   "source": [
    "# using pop to remove items and saving to a variable to use later\n",
    "\n",
    "items = [5, 'ball', True]\n",
    "\n",
    "items.pop()                   # by default removes the last item\n",
    "\n",
    "removed_item = items.pop(0)   # removes 5 and saves it into the variable\n",
    "\n",
    "print(removed_item, '\\n', items)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['baseball', 'football', 'hockey']\n"
     ]
    }
   ],
   "source": [
    "# using the remove method with a try and except\n",
    "\n",
    "sports = ['baseball', 'soccer', 'football', 'hockey']\n",
    "\n",
    "try:\n",
    "    sports.remove('soccer')\n",
    "except:\n",
    "    print('That item does not exist in the list.')\n",
    "    \n",
    "print(sports)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "9\n",
      "17\n"
     ]
    }
   ],
   "source": [
    "# using min, max, and sum\n",
    "\n",
    "nums = [5, 3, 9]\n",
    "\n",
    "print(min(nums))     # will find the lowest number in the list\n",
    "print(max(nums))     # will find the highest number in the list\n",
    "print(sum(nums))     # will add all numbers in the list and return the sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 8, 0, 2] [0, 2, 5, 8]\n"
     ]
    }
   ],
   "source": [
    "# using sorted on lists for numerical and alphabetical data\n",
    "\n",
    "nums = [5, 8, 0, 2]\n",
    "\n",
    "sorted_nums = sorted(nums)      # save to a new variable to use later\n",
    "\n",
    "print(nums, sorted_nums)        # the original list is in tact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 3, 5, 8]\n"
     ]
    }
   ],
   "source": [
    "# sorting a list with .sort() in-place\n",
    "\n",
    "nums = [5, 0, 8, 3]\n",
    "\n",
    "nums.sort()          # alters the original variable directly\n",
    "\n",
    "print(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "found\n",
      "not found\n"
     ]
    }
   ],
   "source": [
    "# using conditional statements on a list\n",
    "\n",
    "names = ['Jack', 'Robert', 'Mary']\n",
    "\n",
    "if 'Mary' in names:\n",
    "    print('found')        # will run since Mary is in the list\n",
    "    \n",
    "if 'Jimmy' not in names:\n",
    "    print('not found')    # will run since Jimmy is not in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "empty\n"
     ]
    }
   ],
   "source": [
    "# using conditionals to see if a list is empty\n",
    "\n",
    "nums = []\n",
    "\n",
    "if not nums:          # could also say 'if nums == []'\n",
    "    print('empty')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Baseball\n",
      "Hockey\n",
      "Football\n",
      "Basketball\n"
     ]
    }
   ],
   "source": [
    "# using a for loop to print all items in a list\n",
    "\n",
    "sports = ['Baseball', 'Hockey', 'Football', 'Basketball']\n",
    "\n",
    "for sport in sports:\n",
    "    print(sport)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Jack', 'Rob', 'Robert']\n"
     ]
    }
   ],
   "source": [
    "# using the while loop to remove a certain value\n",
    "\n",
    "names = ['Bob', 'Jack', 'Rob', 'Bob', 'Robert']\n",
    "\n",
    "while 'Bob' in names:\n",
    "    names.remove('Bob')      # removes all instances of 'Bob'\n",
    "    \n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Friday Project: Creating Hangman"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thanks for playing.\n"
     ]
    }
   ],
   "source": [
    "# import additional functions\n",
    "from random import choice\n",
    "from IPython.display import clear_output\n",
    "\n",
    "# declare game variables\n",
    "words = ['tree', 'basket', 'chair', 'paper', 'python']\n",
    "word = choice(words)\n",
    "guessed, lives, game_over = [], 7, False\n",
    "\n",
    "# create a list of underscores to the length of the word\n",
    "guesses = ['_ '] * len(word)\n",
    "\n",
    "# create main game loop\n",
    "while not game_over:\n",
    "    # output game information\n",
    "    hidden_word = ''.join(guesses)\n",
    "    print('Your guessed letters: {}'.format(guessed))\n",
    "    print('Word to guess: {}'.format(hidden_word))\n",
    "    print('Lives: {}'.format(lives))\n",
    "    \n",
    "    ans = input('Type quit or guess a letter: ').lower()\n",
    "    \n",
    "    clear_output()     # clear all previous output\n",
    "    \n",
    "    if ans == 'quit':\n",
    "        print('Thanks for playing.')\n",
    "        game_over = True\n",
    "    elif ans in word and ans not in guessed:\n",
    "        print('You guessed correctly!')\n",
    "        \n",
    "        # create a loop to change underscore to proper letter\n",
    "        for i in range(len(word)):\n",
    "            if word[i] == ans:\n",
    "                guesses[i] = ans\n",
    "    elif ans in guessed:\n",
    "        print('You already guessed that. Try again.')\n",
    "    else:                 # otherwise lose life\n",
    "        lives -= 1\n",
    "        print('Incorrect, you lost a life.')\n",
    "        \n",
    "    if ans not in guessed:\n",
    "        guessed.append(ans)    # add guess to guessed list\n",
    "        \n",
    "    if lives <= 0:\n",
    "        print('You lost all your lives, you lost!')\n",
    "        game_over = True\n",
    "    elif word == ''.join(guesses):\n",
    "        print('Congratulations, you guessed it correctly!')\n",
    "        game_over = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Monday Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Sports:</b> Define a list of strings, where each string is a sport. Then output each sport with the following line \"I like to play {}\"...\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I like to play baseball.\n",
      "I like to play soccer.\n",
      "I like to play football.\n"
     ]
    }
   ],
   "source": [
    "sports = [ \"baseball\", 'soccer', 'football']\n",
    "\n",
    "print(\"I like to play {}.\".format(sports[0]))\n",
    "print(\"I like to play {}.\".format(sports[1]))\n",
    "print(\"I like to play {}.\".format(sports[2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>First Character:</b> For the following list, print out each item's first letter. (output should be 'J', 'A', 'S', 'K')\n",
    "</p>\n",
    "<p>&nbsp;&nbsp;&nbsp;&nbsp; <i>names = ['John', 'Abraham', 'Sam', 'Kelly']</i></p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "J\n",
      "A\n",
      "S\n",
      "K\n"
     ]
    }
   ],
   "source": [
    "names = [ 'John', 'Abraham', 'Sam', 'Kelly' ]\n",
    "\n",
    "print(names[0][0])\n",
    "print(names[1][0])\n",
    "print(names[2][0])\n",
    "print(names[3][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuesday Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Divisble by Three:</b> Write a for loop that prints out all numbers from 1 to 100 that are divisble by three.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "6\n",
      "9\n",
      "12\n",
      "15\n",
      "18\n",
      "21\n",
      "24\n",
      "27\n",
      "30\n",
      "33\n",
      "36\n",
      "39\n",
      "42\n",
      "45\n",
      "48\n",
      "51\n",
      "54\n",
      "57\n",
      "60\n",
      "63\n",
      "66\n",
      "69\n",
      "72\n",
      "75\n",
      "78\n",
      "81\n",
      "84\n",
      "87\n",
      "90\n",
      "93\n",
      "96\n",
      "99\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 100):\n",
    "    if i % 3 == 0:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>Only Vowels:</b> Ask for user input and write a for loop that will output all the vowels within it. For example:\n",
    "</p>\n",
    "\n",
    "<p>\n",
    ">>> \"Hello\" --> \"eo\"\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: Hello\n",
      "e\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "ans = input(\"Enter a word: \")\n",
    "\n",
    "for letter in ans:\n",
    "    if letter in ['a', 'e', 'i', 'o', 'u']:\n",
    "        print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Wednesday Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>User Input:</b> Write a while loop that continues to ask for user input and runs until they type 'quit'.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter something: asd\n",
      "Enter something: asdf\n",
      "Enter something: adsf\n",
      "Enter something: quit\n"
     ]
    }
   ],
   "source": [
    "while input('Enter something: ').lower() != 'quit':\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>Double Loop:</b> Write a for loop within a while loop that will count from 0 to 5, but when it reaches 3 it sets a game_over variable to True and breaks out of the loop. The while loop should continue to loop until game_over is True. The output should only be 0, 1, 2.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "game_over = False\n",
    "\n",
    "while game_over == False:\n",
    "    for i in range(5):\n",
    "        if i == 3:\n",
    "            game_over = True\n",
    "            break\n",
    "        else:\n",
    "            print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Thursday Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Remove Duplicates:</b> Remove all duplicates from the list below. Hint: Use the .count() method. The output should be [\"Bob\", \"Kenny\", \"Amanda\"]\n",
    "</p>\n",
    "\n",
    "<p>\n",
    ">>> names = [\"Bob\", \"Kenny\", \"Amanda\", \"Bob\", \"Kenny\"]\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Amanda', 'Bob', 'Kenny']\n"
     ]
    }
   ],
   "source": [
    "names = [\"Bob\", \"Kenny\", \"Amanda\", \"Bob\", \"Kenny\"]\n",
    "\n",
    "for name in names:\n",
    "    while names.count(name) > 1:\n",
    "        names.remove(name)\n",
    "        \n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>User Input:</b> Use a while loop to continually ask the user to input a word, until they type 'quit'. Once they type a word in, add it to a list. Once they quit the loop, use a for loop to output all items within the list.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: hello\n",
      "Enter a word: yes\n",
      "Enter a word: quit\n",
      "hello\n",
      "yes\n"
     ]
    }
   ],
   "source": [
    "done = False\n",
    "words = []\n",
    "\n",
    "while done == False:\n",
    "    ans = input('Enter a word: ')\n",
    "    \n",
    "    if ans.lower() == 'quit':\n",
    "        done = True\n",
    "    else:\n",
    "        words.append(ans)\n",
    "        \n",
    "for word in words:\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# End of Week Exercises - Answers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "1. <b>Pyramids:</b> Use a for loop to build a pyramid of x's. It should be modular so that if you loop to 5 or 50, it still creates evenly spaced rows. Hint: Multiply the string 'x' by the row. For example, if you loop to the range of 4, it should produce the following result:\n",
    "</p>\n",
    "\n",
    "<p>\n",
    ">>>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;x <br>\n",
    ">>>&nbsp;&nbsp;&nbsp;&nbsp;x&nbsp;x <br>\n",
    ">>>&nbsp;&nbsp;&nbsp;x&nbsp;x&nbsp;x\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     \n",
      "     x\n",
      "    x x\n",
      "   x x x\n",
      "  x x x x\n"
     ]
    }
   ],
   "source": [
    "row = 5\n",
    "\n",
    "for i in range(row):\n",
    "    print(' ' * (row - i) + ' x' * i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "2. <b>Output Names:</b> Write a loop that will iterate over a list of items and only output items which have letters inside of a string. Take the following list for example, only \"John\" and \"Amanda\" should be output:\n",
    "</p>\n",
    "\n",
    "<p>\n",
    ">>> names = [ \"John\", \" \", \"Amanda\", 5]\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "John\n",
      "Amanda\n"
     ]
    }
   ],
   "source": [
    "names = [ \"John\", \" \", \"Amanda\", 5]\n",
    "\n",
    "for name in names:\n",
    "    if type(name) == str:\n",
    "        if name.strip() != '':\n",
    "            print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "3. <b>Convert Celsius:</b> Given a list of temperatures that are in Celsius, write a loop that iterates over the list and outputs the temperature converted into Fahrenheit. Hint: The conversion is \"F = (9/5) * C + 32\".\n",
    "</p>\n",
    "\n",
    "<p>\n",
    ">>> temps = [32, 12, 44, 29] <br>\n",
    "Output would be [89.6, 53.6, 111.2, 84.2]\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[89.6, 53.6, 111.2, 84.2]\n"
     ]
    }
   ],
   "source": [
    "temps = [32, 12, 44, 29]\n",
    "\n",
    "for i in range(len(temps)):\n",
    "    temps[i] = (9/5) * temps[i] + 32\n",
    "    \n",
    "print(temps)"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}