O'Reilly - 2023-07July-13.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Agenda: Loops, lists, and tuples\n",
    "\n",
    "1. Q&A\n",
    "2. Loops\n",
    "    - What are they?\n",
    "    - `for` loops\n",
    "    - `for` loops a number of times\n",
    "    - `while` loops\n",
    "    - Breaking out of a loop\n",
    "3. Lists\n",
    "    - What are lists?\n",
    "    - How are lists similar to strings?\n",
    "    - How are lists different from strings?\n",
    "    - Looping over lists\n",
    "    - Lists are mutable -- how to add to or remove from a list\n",
    "4. Strings to lists, and back\n",
    "    - Turn a string into a list (with `str.split`)\n",
    "    - Turn a list of strings into a string (with `str.join`)\n",
    "5. Tuples\n",
    "    - What are they? (What do we care?)\n",
    "    - Tuple unpacking, and how great it is"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DRY -- don't repeat yourself!\n",
    "\n",
    "This is one of the most important rules in all of programming. (\"Pragmatic Programmer\" book first told me about it.)\n",
    "\n",
    "If you have some code that repeats itself, several lines in a row, then you should find a way to avoid doing that."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "s = 'abcde'\n",
    "\n",
    "# I want to print all of the characters in the string s\n",
    "print(s[0])\n",
    "print(s[1])\n",
    "print(s[2])\n",
    "print(s[3])\n",
    "print(s[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this does give us the right answer!\n",
    "# but it's a huge violation of the DRY rule\n",
    "\n",
    "# this is where a loop comes in handy -- a loop lets us tell the programming language\n",
    "# that we want to do something multiple times"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# What are `for` loops?\n",
    "\n",
    "- They work on \"iterable\" objects, meaning objects that know how to work in `for` loops\n",
    "- Basically, that means any \"container\" object, which has inside of it other objects\n",
    "- If we iterate over that object, we'll get (in each iteration) a new value\n",
    "- The `for` loop will typically run once for each value we'll get in an object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "s = 'abcde'\n",
    "\n",
    "# we start with the \"for\" keyword\n",
    "# then comes a variable, which we're defining via the \"for\" loop\n",
    "# then we have the \"in\" keyword\n",
    "# then we have the iterable object -- what we're asking for multiple values\n",
    "# then there's a colon, and indentation\n",
    "\n",
    "# the loop body, as it's known, as can be as long as you want\n",
    "# the loop body can contain ANYTHING at all -- if/else, for, print, input, assignment\n",
    "\n",
    "# with each iteration, the \"for\" loop asks the object for its next value\n",
    "# that value is assigned to the loop variable (here, one_character)\n",
    "# we then execute the loop body with the loop variable assigned to an element of our object\n",
    "\n",
    "# at some point, the for loop turns to the object and asks for the next item\n",
    "# the object says: No more! I'm done!\n",
    "# at that point, we exit from the loop\n",
    "\n",
    "# we don't need an index, because we get the values\n",
    "# how do we get one character at a time from s? Is it because we called our variable one_character?\n",
    "#   NO NO NO NO NO!\n",
    "#   strings always return one character at a time when you iterate over them\n",
    "#   I chose the variable name one_character because I thought it made the program easier to read/maintain\n",
    "\n",
    "for one_character in s:\n",
    "    print(one_character)         "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise: Vowels, digits, and others\n",
    "\n",
    "1. Define three variables: `vowels`, `digits`, and `others`, all set to 0.\n",
    "2. Ask the user to enter a string.\n",
    "3. Go through the string, one character at a time. For each character, determine:\n",
    "    - Is it a vowel? If so, add 1 to `vowels`\n",
    "    - Is it a digit? If so, add 1 to `digits`\n",
    "    - In all other cases, add 1 to `others`.\n",
    "4. Print the values of all variables.\n",
    "\n",
    "Example:\n",
    "\n",
    "    Enter a string: hello123 !!\n",
    "    vowels: 2\n",
    "    digits: 3\n",
    "    others: 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  hello123 !!\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vowels = 2\n",
      "digits = 3\n",
      "others = 6\n"
     ]
    }
   ],
   "source": [
    "vowels = 0\n",
    "digits = 0\n",
    "others = 0\n",
    "\n",
    "s = input('Enter a string: ').strip()    # get input from the user, then remove leading/trailing whitespace, then assign to s\n",
    "\n",
    "for one_character in s:\n",
    "    if one_character in 'aeiou':     # is the character a vowel?\n",
    "        vowels += 1\n",
    "    elif one_character.isdigit():    # is the character a digit?\n",
    "        digits += 1\n",
    "    else:\n",
    "        others += 1\n",
    "\n",
    "print(f'vowels = {vowels}')\n",
    "print(f'digits = {digits}')\n",
    "print(f'others = {others}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Special characters\n",
    "\n",
    "Normally, a string contains characters that are printed in an obvious way. \"a\" will be printed as \"a\" and \"!\" will be printed as \"!\".\n",
    "\n",
    "But sometimes, we want to print special values. And for those, we need to put a combination of characters in our string. These special characters are normally written in our string starting with `\\` and then one or more other characters. Some common ones:\n",
    "\n",
    "- `\\n` -- newline\n",
    "- `\\t` -- tab\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd\n",
      "efgh\n"
     ]
    }
   ],
   "source": [
    "print('abcd\\nefgh')   # \\n is one character, written as two, that adds a newline to the print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = '     a     b      c    '\n",
    "\n",
    "len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a     b      c'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.strip()   # how many characters will be left now?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# strip removes whitespace (spaces, \\n, \\t, \\r, \\v) from the EDGES of the string, \n",
    "# not from the middle of it\n",
    "\n",
    "len(s.strip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "105"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# += means: + and then assign\n",
    "\n",
    "x = 100\n",
    "x = x + 5   # this evaluates to x = 105, which then assigns\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "105"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# exactly the same thing to say:\n",
    "\n",
    "x = 100\n",
    "x += 5\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  HELLO123 !!\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vowels = 2\n",
      "digits = 3\n",
      "others = 6\n"
     ]
    }
   ],
   "source": [
    "# improved version, handling capital letters (vowels), too:\n",
    "\n",
    "vowels = 0\n",
    "digits = 0\n",
    "others = 0\n",
    "\n",
    "s = input('Enter a string: ').strip()    # get input from the user, then remove leading/trailing whitespace, then assign to s\n",
    "\n",
    "for one_character in s.lower():      # check all characters lowercase, so A and a are both considered vowels\n",
    "    if one_character in 'aeiou':     # is the character a vowel?\n",
    "        vowels += 1\n",
    "    elif one_character.isdigit():    # is the character a digit?\n",
    "        digits += 1\n",
    "    else:\n",
    "        others += 1\n",
    "\n",
    "print(f'vowels = {vowels}')\n",
    "print(f'digits = {digits}')\n",
    "print(f'others = {others}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "105"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# BH says: I wrote =+ instead of +=\n",
    "# Python won't stop you from writing this.. it just won't do what you want\n",
    "\n",
    "x = 100\n",
    "x += 5   # this means: x = x + 5\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 100\n",
    "x =+ 5   # what does this mean?   it basically means x = 5\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 100  # I have now assigned the int value 100 to the variable x\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "101"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = x + 1   # now I've \"incremented\" x, taking its current value, adding 1 to it, and asisgning that back to x\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "102"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x += 1\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  hello123 !!\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\t\"h\" is other\n",
      "\t\"e\" is a vowel\n",
      "\t\"l\" is other\n",
      "\t\"l\" is other\n",
      "\t\"o\" is a vowel\n",
      "\t\"1\" is a digit\n",
      "\t\"2\" is a digit\n",
      "\t\"3\" is a digit\n",
      "\t\" \" is other\n",
      "\t\"!\" is other\n",
      "\t\"!\" is other\n",
      "vowels = 2\n",
      "digits = 3\n",
      "others = 6\n"
     ]
    }
   ],
   "source": [
    "# improved version, handling capital letters (vowels), too:\n",
    "\n",
    "vowels = 0\n",
    "digits = 0\n",
    "others = 0\n",
    "\n",
    "s = input('Enter a string: ').strip()    # get input from the user, then remove leading/trailing whitespace, then assign to s\n",
    "\n",
    "for one_character in s.lower():      # check all characters lowercase, so A and a are both considered vowels\n",
    "    if one_character in 'aeiou':     # is the character a vowel?\n",
    "        print(f'\\t\"{one_character}\" is a vowel')\n",
    "        vowels += 1\n",
    "    elif one_character.isdigit():    # is the character a digit?\n",
    "        print(f'\\t\"{one_character}\" is a digit')\n",
    "        digits += 1\n",
    "    else:\n",
    "        others += 1\n",
    "        print(f'\\t\"{one_character}\" is other')\n",
    "        \n",
    "\n",
    "print(f'vowels = {vowels}')\n",
    "print(f'digits = {digits}')\n",
    "print(f'others = {others}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hooray!\n",
      "Hooray!\n",
      "Hooray!\n"
     ]
    }
   ],
   "source": [
    "# what if I'm in a really great mood (because I'm teaching Python) I want to say that in Python!\n",
    "\n",
    "print('Hooray!')\n",
    "print('Hooray!')\n",
    "print('Hooray!')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[22], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# I realize that I've violated the DRY rule, and I decide to use a \"for\" loop\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;241m3\u001b[39m:\n\u001b[1;32m      4\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mHooray!\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
     ]
    }
   ],
   "source": [
    "# I realize that I've violated the DRY rule, and I decide to use a \"for\" loop\n",
    "\n",
    "for i in 3:\n",
    "    print('Hooray!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Integers aren't iterable!\n",
    "\n",
    "If you want to iterate a certain number of times, you cannot do it directly on an integer.\n",
    "\n",
    "Instead, you need to use the `range` function, which takes an integer as an argument, and then lets you iterate that number of times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Hooray!\n",
      "1 Hooray!\n",
      "2 Hooray!\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(f'{i} Hooray!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# wait... what is the value of i in each iteration?\n",
    "\n",
    "# when you iterate over range(n), you'll get integers starting at 0, going up by 1, \n",
    "# until (and not including) the n you chose."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise: Name triangles\n",
    "\n",
    "1. Ask the user to enter their name.\n",
    "2. Print the name in a triangle, such that:\n",
    "    - The first line prints the name's first letter\n",
    "    - The second line prints the name's first 2 letters\n",
    "    - The third line prints the name's first 3 letters\n",
    "    - ...\n",
    "    - The final line prints the entire name\n",
    "  \n",
    "Example:\n",
    "\n",
    "    Enter your name: Reuven\n",
    "    R\n",
    "    Re\n",
    "    Reu\n",
    "    Reuv\n",
    "    Reuve\n",
    "    Reuven\n",
    "\n",
    "Some things to remember:\n",
    "- You can get the length of a string with `len`\n",
    "- You can get a slice (substring) of characters in a string with `[start:end]`\n",
    "- `range` works up to and not including the number you specified, starting with 0\n",
    "- While `[]` normally only let you choose an element up to `len(s) - 1`, if you're using a slice, then the boundaries are not checked."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R\n",
      "Re\n",
      "Reu\n",
      "Reuv\n",
      "Reuve\n",
      "Reuven\n"
     ]
    }
   ],
   "source": [
    "# let's start without a for loop\n",
    "\n",
    "name = 'Reuven'\n",
    "\n",
    "print(name[:1])\n",
    "print(name[:2])\n",
    "print(name[:3])\n",
    "print(name[:4])\n",
    "print(name[:5])\n",
    "print(name[:6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "R\n",
      "Re\n",
      "Reu\n",
      "Reuv\n",
      "Reuve\n"
     ]
    }
   ],
   "source": [
    "# almost, but not quite\n",
    "for end_index in range(6):\n",
    "    print(name[:end_index])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R\n",
      "Re\n",
      "Reu\n",
      "Reuv\n",
      "Reuve\n",
      "Reuven\n"
     ]
    }
   ],
   "source": [
    "# off-by-one error -- a famous type of error!\n",
    "# let's fix it\n",
    "\n",
    "for end_index in range(6):\n",
    "    print(name[:end_index+1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your name:  thisisaverylongandsillyname\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t\n",
      "th\n",
      "thi\n",
      "this\n",
      "thisi\n",
      "thisis\n",
      "thisisa\n",
      "thisisav\n",
      "thisisave\n",
      "thisisaver\n",
      "thisisavery\n",
      "thisisaveryl\n",
      "thisisaverylo\n",
      "thisisaverylon\n",
      "thisisaverylong\n",
      "thisisaverylonga\n",
      "thisisaverylongan\n",
      "thisisaverylongand\n",
      "thisisaverylongands\n",
      "thisisaverylongandsi\n",
      "thisisaverylongandsil\n",
      "thisisaverylongandsill\n",
      "thisisaverylongandsilly\n",
      "thisisaverylongandsillyn\n",
      "thisisaverylongandsillyna\n",
      "thisisaverylongandsillynam\n",
      "thisisaverylongandsillyname\n"
     ]
    }
   ],
   "source": [
    "name = input('Enter your name: ').strip()\n",
    "\n",
    "for end_index in range(len(name)):\n",
    "    print(name[:end_index+1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d\n",
      "c\n",
      "b\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "# how can I print a string, one charater at a time, *backwards*?\n",
    "# two possiblities that are similar\n",
    "\n",
    "# option 1: reverse the string, and iterate over it\n",
    "# we can reverse a string by using a slice INCLUDING the third, optional number -- the step size\n",
    "# s[2:10:2]  -- from index 2, until (not including) index 10, step size 2\n",
    "# s[::2]  -- from  start to end, step size 2\n",
    "# s[::-1]  -- from  start to end, step size -1 -- meaning, reversed\n",
    "\n",
    "s = 'abcd'\n",
    "for one_character in s[::-1]: # now we'll print the characters in s reversed\n",
    "    print(one_character)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'abcd'   # indexes 0-1-2-3\n",
    "\n",
    "s[:3]        # up to, but not including, index 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcd'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:3+1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# other option is similar: give range two more (optional) arguments: the end number and the step size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Next up\n",
    "\n",
    "- `while` loops\n",
    "- Where's the index? How can we compensate?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `while` loops\n",
    "\n",
    "Whereas a `for` loop goes through each element of a string/range and does the same action on it, until we reach the end, a `while` loop keeps executing the loop body so long as a condition is `True`.\n",
    "\n",
    "This is very similar to an `if` statement, except that it repeats checking the condition.  Only when the condition is `False` does the `while` loop exit.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "\n",
    "while x > 0:   # so long as x is > 0...\n",
    "    print(x)\n",
    "    x -= 1     # x = x - 1   or: take 1 away from x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Warning!\n",
    "\n",
    "What if the condition is *always* `True`?\n",
    "\n",
    "You have an infinite loop!  Be careful with your condition, and make sure that something is changing regarding the condition across iterations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise: Sum to 100\n",
    "\n",
    "1. Define `total` to be 0\n",
    "2. Using a `while` loop, ask the user to enter a number.\n",
    "3. (If you want, you can check that they entered an actual number.)\n",
    "4. Add that number to `total`, and print the current value of `total`.\n",
    "5. If we have reached 100 or more, stop.  (Note: This condition will be at the top of the `while` loop, not the bottom.)\n",
    "\n",
    "Example:\n",
    "\n",
    "    Enter a number: 10\n",
    "    10\n",
    "    Enter a number: 30\n",
    "    40\n",
    "    Enter a number: 50\n",
    "    90\n",
    "    Enter a number: 30\n",
    "    120\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  50\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tCurrently, total is 50\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  20\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tCurrently, total is 70\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  -10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tCurrently, total is 60\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  30\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tCurrently, total is 90\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  5\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tCurrently, total is 95\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  15\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tCurrently, total is 110\n",
      "Final total = 110\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "\n",
    "while total < 100:\n",
    "    s = input('Enter a number: ').strip()\n",
    "    n = int(s)   # get an integer based on the user's input\n",
    "    total += n\n",
    "    print(f'\\tCurrently, total is {total}')\n",
    "\n",
    "print(f'Final total = {total}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number 10\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[42], line 6\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m total \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m100\u001b[39m:\n\u001b[1;32m      5\u001b[0m     num \u001b[38;5;241m=\u001b[39m \u001b[38;5;28minput\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEnter a number\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m----> 6\u001b[0m     total \u001b[38;5;241m=\u001b[39m \u001b[43mtotal\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mnum\u001b[49m\n\u001b[1;32m      7\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mo valor é \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtotal\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "# AL\n",
    "total = 0\n",
    "\n",
    "while total < 100:\n",
    "    num = input(\"Enter a number\")\n",
    "    total = total + int(num)\n",
    "    print(f\"o valor é {total}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  30\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tCurrently, total is 30\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  40\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tCurrently, total is 70\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number:  hello\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final total = 70\n"
     ]
    }
   ],
   "source": [
    "# let's implement the same thing\n",
    "# BUT we'll stop the loop either if we reach 100 or if the user enters a non-digit\n",
    "\n",
    "total = 0\n",
    "\n",
    "while total < 100:\n",
    "    s = input('Enter a number: ').strip()\n",
    "\n",
    "    if not s.isdigit():   # does the user's string NOT contain only digits?\n",
    "        print(f'Non-numeric input; exiting the loop')\n",
    "        break             # this means: exit the loop RIGHT AWAY, NOW\n",
    "    \n",
    "    n = int(s)   # get an integer based on the user's input\n",
    "    total += n\n",
    "    print(f'\\tCurrently, total is {total}')\n",
    "\n",
    "print(f'Final total = {total}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your name:  Reuven\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Reuven.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your name:  world\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your name:  out there\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, out there.\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your name:  \n"
     ]
    }
   ],
   "source": [
    "while True:    # notice -- an infinite loop!\n",
    "    name = input('Enter your name: ').strip()\n",
    "\n",
    "    if name == '':\n",
    "        break\n",
    "\n",
    "    print(f'Hello, {name}.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number 20\n",
      "Enter a number 40\n",
      "Enter a number 60\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o valor é 120\n"
     ]
    }
   ],
   "source": [
    "# AL\n",
    "total = 0\n",
    "\n",
    "while total < 100:\n",
    "    num = input(\"Enter a number\")\n",
    "    total = total + int(num)\n",
    "print(f\"o valor é {total}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# why not negative numbers?\n",
    "# if we use .isdigit(), then it only returns True for non-empty strings containing ONLY 0-9\n",
    "# if you want to really check for numbers, you need to use a different technique"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Where's the index?\n",
    "\n",
    "In other programming languages, the `for` loop is in charge of itself. Meaning: It typically goes through a bunch of numeric indexes, and then uses those indexes to retrieve values at different locations.\n",
    "\n",
    "In Python, the `for` loop is actually quite dumb and passive. It doesn't know how many values it'll get, or what types of values it'll get. The object on which we're running the loop determines these.\n",
    "\n",
    "Strings are defined to give us one character at a time, from the start until the end.\n",
    "\n",
    "Different data structures have different rules in for loops for what they return.\n",
    "\n",
    "Other languages need the index, because they cannot rely on the objects to give us something new and useful each time. Python can, so we don't need the index...\n",
    "\n",
    "... except when we do.\n",
    "\n",
    "There are definitely times when we want to have an index around. There are two ways to do that:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: a\n",
      "1: b\n",
      "2: c\n",
      "3: d\n"
     ]
    }
   ],
   "source": [
    "# option 1: Use an \"index\" variable that we keep track of\n",
    "\n",
    "index = 0\n",
    "\n",
    "for one_character in 'abcd':\n",
    "    print(f'{index}: {one_character}')\n",
    "    index += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: a\n",
      "1: b\n",
      "2: c\n",
      "3: d\n"
     ]
    }
   ],
   "source": [
    "# option 2: Use the \"enumerate\" function that comes with Python\n",
    "# enumerate wraps itself around an iterable object (e.g., a string)\n",
    "# and it returns TWO things with each iteration -- an index, and a value\n",
    "\n",
    "for index, one_character in enumerate('abcd'):\n",
    "    print(f'{index}: {one_character}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number 20\n",
      "Enter a number 50\n",
      "Enter a number 70\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o valor é 140\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "\n",
    "while total < 100:\n",
    "    num = input(\"Enter a number\")\n",
    "    total = total + int(num)\n",
    "print(f\"o valor é {total}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control of our loops\n",
    "\n",
    "We earlier saw that we can use `break` to stop a loop right away, continuing with the code after the loop's end.\n",
    "\n",
    "There's another control statement called `continue`, which immediately goes to the next *iteration*, but doesn't exit the loop.  This is especially useful if there are common values you want to ignore/throw out in your `for` loop. This way, you can have a quick `if`/`continue` at the top of the loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise: Sum digits\n",
    "\n",
    "1. Define `total` to be 0.\n",
    "2. Ask the user, repeatedly, to enter a string.  You should stop asking if/when `total` is >= 40.\n",
    "3. Go through the user's string, one charater at a time. (Yes, this means having a `for` loop inside of a `while` loop!)\n",
    "    - If a character is a non-digit, then `continue` onto the next iteration (i.e., the next character)\n",
    "    - If a character is a digit, then turn it into an int, and add it to `total`.\n",
    "  \n",
    "Example:\n",
    "\n",
    "    Enter a string containing digits: 12345\n",
    "    Current value is 15\n",
    "    Enter a string containing digits: a1b2c3\n",
    "    Enter a string containing digits: 9999\n",
    "    Current value is 51  [EXITS]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  12345\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total = 15\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  2a3b\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\ta is not a digit\n",
      "\tb is not a digit\n",
      "total = 20\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  9876\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total = 50\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "\n",
    "while total < 40:   # only ask the user for input so long as total is <40\n",
    "    s = input('Enter a string: ').strip()\n",
    "\n",
    "    for one_character in s:\n",
    "        if not one_character.isdigit():\n",
    "            print(f'\\t{one_character} is not a digit')\n",
    "            continue\n",
    "\n",
    "        total += int(one_character)   # get an integer based on one_character, and add to total\n",
    "\n",
    "    print(f'total = {total}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a number 20\n",
      "Enter a number 30\n",
      "Enter a number 80\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o valor é 130\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "\n",
    "while total < 100:\n",
    "    num = input(\"Enter a number\")\n",
    "    total = total + int(num)\n",
    "\n",
    "print(f\"o valor é {total}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  2345\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total = 14\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  2a2b3c\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\ta is not a digit\n",
      "total = 21\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  9\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total = 30\n"
     ]
    },
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  98\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total = 47\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "\n",
    "while total < 40:   # only ask the user for input so long as total is <40\n",
    "    s = input('Enter a string: ').strip()\n",
    "\n",
    "    already_warned = False\n",
    "    for one_character in s:\n",
    "\n",
    "        if not one_character.isdigit():\n",
    "            if not already_warned:\n",
    "                already_warned = True\n",
    "                print(f'\\t{one_character} is not a digit')\n",
    "            continue\n",
    "\n",
    "        total += int(one_character)   # get an integer based on one_character, and add to total\n",
    "\n",
    "    print(f'total = {total}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Done!\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "\n",
    "while total >= 40:\n",
    "     s = input('enter a number: ').strip()\n",
    "     for one_character in s:\n",
    "         if not one_character.isdigit():\n",
    "             print(f'\\t{one_character} is a not a digit')\n",
    "             continue\n",
    " \n",
    "         total += int(one_character)\n",
    "     print(f'total = {total}')\n",
    "\n",
    "print('Done!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Next up:\n",
    "\n",
    "1. Lists! What are they, and how can we create them (and use them)?\n",
    "2. Strings to lists, and back"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists\n",
    "\n",
    "So far, we've seen that strings contain characters. This is great for searching, storing, etc. charactres.\n",
    "\n",
    "But it's pretty restrictive. We want to store other kinds of things, such as integers. We might even want to modify the values along the way. (Remember, strings cannot be modified -- they are \"immutable.\")\n",
    "\n",
    "For that, we have *lists*. Many people who come from other languages think that they should call lists \"arrays.\" But they aren't arrays!\n",
    "\n",
    "A technical definition of lists would be something like, \"An ordered, mutable collection of objects of any type.\"\n",
    "\n",
    "You can put *anything* inside of a list. And it's considered traditional to put only one type of value in a list, but Python won't stop you from mixing them up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here is how I define a list:\n",
    "# I use []\n",
    "# I separate the elements with ,\n",
    "\n",
    "mylist = [10, 20, 30, 40, 50] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(mylist)  # what kind of data structure is this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lists have many things in common with strings\n",
    "# how many elements are there?\n",
    "len(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# I want the first element - -it's at index 0\n",
    "mylist[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[20, 30]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# I can get a slice\n",
    "mylist[1:3]   # from index 1, until (not including) index 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "# I can run a for loop on a list, getting each element, one at a time\n",
    "\n",
    "for one_item in mylist:\n",
    "    print(one_item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# snake_case is the standard for ALL VARIABLES in Python, regardless of data type\n",
    "my_favorite_list = [10, 20, 30]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 * 3 = 30\n",
      "20 * 3 = 60\n",
      "30 * 3 = 90\n",
      "40 * 3 = 120\n",
      "50 * 3 = 150\n"
     ]
    }
   ],
   "source": [
    "# lists are different... we can store integers in them\n",
    "\n",
    "for one_item in mylist:\n",
    "    print(f'{one_item} * 3 = {one_item*3}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# can I have a list inside of another list? YES!\n",
    "\n",
    "mylist = [10, 20, 30]\n",
    "biglist = [mylist, mylist, mylist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30]"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[10, 20, 30], [10, 20, 30], [10, 20, 30]]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biglist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# what is the len of biglist?\n",
    "len(biglist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# can I change a string? (No)\n",
    "\n",
    "s = 'abcde'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[75], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43ms\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m!\u001b[39m\u001b[38;5;124m'\u001b[39m   \u001b[38;5;66;03m# can I do this?\u001b[39;00m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "s[0] = '!'   # can I do this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "# what about our lists?\n",
    "\n",
    "mylist[0] = '!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['!', 20, 30]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['!', 20, 30], ['!', 20, 30], ['!', 20, 30]]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biglist  # which we defined earlier to be [mylist, mylist, mylist]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# We can modify a list's size, too!\n",
    "\n",
    "So far, we've seen that we can modify an existing value in a list.\n",
    "Can we add to the number of elements in a list? Yes, using the `list.append` method, which adds an element to the end of the list.\n",
    "\n",
    "We can remove the final element of a list with `list.pop`. This removes and returns whatever was at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [10, 20, 30]\n",
    "mylist.append(40)\n",
    "mylist.append(50)\n",
    "\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# what if I try to add multiple things at once?\n",
    "\n",
    "mylist.append([100, 200, 300])  # this will work poorly!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50, [100, 200, 300]]"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[100, 200, 300]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# how can we get rid of what we just added?\n",
    "\n",
    "mylist.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50, 60, 70]"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# is there a way for us to add more than one thing at a time?\n",
    "# answer: Yes, use += \n",
    "\n",
    "mylist = [10, 20, 30]\n",
    "mylist += [40, 50, 60, 70]  # += basically runs a for loop on the list, adding each element to the end of mylist\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [1,2,3,'Two','Twelve']\n",
    "\n",
    "mylist[1:3]  # this means: from index 1 until (not including) index 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise: Vowels, digits, and others -- list version\n",
    "\n",
    "1. Define three empty lists (i.e., just `[]` with nothing in them)\n",
    "2. Ask the user to enter a string.\n",
    "3. Go through each character in the string, deciding:\n",
    "    - Is it a vowel? If so, append it to `vowels`\n",
    "    - Is a digit? If so, append it to `digits`\n",
    "    - Is it neither, then append it others\n",
    "At the end, print the lists, containing the characters from our user's input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a string:  hello 123 !!\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vowels = ['e', 'o']\n",
      "digits = ['1', '2', '3']\n",
      "others = ['h', 'l', 'l', ' ', ' ', '!', '!']\n"
     ]
    }
   ],
   "source": [
    "vowels = []\n",
    "digits = []\n",
    "others = []\n",
    "\n",
    "s = input('Enter a string: ').strip()\n",
    "\n",
    "for one_character in s:\n",
    "    if one_character in 'aeiou':\n",
    "        vowels.append(one_character)\n",
    "    elif one_character.isdigit():\n",
    "        digits.append(one_character)\n",
    "    else:\n",
    "        others.append(one_character)\n",
    "\n",
    "print(f'vowels = {vowels}')\n",
    "print(f'digits = {digits}')\n",
    "print(f'others = {others}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's say I want to add to a list\n",
    "\n",
    "mylist = [10, 20, 30]\n",
    "mylist.append(40)   # this is the right way!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "mylist = mylist.append(50)   # this is the WRONG way! You will erase your list this way!\n",
    "\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise: Big and small\n",
    "\n",
    "1. Define two empty lists, big and small\n",
    "2. Ask the user to enter a numeric threshold, into the variable `threshold`.\n",
    "3. Ask the user to enter, one by one, integers.\n",
    "    - If they enter an empty string, stop asking and just show `big` and `small`.\n",
    "    - If they enter non-digits, scold them a bit\n",
    "    - If they enter a number, check if it's larger than the threshold. If so, the number goes into `big`. Otherwise, it goes into `small`.\n",
    "4. Print `big` and `small`.\n",
    "\n",
    "Example: \n",
    "\n",
    "    Enter a threshold: 5\n",
    "    Enter a number: 3   \n",
    "    Enter a number: 22 \n",
    "    Enter a number: 2\n",
    "    Enter a number: 8\n",
    "    Enter a number: [ENTER]\n",
    "    big: [22, 8]\n",
    "    small: [3, 2]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter threshold:  10\n",
      "Enter a number:  2\n",
      "Enter a number:  20\n",
      "Enter a number:  5\n",
      "Enter a number:  16\n",
      "Enter a number:  80\n",
      "Enter a number:  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20, 16, 80]\n",
      "[2, 5]\n"
     ]
    }
   ],
   "source": [
    "big = []\n",
    "small = []\n",
    "\n",
    "threshold = int(input('Enter threshold: ').strip())\n",
    "\n",
    "while True:    # potentially dangerous -- better make sure we have an escape hatch\n",
    "    s = input('Enter a number: ').strip()\n",
    "\n",
    "    if s == '':   # empty string? Exit the loop!\n",
    "        break\n",
    "\n",
    "    if not s.isdigit():    # non-digit? Go get more input from the user\n",
    "        print(f'Not digits only; try again')\n",
    "        continue\n",
    "\n",
    "    n = int(s)\n",
    "\n",
    "    if n > threshold:\n",
    "        big.append(n)\n",
    "    else:\n",
    "        small.append(n)\n",
    "\n",
    "print(big)\n",
    "print(small)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Next up\n",
    "\n",
    "- Joining and splitting\n",
    "- Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abcd', 'ef', 'ghi']"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's assume that we have a string that looks like this:\n",
    "\n",
    "s = 'abcd:ef:ghi'\n",
    "\n",
    "# we see not just a bunch of characters, but also three \"fields\" in this string\n",
    "\n",
    "# how can we turn this string into a list of those fields?\n",
    "\n",
    "# answer: the \"str.split\" method, a string method that always returns a list of strings.\n",
    "\n",
    "# we also have to specify what character(s) should be seen as the field separator\n",
    "\n",
    "s.split(':')   # this returns a new list of strings, and does NOT modify s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc', ':ef:ghi']"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# I could say:\n",
    "\n",
    "s.split('d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abcd', 'ef', '', 'ghi']"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'abcd,ef,,ghi'\n",
    "\n",
    "s.split(',')  # this is pretty common"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this', 'is', 'a', 'bunch', 'of', 'words', 'for', 'my', 'Python', 'class']"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# what about words in a sentence?\n",
    "\n",
    "s = 'this is a bunch of words for my Python class'\n",
    "\n",
    "s.split(' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this',\n",
       " 'is',\n",
       " '',\n",
       " '',\n",
       " '',\n",
       " 'a',\n",
       " 'bunch',\n",
       " '',\n",
       " 'of',\n",
       " 'words',\n",
       " '',\n",
       " '',\n",
       " '',\n",
       " 'for',\n",
       " 'my',\n",
       " '',\n",
       " '',\n",
       " '',\n",
       " '',\n",
       " 'Python',\n",
       " 'class']"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# what about this:\n",
    "\n",
    "s = 'this is    a bunch  of words    for my     Python class'\n",
    "\n",
    "s.split(' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this', 'is', 'a', 'bunch', 'of', 'words', 'for', 'my', 'Python', 'class']"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we can avoid this problem by splitting without an argument\n",
    "\n",
    "# that forces split to use all whitespace (space, \\n, \\r, \\t, \\v) \n",
    "# of any length\n",
    "\n",
    "mylist = s.split()  # this is the best and easiest way!\n",
    "mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise: Summing numbers\n",
    "\n",
    "1. Define `total` to be 0.\n",
    "2. Ask the user to enter a string containing integers separated by spaces.\n",
    "3. Go through each of the numbers in the string, one by one. If it's not numeric, ignore it/scold the user.\n",
    "4. If it is numeric, then add to `total`.\n",
    "5. Print `total`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter some numbers:  10 twenty 30\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hey! twenty is not numeric; ignoring\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "\n",
    "s = input('Enter some numbers: ').strip()\n",
    "\n",
    "for one_number in s.split():\n",
    "    if one_number.isdigit():\n",
    "        total += int(one_number)\n",
    "    else:\n",
    "        print(f'Hey! {one_number} is not numeric; ignoring')\n",
    "\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Joining with `str.join`\n",
    "\n",
    "What happens if you have a list of strings, and you want to turn them into a single string.\n",
    "\n",
    "Example:  If I have `mylist = ['abcd', 'ef', 'ghi']` as a list of strings, I can join it together, putting spaces between the elements, with \n",
    "\n",
    "#   glue\n",
    "    ' '.join(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcd ef ghi'"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = ['abcd', 'ef', 'ghi']\n",
    "' '.join(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "sequence item 0: expected str instance, int found",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[104], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# has to be a list of strings!\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m \u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mjoin\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m20\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m30\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: sequence item 0: expected str instance, int found"
     ]
    }
   ],
   "source": [
    "# has to be a list of strings!\n",
    "\n",
    "' '.join([10, 20, 30])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise: Pig Latin Sentence\n",
    "\n",
    "Last week, we wrote a program that takes a single word from the user, and translates it into Pig Latin. This week, we'll be going one step further, allowing us to translate entire sentences. (All lowercase, no punctuation.)\n",
    "\n",
    "Last week's code was:\n",
    "\n",
    "```python\n",
    "word = input('Enter a word: ').strip()\n",
    "\n",
    "if word[0] in 'aeiou':\n",
    "    print(word + 'way')\n",
    "else:\n",
    "    print(word[1:] + word[0] + 'ay')\n",
    "```\n",
    "\n",
    "now we want to do the same for an entire sentence:\n",
    "\n",
    "1. Ask the user to enter a sentece.\n",
    "2. Translate the words in the sentence into Pig Latin.\n",
    "3. Produce the final, translated version on a single line.  (Consider a list of words that you can then `join`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter a sentence:  this is a test hippo walrus\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "histay isway away esttay ippohay alrusway\n"
     ]
    }
   ],
   "source": [
    "sentence = input('Enter a sentence: ').strip()\n",
    "output = []\n",
    "\n",
    "for word in sentence.split():\n",
    "    if word[0] in 'aeiou':\n",
    "        output.append(word + 'way')\n",
    "    else:\n",
    "        output.append(word[1:] + word[0] + 'ay')\n",
    "\n",
    "print(' '.join(output))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples\n",
    "\n",
    "- Strings are immutable, and contain only characters.\n",
    "- Lists are mutable, and can contain anything.\n",
    "- Tuples are immutable, and can contain anything.\n",
    "\n",
    "Tuples are the third (and final) part of the \"sequence\" family in Python.\n",
    "\n",
    "All three types share a lot of functionality:\n",
    "\n",
    "- `len(x)` returns their length\n",
    "- Use `[]` to retrieve one item\n",
    "- Use `[]` to retrieve a slic\n",
    "- Use a `for` loop to iterate over the elementse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's define some tuples!\n",
    "# we use round parentheses and commas to create a tuple\n",
    "\n",
    "t = (10, 20, 30, 40, 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[111], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mt\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m!\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t[0]= '!'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30]\n"
     ]
    }
   ],
   "source": [
    "# Tuple unpacking\n",
    "\n",
    "mylist = [10, 20, 30]\n",
    "\n",
    "x = mylist\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y,z = mylist   # what happens now?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this works because the number of elements in mylist is the SAME as the number of variables on the left.\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# where do people use tuple unpacking?\n",
    "\n",
    "x = 10\n",
    "y = 20\n",
    "\n",
    "# swap the variables \n",
    "x,y = y,x\n",
    "\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0, a\n",
      "1, b\n",
      "2, c\n",
      "3, d\n"
     ]
    }
   ],
   "source": [
    "# here's an example of unpacking\n",
    "\n",
    "s = 'abcd'\n",
    "for index, one_character in enumerate(s):\n",
    "    print(f'{index}, {one_character}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'a')\n",
      "(1, 'b')\n",
      "(2, 'c')\n",
      "(3, 'd')\n"
     ]
    }
   ],
   "source": [
    "for t in enumerate(s):\n",
    "    print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}