First steps day 2, January 13.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "babebf2b",
   "metadata": {},
   "source": [
    "# Loops, lists and tuples\n",
    "\n",
    "1. What are loops?\n",
    "    - `for` loops\n",
    "    - `while` loops\n",
    "    - Breaking out of loops early\n",
    "    - Looping a certain number of times\n",
    "2. Lists\n",
    "    - Lists as a data type\n",
    "    - What are lists -- similarities and differences with strings\n",
    "    - Mutable data with lists\n",
    "    - How can we change lists?\n",
    "3. Strings to lists, and back\n",
    "    - Splitting strings into lists\n",
    "    - Joining lists back into strings\n",
    "4. Tuples\n",
    "    - What the heck are they?\n",
    "    - What are they used for?\n",
    "    - Tuple unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d66d25b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'abcd'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2217c42",
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = 'I am s1'\n",
    "s2 = 'I am s2'\n",
    "\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62ab68ed",
   "metadata": {},
   "source": [
    "# DRY rule -- Don't Repeat Yourself!\n",
    "\n",
    "A key rule in programming! (Pragmatic Programmers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0af1a1ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n"
     ]
    }
   ],
   "source": [
    "# I want to print all of the elements of s\n",
    "\n",
    "s = 'abcd'\n",
    "\n",
    "# unfortunately, this works!\n",
    "print(s[0])\n",
    "print(s[1])\n",
    "print(s[2])\n",
    "print(s[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3182bba4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before\n",
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "After\n"
     ]
    }
   ],
   "source": [
    "# DRY up this code with a *loop*\n",
    "\n",
    "# for loops\n",
    "\n",
    "s = 'abcd'\n",
    "\n",
    "# (1) the for loop asks s, the object at the end of the line, if it's \"iterable\" -- meaning,\n",
    "# does it know what to do in a for loop?\n",
    "# (2) If the answer is yes, then the \"for\" loop says: OK, give me your next item.\n",
    "# (3) That item is assigned to the variable one_character\n",
    "# (4) The loop body (here, only one line -- line 17) is executed\n",
    "# (5) We go back to line 2, and keep asking for the next thing.\n",
    "# (6) When the object says, \"I'm done -- nothing left!\"  the loop exits.\n",
    "\n",
    "print('Before')\n",
    "for one_character in s:\n",
    "    print(one_character)   # as long or short as we want, including if / assignment / print / another loop!\n",
    "print('After')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2be7735c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d\n"
     ]
    }
   ],
   "source": [
    "# if this gives you the error \"str is not callable\"\n",
    "# then you accidentally redefined the print function\n",
    "# (oops)\n",
    "\n",
    "# to get out of that, type\n",
    "# del(print) -- don't get in the habit of doing that\n",
    "\n",
    "print(one_character)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "058f6bc1",
   "metadata": {},
   "source": [
    "# When do we use `for` loops?\n",
    "\n",
    "When we have a collection of data (right now, only strings -- but we'll expand that soon) and we want to go through each element and do something with it.\n",
    "\n",
    "Examples:\n",
    "- Go through a string, and check each letter for some condition \n",
    "- Go through a bunch of IP addresses, and count how often each is in our logfile\n",
    "- Go through a bunch of users, and check that they have appropriate permissions\n",
    "\n",
    "Any time you want to \"go through a bunch of\" in Python, it's a `for` loop.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "bb494426",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tNow looking at 1\n",
      "\tNow looking at 2\n",
      "\tNow looking at 3\n",
      "\tNow looking at 4\n",
      "\tNow looking at 5\n",
      "total = 15\n"
     ]
    }
   ],
   "source": [
    "# let's sum the digits in the string s\n",
    "\n",
    "total = 0\n",
    "s = '12345'\n",
    "\n",
    "for one_character in s:\n",
    "    print(f'\\tNow looking at {one_character}')  # tab, \\t, for indentation\n",
    "    total += int(one_character)  # turn the character into an integer, and add to total\n",
    "    \n",
    "print(f'total = {total}')     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "44f1e4fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 10\n",
    "\n",
    "x = x + 1   # this means: get the value of x, add 1 to it, and then assign that new value back to x\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "177e5df7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# I can write that in a different way:\n",
    "\n",
    "x = 10\n",
    "x += 1  # same as x = x + 1\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b792197",
   "metadata": {},
   "source": [
    "# Exercise: Vowels and others\n",
    "\n",
    "1. Define two variables, `vowels` and `others`, both to be 0.\n",
    "2. Ask the user to enter a string.\n",
    "3. Go through each character in the string, and check -- is it a vowel or not?\n",
    "    - If it's a vowel, then increment `vowels` by 1.\n",
    "    - If it's not, then increment `others` by 1.\n",
    "4. In the end, print the values of both `vowels` and `others`.\n",
    "\n",
    "Example:\n",
    "\n",
    "    Enter a string: hello!\n",
    "    vowels: 2\n",
    "    others: 4\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "5ac7b00d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: hello\n",
      "vowels = 2\n",
      "others = 3\n"
     ]
    }
   ],
   "source": [
    "vowels = 0    # define these variables as 0, so we can add to them later on\n",
    "others = 0 \n",
    "\n",
    "s = input('Enter a string: ').strip()   # removes the whitespace from the sides of the input string\n",
    "\n",
    "for one_character in s:\n",
    "    if one_character in 'aeiou':  # if the current character is a vowel\n",
    "        vowels += 1   # add 1 to the vowel counter\n",
    "    else:\n",
    "        others += 1\n",
    "        \n",
    "print(f'vowels = {vowels}')       # show the total number of vowels   \n",
    "print(f'others = {others}')       # show the total number of others"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "306fe958",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdef'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = '   aBcDeF   '\n",
    "s.strip().lower()  # s.strip() returns a new string... on which we can run lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e41fe438",
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Reuven'  # this variable didn't previously exist... now it does... that's fine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "f8509cc9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 + 20 = 30\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 20\n",
    "\n",
    "print(f'{x} + {y} = {x+y}')  # print gets a string -- in each {}, we have a Python expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3fcd2186",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The \"in\" operator searches in a string for a smaller string\n",
    "\n",
    "'a' in 'aeiou'    # since 'a' can be found in 'aeiou', it returns True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "a3ed964a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'q' in 'aeiou'  # not there, so we get False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d4d03871",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can express \"in\" as \n",
    "\n",
    "# small in big  -- and it returns True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e7f7230d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: hello\n",
      "Found an other: h\n",
      "Found a vowel: e\n",
      "Found an other: l\n",
      "Found an other: l\n",
      "Found a vowel: o\n",
      "vowels = 2\n",
      "others = 3\n"
     ]
    }
   ],
   "source": [
    "vowels = 0    # define these variables as 0, so we can add to them later on\n",
    "others = 0 \n",
    "\n",
    "s = input('Enter a string: ').strip()   # removes the whitespace from the sides of the input string\n",
    "\n",
    "for one_character in s:  # the body of the loop executes once per character in s\n",
    "\n",
    "    if one_character in 'aeiou':  # if the current character is a vowel\n",
    "        print(f'Found a vowel: {one_character}')\n",
    "        vowels += 1   # add 1 to the vowel counter\n",
    "    else:\n",
    "        print(f'Found an other: {one_character}')\n",
    "        others += 1\n",
    "        \n",
    "print(f'vowels = {vowels}')       # show the total number of vowels   \n",
    "print(f'others = {others}')       # show the total number of others"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "a0c72401",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: hello\n",
      "Found an other: h\n",
      "Found a vowel: e\n",
      "Found an other: l\n",
      "Found an other: l\n",
      "Found a vowel: o\n",
      "vowels = 2\n",
      "others = 3\n"
     ]
    }
   ],
   "source": [
    "all_vowels = 'aeiouAEIOU'\n",
    "vowels = 0    # define these variables as 0, so we can add to them later on\n",
    "others = 0 \n",
    "\n",
    "s = input('Enter a string: ').strip()   # removes the whitespace from the sides of the input string\n",
    "\n",
    "for one_character in s:  # the body of the loop executes once per character in s\n",
    "\n",
    "    if one_character in all_vowels:\n",
    "        print(f'Found a vowel: {one_character}')\n",
    "        vowels += 1   # add 1 to the vowel counter\n",
    "    else:\n",
    "        print(f'Found an other: {one_character}')\n",
    "        others += 1\n",
    "        \n",
    "print(f'vowels = {vowels}')       # show the total number of vowels   \n",
    "print(f'others = {others}')       # show the total number of others"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af358b0c",
   "metadata": {},
   "source": [
    "See this in Python Tutor:\n",
    "\n",
    "https://pythontutor.com/visualize.html#code=all_vowels%20%3D%20'aeiouAEIOU'%0Avowels%20%3D%200%20%20%20%20%23%20define%20these%20variables%20as%200,%20so%20we%20can%20add%20to%20them%20later%20on%0Aothers%20%3D%200%20%0A%0As%20%3D%20input%28'Enter%20a%20string%3A%20'%29.strip%28%29%20%20%20%23%20removes%20the%20whitespace%20from%20the%20sides%20of%20the%20input%20string%0A%0Afor%20one_character%20in%20s%3A%20%20%23%20the%20body%20of%20the%20loop%20executes%20once%20per%20character%20in%20s%0A%0A%20%20%20%20if%20one_character%20in%20all_vowels%3A%0A%20%20%20%20%20%20%20%20print%28f'Found%20a%20vowel%3A%20%7Bone_character%7D'%29%0A%20%20%20%20%20%20%20%20vowels%20%2B%3D%201%20%20%20%23%20add%201%20to%20the%20vowel%20counter%0A%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20print%28f'Found%20an%20other%3A%20%7Bone_character%7D'%29%0A%20%20%20%20%20%20%20%20others%20%2B%3D%201%0A%20%20%20%20%20%20%20%20%0Aprint%28f'vowels%20%3D%20%7Bvowels%7D'%29%20%20%20%20%20%20%20%23%20show%20the%20total%20number%20of%20vowels%20%20%20%0Aprint%28f'others%20%3D%20%7Bothers%7D'%29%20%20%20%20%20%20%20%23%20show%20the%20total%20number%20of%20others&cumulative=false&curInstr=27&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%22hello%22%5D&textReferences=false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "77cf0764",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "z\n",
      "y\n",
      "x\n"
     ]
    }
   ],
   "source": [
    "for one_item in 'zyx':\n",
    "    print(one_item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d9e21bc4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yay!\n",
      "Yay!\n",
      "Yay!\n"
     ]
    }
   ],
   "source": [
    "# I'm in a great mood, because I'm teaching Python!\n",
    "# I want to express how happy I am!\n",
    "\n",
    "print('Yay!')\n",
    "print('Yay!')\n",
    "print('Yay!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "390f0c05",
   "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)",
      "\u001b[0;32m/var/folders/rr/0mnyyv811fs5vyp22gf4fxk00000gn/T/ipykernel_32202/2092896610.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# let's try using a for loop!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mone_item\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Yay!'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
     ]
    }
   ],
   "source": [
    "# this looks like very un-DRY code\n",
    "# WET code means: write everything twice\n",
    "\n",
    "# let's try using a for loop!\n",
    "for one_item in 3:\n",
    "    print('Yay!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "29fb7b16",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yay!\n",
      "Yay!\n",
      "Yay!\n"
     ]
    }
   ],
   "source": [
    "# we can iterate a number of times using the \"range\" function\n",
    "\n",
    "for one_item in range(3):    # this will run things 3 times\n",
    "    print('Yay!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "74cdac59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Yay!\n",
      "1 Yay!\n",
      "2 Yay!\n"
     ]
    }
   ],
   "source": [
    "# what value do we get with each iteration on a range?\n",
    "\n",
    "# we get integers, starting with 0, going up to (but not including) the number we stated\n",
    "\n",
    "for one_item in range(3):     # three iterations -- 0, 1, and 2\n",
    "    print(f'{one_item} Yay!') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "01086e2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2 Yay!'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'{one_item} Yay!'   # creates a string, but everything in {} is run as a tiny Python program"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "2f5a7ed3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: Hello\n",
      "1: Hello\n"
     ]
    }
   ],
   "source": [
    "# I can use a variable in range\n",
    "\n",
    "number_of_times = 2\n",
    "\n",
    "for index in range(number_of_times):\n",
    "    print(f'{index}: Hello')  # in an f-string, {} contain Python code that's then put into the final string"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "479426c9",
   "metadata": {},
   "source": [
    "# Exercise: Name triangles\n",
    "\n",
    "1. Ask the user to enter their name, and assign to a variable `name`.\n",
    "2. Print the user's name, repeatedly, starting with 1 letter and going up to the whole name.\n",
    "\n",
    "Example:\n",
    "\n",
    "    Enter your name: Reuven\n",
    "    R\n",
    "    Re \n",
    "    Reu\n",
    "    Reuv\n",
    "    Reuve\n",
    "    Reuven\n",
    "    \n",
    "Hints:\n",
    "1. You can get the length of a string with `len`\n",
    "2. You can use a \"slice\" to get only part of a string: `s[start:end+1]`\n",
    "3. Slices can use indexes beyond the boundary of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "12fec10d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name: Reuven\n",
      "R\n",
      "Re\n",
      "Reu\n",
      "Reuv\n",
      "Reuve\n",
      "Reuven\n"
     ]
    }
   ],
   "source": [
    "# how would I do this without a loop?\n",
    "\n",
    "name = input('Enter your name: ').strip()\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": 47,
   "id": "7ebe179c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tmax_index = 0\n",
      "R\n",
      "\tmax_index = 1\n",
      "Re\n",
      "\tmax_index = 2\n",
      "Reu\n",
      "\tmax_index = 3\n",
      "Reuv\n",
      "\tmax_index = 4\n",
      "Reuve\n",
      "\tmax_index = 5\n",
      "Reuven\n"
     ]
    }
   ],
   "source": [
    "name = 'Reuven'\n",
    "for max_index in range(6):\n",
    "    print(f'\\tmax_index = {max_index}')\n",
    "    print(name[:max_index+1])  # string + slice + addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "1de1fb30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name: Maximillion\n",
      "M\n",
      "Ma\n",
      "Max\n",
      "Maxi\n",
      "Maxim\n",
      "Maximi\n",
      "Maximil\n",
      "Maximill\n",
      "Maximilli\n",
      "Maximillio\n",
      "Maximillion\n"
     ]
    }
   ],
   "source": [
    "name = input('Enter your name: ').strip()\n",
    "\n",
    "for max_index in range(len(name)):   # iterate from 0 to the length of the name - 1\n",
    "    print(name[:max_index+1])        # print the name from the start until max_index characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "fc77d75c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for one_item in range(len(name)):  # range will always be 0 until its argument - 1\n",
    "    print(one_item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "3a52237e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "c9342f6c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a    b    c'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the strip method only removes whitespace from the *edges* of the string\n",
    "\n",
    "s = '   a    b    c    '\n",
    "s.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2504550",
   "metadata": {},
   "source": [
    "# Next up\n",
    "\n",
    "- Indexes\n",
    "- `while`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "751832d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: a\n",
      "1: b\n",
      "2: c\n",
      "3: d\n"
     ]
    }
   ],
   "source": [
    "# what if I *want* to print the indexes along with the values?\n",
    "# One way: Do it yourself!\n",
    "\n",
    "s = 'abcd'\n",
    "index = 0   # define index , set to 0\n",
    "\n",
    "for one_item in s:\n",
    "    print(f'{index}: {one_item}')   # print the index and the item\n",
    "    index += 1  # increment the index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "da5ddc70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: a\n",
      "1: b\n",
      "2: c\n",
      "3: d\n"
     ]
    }
   ],
   "source": [
    "# You could do this... but please don't!\n",
    "\n",
    "s = 'abcd'\n",
    "\n",
    "for one_index in range(len(s)):\n",
    "    print(f'{one_index}: {s[one_index]}')  # don't do this!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "90cf2f92",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1: a\n",
      "2: b\n",
      "3: c\n",
      "4: d\n"
     ]
    }
   ],
   "source": [
    "# start counting with 1, not 0 by starting index at 1\n",
    "\n",
    "s = 'abcd'\n",
    "index = 1\n",
    "\n",
    "for one_item in s:\n",
    "    print(f'{index}: {one_item}')   # print the index and the item\n",
    "    index += 1  # increment the index"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1439276d",
   "metadata": {},
   "source": [
    "# Zero-based indexes\n",
    "\n",
    "Many, *many* programming languages start indexing with zero. Not because people do, but -- why not? Why not use a number we have?\n",
    "\n",
    "Python, Ruby, JavaScript, C, C++, Java, C# and many others start with 0.\n",
    "\n",
    "Many others (I think a minority) use 1-based indexing: R, Lisp, Matlab."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "e75584d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n"
     ]
    }
   ],
   "source": [
    "s = 'abcd'\n",
    "\n",
    "for one_item in s:  # iterate over the characters in s, a string\n",
    "    print(one_item)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "75a4076e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "s = 'abcd'\n",
    "\n",
    "for one_item in range(len(s)):  # range always returns numbers, from 0 to a maximum\n",
    "    print(one_item)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "5cf5f63b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "c\n",
      "b\n",
      "d\n"
     ]
    }
   ],
   "source": [
    "s = 'acbd'\n",
    "\n",
    "for one_item in s:  # iterate over the characters in s, IN THE ORDER OF THE STRING\n",
    "    print(one_item)  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fd14b9c",
   "metadata": {},
   "source": [
    "# Are `for` loops enough?\n",
    "\n",
    "No.\n",
    "\n",
    "`for` loops are great when we want to do something:\n",
    "- for each element in a container\n",
    "- a number of times\n",
    "\n",
    "What if I don't know how many times I want to run a loop?\n",
    "\n",
    "The other kind of loop is a `while` loop. It stops when a certain condition is `False`.\n",
    "\n",
    "You can think of `while` loops as just like `if` statements -- but `if` conditions are only checked once, and the body of the `if` is only executed once.  In a `while` loop, the condition is checked after the body runs, and if the condition is still `True`, then the body runs again.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "500db070",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "End\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "\n",
    "print('Start')\n",
    "while x > 0:   # so long as it's > 0...\n",
    "    print(x)   # ... print x ...\n",
    "    x -= 1     # ... take 1 away from x (decrementing x)\n",
    "print('End')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "63512fee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start\n",
      "Enter your name: Reuven\n",
      "Hello, Reuven!\n",
      "Enter your name: asdfsafdasf\n",
      "Hello, asdfsafdasf!\n",
      "Enter your name: asdfsadfsafasfasdfas\n",
      "Hello, asdfsadfsafasfasdfas!\n",
      "Enter your name: \n",
      "End\n"
     ]
    }
   ],
   "source": [
    "# what if I want to break out of a loop?\n",
    "# in a for loop, or in a while loop, sometimes I want to say: I'm done!\n",
    "\n",
    "# for that, we can say \"break\"\n",
    "# that means: stop the loop right away\n",
    "\n",
    "# I'm going to create an infinite loop on purpose:\n",
    "\n",
    "print('Start')\n",
    "while True:   # infinite loop\n",
    "    name = input('Enter your name: ').strip()\n",
    "    \n",
    "    if name == '':  # is name empty?\n",
    "        break       # stop the loop right now!\n",
    "\n",
    "    print(f'Hello, {name}!')  # indented, thus in the loop body -- will run once per iteration\n",
    "print('End')                  # not indented, *after* the loop -- will run *AFTER* finishing the loop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35d5a92f",
   "metadata": {},
   "source": [
    "# When do we use `for`, and when do we use `while`?\n",
    "\n",
    "Use `for`:\n",
    "- When you want to do the same thing for each element in a string (or other collection)\n",
    "- When you want to do something a particular number of times\n",
    "\n",
    "Use `while`:\n",
    "- When you don't know how many iterations you'll need, but you know when you'll want to stop\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8e72b4d",
   "metadata": {},
   "source": [
    "# Exercise: Summing to 100\n",
    "\n",
    "1. Set `total` to 0.\n",
    "2. Ask the user, repeatedly, to enter a number.\n",
    "3. (Take the user's input and turn it into an integer.)\n",
    "4. Add it to total.\n",
    "5. Stop asking, and exit your loop, if `total` is > 100.\n",
    "6. Print the value of `total`\n",
    "\n",
    "Example:\n",
    "\n",
    "    Enter a number: 25\n",
    "    Enter a number: 50\n",
    "    Enter a number: 20\n",
    "    Enter a number: 10\n",
    "    Total is 105"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "730c9350",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 10\n",
      "\ts = 10, total = 10\n",
      "Enter a number: 20\n",
      "\ts = 20, total = 30\n",
      "Enter a number: 30\n",
      "\ts = 30, total = 60\n",
      "Enter a number: 40\n",
      "\ts = 40, total = 100\n",
      "Enter a number: 50\n",
      "\ts = 50, total = 150\n",
      "total = 150\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "\n",
    "while total <= 100:\n",
    "    s = input('Enter a number: ')   # get input from the user\n",
    "    \n",
    "    if s.isdigit():            # if s contains only 0-9, then turn into an int and add to total\n",
    "        total += int(s)        # add the int (based on s) to total\n",
    "        print(f'\\ts = {s}, total = {total}')\n",
    "\n",
    "print(f'total = {total}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "d83aa98c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 10\n",
      "\ts = 10, total = 10\n",
      "Enter a number: 20\n",
      "\ts = 20, total = 30\n",
      "Enter a number: 30\n",
      "\ts = 30, total = 60\n",
      "Enter a number: 40\n",
      "\ts = 40, total = 100\n",
      "Enter a number: 50\n",
      "\ts = 50, total = 150\n",
      "Enter a number: \n",
      "total = 150\n"
     ]
    }
   ],
   "source": [
    "# I want to total numbers that the user enters, until I get an empty string\n",
    "\n",
    "total = 0\n",
    "\n",
    "while True:   # we don't know how many times we'll need to get input from the user!\n",
    "    \n",
    "    s = input('Enter a number: ').strip()\n",
    "    \n",
    "    if s == '':   # stop asking if we got an empty string\n",
    "        break\n",
    "        \n",
    "    if s.isdigit():\n",
    "        total += int(s)\n",
    "        \n",
    "    print(f'\\ts = {s}, total = {total}')  # this is *inside* the loop body, so it prints every iteration\n",
    "\n",
    "print(f'total = {total}') # this is *outside* the loop body, so it prints after the loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "2a13df29",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcdefgh\n"
     ]
    }
   ],
   "source": [
    "s = 'abcdefgh'\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "36a5fffc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd\n",
      "efgh\n"
     ]
    }
   ],
   "source": [
    "s = 'abcd\\nefgh'   # \\n == newline character, meaning: go down one line\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "b540a74a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd\tefgh\n"
     ]
    }
   ],
   "source": [
    "s = 'abcd\\tefgh'   # \\t == tab character, meaning: go to the next column that's a multiple of 8\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "f94fb1f4",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\ts = abcd\tefgh\n"
     ]
    }
   ],
   "source": [
    "print(f'\\ts = {s}')  # start with a tab, then show s = (current value of s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "70bf8bf7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "x = int(input('Enter a number: '))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "876e21a7",
   "metadata": {},
   "source": [
    "# Next up:\n",
    "\n",
    "1. Lists\n",
    "    - Creating\n",
    "    - Retrieving, etc.\n",
    "    - Mutability\n",
    "2. Strings to lists, and back\n",
    "3. Tuples and unpacking\n",
    "\n",
    "10-minutes break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "69d87336",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 1a2b\n",
      "1a2b contains non-digits\n"
     ]
    }
   ],
   "source": [
    "s = input('Enter a number: ').strip()\n",
    "\n",
    "# does s contain only digits, and can be turned into an int?\n",
    "if s.isdigit():\n",
    "    print(f'Yes, {s} contains only digits')\n",
    "    n = int(s)\n",
    "    print(n*3)\n",
    "else:\n",
    "    print(f'{s} contains non-digits')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68cf1e53",
   "metadata": {},
   "source": [
    "# Lists\n",
    "\n",
    "We sometimes want a collection of objects of various types, because they all belong together:\n",
    "\n",
    "- a bunch of usernames\n",
    "- a bunch of filenames\n",
    "- a bunch of ID numbers\n",
    "- children in a family\n",
    "\n",
    "Strings are also collections in a sense, but they can only contain characters. We might want more than that. And that's what lists offer us.\n",
    "\n",
    "Lists are Python's equivalent (more or less) to other languages' arrays. They are not arrays, but you can think of them in that way.\n",
    "\n",
    "A list can contain any number of any kind of objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "e35b06ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# define a list with []\n",
    "# the elements of the list are separated by ,\n",
    "# the elements can be ANYTHING AT ALL, but it's traditional in Python for them to all be of the same type.\n",
    "\n",
    "mylist = [10, 20, 30]\n",
    "type(mylist)   # what kind of data do I have here?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b77220b",
   "metadata": {},
   "source": [
    "# Lists are sequences... just like strings!\n",
    "\n",
    "So they share many features:\n",
    "\n",
    "- We retrieve items from a list with `[i]`, where `i` is an index\n",
    "- We can retrieve a slice with `[start:end+1]`\n",
    "- Get the length with `len`\n",
    "- We can search with `in`\n",
    "- We can iterate with a `for` loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "50e4c31f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n",
    "\n",
    "mylist[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "903b4797",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "551076f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "32d1d92f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[-1]  # remember: -1 means: first item from the *right* side"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "91a3262e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "90"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[-2]  # means: 2nd item from the right side"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "d83bf594",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "50 in mylist  # is 50 an element of mylist?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "3a239818",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[40, 50, 60, 70]"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[3:7]  # from index 3 to (not including) index 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "71f0b5e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n",
      "50\n",
      "60\n",
      "70\n",
      "80\n",
      "90\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "for one_item in mylist:\n",
    "    print(one_item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "d21d2cd9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# some things are different\n",
    "\n",
    "mylist = [10, 20, 30]\n",
    "biglist = [mylist, mylist, mylist]  # each element of biglist is ... a list!\n",
    "\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "53980546",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "261f2a6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[10, 20, 30], [10, 20, 30], [10, 20, 30]]"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biglist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "50e66156",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(biglist)  # biglist contains three elements, each of which happens to be a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "064142ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30]"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biglist[0]  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "f0c9574f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biglist[0][1]   # go to biglist, ask for index 0... go to the returned value, and ask it for index 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "4c4e8614",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'abcde'\n",
    "s[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "d094a2c8",
   "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)",
      "\u001b[0;32m/var/folders/rr/0mnyyv811fs5vyp22gf4fxk00000gn/T/ipykernel_32202/1115476868.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'!'\u001b[0m  \u001b[0;31m# can I assign to a string, and change it?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "s[0] = '!'  # can I assign to a string, and change it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "8e9617f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30]"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "a49e1ae7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "f35208eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist[0] = '!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "7388196c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['!', 20, 30]"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist   # lists are mutable -- you can change their contents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "cd1b2e91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['!', 20, 30], ['!', 20, 30], ['!', 20, 30]]"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biglist"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67f90c2a",
   "metadata": {},
   "source": [
    "Python tutor example with `mylist` and `biglist`\n",
    "\n",
    "https://pythontutor.com/visualize.html#code=mylist%20%3D%20%5B10,%2020,%2030%5D%0Abiglist%20%3D%20%5Bmylist,%20mylist,%20mylist%5D%0A%0Amylist%5B0%5D%20%3D%20'!'%0Abiglist%5B1%5D%5B2%5D%20%3D%20'%3F'%0A%0Aprint%28mylist%29%0Aprint%28biglist%29%0A&cumulative=false&curInstr=6&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "2120ee42",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 'hello', 30]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [10, 20, 30]\n",
    "\n",
    "# modify an element of mylist by assigning to its index\n",
    "mylist[1] = 'hello'\n",
    "\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "b6040772",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 'hello', 30, 40]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# how can I make mylist bigger?\n",
    "# to add a single item to the end, we use the \"append\" method\n",
    "\n",
    "mylist.append(40)  # whatever we pass to append is added to the end\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "bdb99359",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 'hello', 30, 40, 50]"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.append(50)\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "7a49ade2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 'hello', 30, 40, 50, [100, 200, 300]]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.append([100, 200, 300])  # add the list to the end\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "b762cdb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can use a list to accumulate values as a program is running\n",
    "\n",
    "# go through a logfile, and keep a list of the error messages\n",
    "# go through a directory, and keep a list of the files that had permission issues\n",
    "# go through a network, and keep a list of the IP addresses that give you trouble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "4a55561e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50, 60]"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# you can also add multiple items to the end of a list!\n",
    "mylist = [10, 20, 30]\n",
    "\n",
    "mylist += [40, 50, 60]  # += looks to its right and runs a \"for\" loop, appending each item\n",
    "mylist\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "ec61281a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50, 60, 'abc']"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.append('abc')  # added exactly what I gave it, a string\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "9811d662",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50, 60, 'abc', 'd', 'e', 'f']"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist += 'def'  # ran the for loop, and added each item in the string\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "39de8898",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'f'"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# you can remove an item with \"pop\"\n",
    "# by default, pop removes from the end, and returns what it removed\n",
    "mylist.pop()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "f6ac8bb9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50, 60, 'abc', 'd', 'e']"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "9d6b41ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# I can also give an index to remove\n",
    "mylist.pop(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "6be9ac80",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 50, 60, 'abc', 'd', 'e']"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "7e92f12a",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "list.append() takes exactly one argument (2 given)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/rr/0mnyyv811fs5vyp22gf4fxk00000gn/T/ipykernel_32202/3706043110.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmylist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m40\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m50\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: list.append() takes exactly one argument (2 given)"
     ]
    }
   ],
   "source": [
    "mylist.append(40, 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "61069ffe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40]"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to add one item to the end of a list, use .append\n",
    "mylist = [10, 20, 30]\n",
    "mylist.append(40)  # after this, 40 will be the final element\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "51ab61a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50, 60]"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to add MULTIPLE ITEMS to the end of a list, use += and an iterable type\n",
    "# += will run a for loop on what's on the right\n",
    "# each element will be appended to the list\n",
    "\n",
    "mylist = [10, 20, 30]\n",
    "mylist += [40, 50, 60]  # run a for loop on [40, 50, 60], appending each one\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "ca4ab4cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 50, 60]"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.remove(40) # this removes the first occurence of 40\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab634343",
   "metadata": {},
   "outputs": [],
   "source": [
    "# .append takes anything, as one item\n",
    "# append a string? the entire string is added, as one string\n",
    "# append a list? the entire list is added, as one list\n",
    "# append a number? the number is added, as one number\n",
    "\n",
    "# += only works when the right-side item is iterable (i.e., can work in a for loop)\n",
    "# += a string? Add each character to the end of the list\n",
    "# += a list? Add each list element to the end of our list\n",
    "# += a number? ERROR -- because you cannot run a for loop on a number"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "476e22a2",
   "metadata": {},
   "source": [
    "# Exercise: Odds and evens\n",
    "\n",
    "1. Define two empty lists (`[]`), `odds` and `evens`.\n",
    "2. Ask the user, repeatedly, to enter a number.\n",
    "    - If they give us an empty string, stop asking.\n",
    "    - If they give us something that's not digits, scold them and let them try again\n",
    "3. Find out if the number is odd or even.\n",
    "    - If it's odd, append it to the end of `odds`\n",
    "    - If it's even, append it to the end of `evens`\n",
    "4. When done asking, print both `odds` and `evens`.\n",
    "\n",
    "To check if a number is odd or even, we can use `% 2` (remainder from division) -- this returns 0 if the number is even, and 1 if the number is odd.\n",
    "\n",
    "Example:\n",
    "\n",
    "    Enter a number: 10\n",
    "    Enter a number: 15\n",
    "    Enter a number: 23\n",
    "    Enter a number: 648\n",
    "    Enter a number: abc\n",
    "        abc is not numeric!\n",
    "    Enter a number: [ENTER]\n",
    "    odds: [15, 23]\n",
    "    evens: [10, 648]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "15257373",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 10\n",
      "Enter a number: 11\n",
      "Enter a number: 15\n",
      "Enter a number: 18\n",
      "Enter a number: 20\n",
      "Enter a number: asdfafa\n",
      "asdfafa is not numeric!\n",
      "Enter a number: \n",
      "odds = [11, 15]\n",
      "evens = [10, 18, 20]\n"
     ]
    }
   ],
   "source": [
    "odds = []\n",
    "evens = []\n",
    "\n",
    "while True:  # always run the block, the condition is always True \n",
    "    s = input('Enter a number: ').strip()\n",
    "    \n",
    "    if s == '':   # did we get an empty string from the user? stop the loop now\n",
    "        break\n",
    "        \n",
    "    if s.isdigit():\n",
    "        n = int(s)  # get n, an int, based on user's input\n",
    "\n",
    "        if n % 2 == 1:\n",
    "            odds.append(n)  # add n to odds, if it's odd\n",
    "        else:\n",
    "            evens.append(n)  # add n to evens, if it's even\n",
    "            \n",
    "    else:\n",
    "        print(f'{s} is not numeric!')\n",
    "    \n",
    "print(f'odds = {odds}')\n",
    "print(f'evens = {evens}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "c8f8f4ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start\n",
      "End\n"
     ]
    }
   ],
   "source": [
    "# if the condition is False at the start, then the while loop runs zero times\n",
    "\n",
    "x = 10\n",
    "print('Start')\n",
    "while x == 20:   # this is False, so the loop body doesn't run\n",
    "    print('Yes, x is 20!')\n",
    "print('End')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "432ecf1d",
   "metadata": {},
   "source": [
    "# Next up:\n",
    "\n",
    "- Strings to lists\n",
    "- Lists to strings\n",
    "- Tuples\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e08e2b0",
   "metadata": {},
   "source": [
    "# Converting strings to lists\n",
    "\n",
    "We've seen that we can convert a string to an int with `int(s)`. And we can convert a string to a float with `float(s)`.  (In both cases, we don't actually change `s`, but we get a new object back based on it.)\n",
    "\n",
    "What if I try to create a list based on `s`?  Will that work?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "5ad8c473",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', 'd']"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'abcd'\n",
    "list(s)     # each character becomes a list element -- it ran a \"for\" loop!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "6cf22fe7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c', ' ', 'd', 'e', 'f', ' ', 'g', 'h', 'i']"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# what if my string is structured differently?\n",
    "s = 'abc def ghi'\n",
    "list(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "3c0a9c96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc', 'def', 'ghi']"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# how can I get a list back from s that uses the space characters to separate things,\n",
    "# and doesn't give me each individual character back as a list element?\n",
    "\n",
    "# a string method: split\n",
    "\n",
    "s.split(' ')  # this means: give me a list of strings back, based on s, using ' ' as a separator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "ea35613b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc de', ' ghi']"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.split('f')  # weird, but possible!  'f' is the separator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "3d521ef6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc d', ' ghi']"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.split('ef')  # use 'ef' as the separator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "5b65f7d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ab', '', '', '', 'cde', '', '', 'fghij', 'kl']"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'ab    cde   fghij kl'\n",
    "s.split(' ')   # split uses *each* space character as a separator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "e8e46576",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ab', 'cde', 'fghij', 'kl']"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# there is a solution! We can *NOT* give any argument to split:\n",
    "s.split()  # this means: use any whitespace characters, in any number, and any combination, as a separator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "152ef4d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ab', 'cde', 'fghij', 'kl']"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = s.split()\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "50c88310",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ab', 'cde', 'fghij', 'kl', 'ab', 'cde', 'fghij', 'kl']"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist += s.split()\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "4cd032d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ab\n",
      "cde\n",
      "fghij\n",
      "kl\n"
     ]
    }
   ],
   "source": [
    "# s.split returns a list, so we can use it wherever we use lists\n",
    "for one_item in s.split():\n",
    "    print(one_item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "1204a167",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ab    cde   fghij kl'"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "2d036b51",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ab    cde   fghij kl']"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.split('abc ')  # always returns a list of strings, here one element only"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "463afdc5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "for one_item in [10, 20, 30]:\n",
    "    print(one_item)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cea56f46",
   "metadata": {},
   "source": [
    "# Remember Pig Latin?\n",
    "\n",
    "We did a Pig Latin translator last week."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "bdcd1104",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: elephant\n",
      "elephantway\n"
     ]
    }
   ],
   "source": [
    "word = input('Enter a word: ').strip()\n",
    "\n",
    "if word[0] in 'aeiou':  # if the word starts with a vowel\n",
    "    print(word + 'way') # add 'way' to the word\n",
    "else:\n",
    "    print(word[1:] + word[0] + 'ay')  # first letter goes to the end, and add 'ay'\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e439efc4",
   "metadata": {},
   "source": [
    "# Exercise: Pig Latin sentence\n",
    "\n",
    "1. Ask the user to enter a sentence in English. (All lowercase, no punctuation, spaces between words.)\n",
    "2. Print each word, translated into Pig Latin.\n",
    "\n",
    "Example:\n",
    "\n",
    "    Enter sentence: this is a test\n",
    "    histay isway away esttay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "094879b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: this is a test\n",
      "histay\n",
      "isway\n",
      "away\n",
      "esttay\n"
     ]
    }
   ],
   "source": [
    "sentence = input('Enter a sentence: ').strip()\n",
    "\n",
    "for word in sentence.split():\n",
    "    if word[0] in 'aeiou':  # if the word starts with a vowel\n",
    "        print(word + 'way') # add 'way' to the word\n",
    "    else:\n",
    "        print(word[1:] + word[0] + 'ay')  # first letter goes to the end, and add 'ay'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "89691091",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: this is a test\n",
      "histay isway away esttay \n"
     ]
    }
   ],
   "source": [
    "# how can we print it on one line?\n",
    "# one option\n",
    "\n",
    "output = ''\n",
    "sentence = input('Enter a sentence: ').strip()\n",
    "\n",
    "for word in sentence.split():\n",
    "    if word[0] in 'aeiou': \n",
    "        output += word + 'way '\n",
    "    else:\n",
    "        output += word[1:] + word[0] + 'ay '\n",
    "        \n",
    "print(output)        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5789bbda",
   "metadata": {},
   "source": [
    "# Lists to strings\n",
    "\n",
    "We've seen how we can get a list from a string by using the `split` method. That always returns a list of strings.\n",
    "\n",
    "But what if I have a list of strings, and I want to turn it into a single string?\n",
    "\n",
    "```python\n",
    "mylist = ['abcd', 'ef', 'ghij']\n",
    "s = str(mylist)  # this will work, but it's very ugly\n",
    "print(s)\n",
    "```\n",
    "\n",
    "Better is to use the `join` method. This has two parts:\n",
    "\n",
    "- The string we want to put between the elements of our list (the \"glue\")\n",
    "- The list of strings we want to join together\n",
    "\n",
    "```python\n",
    "mylist = ['abcd', 'ef', 'ghij']\n",
    "s = '*'.join(mylist)   # notice: we invoke the method on the glue!\n",
    "print(s)  # 'abcd*ef*ghij'\n",
    "```\n",
    "\n",
    "The string we get back from invoking `join` will have the elements of the list, and the glue *between* them, not on the edges."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "63d2e5c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['abcd', 'ef', 'ghij']\n"
     ]
    }
   ],
   "source": [
    "mylist = ['abcd', 'ef', 'ghij']\n",
    "s = str(mylist)  # this will work, but it's very ugly\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "4b28dea9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd*ef*ghij\n"
     ]
    }
   ],
   "source": [
    "mylist = ['abcd', 'ef', 'ghij']\n",
    "s = '*'.join(mylist)   # notice: we invoke the method on the glue!\n",
    "print(s)  # 'abcd*ef*ghij'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "64171402",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd***ef***ghij\n"
     ]
    }
   ],
   "source": [
    "s = '***'.join(mylist)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "8908a3b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd ef ghij\n"
     ]
    }
   ],
   "source": [
    "s = ' '.join(mylist)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "1af7a9a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd\n",
      "ef\n",
      "ghij\n"
     ]
    }
   ],
   "source": [
    "s = '\\n'.join(mylist)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "18bfcff2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcdefghij\n"
     ]
    }
   ],
   "source": [
    "s = ''.join(mylist)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "56334f32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: this is a test\n",
      "histay isway away esttay\n"
     ]
    }
   ],
   "source": [
    "# how can we print it on one line?\n",
    "# a better option for printing the results on a single line: use a list, then join\n",
    "\n",
    "output = []  # empty list\n",
    "sentence = input('Enter a sentence: ').strip()\n",
    "\n",
    "for word in sentence.split():\n",
    "    if word[0] in 'aeiou': \n",
    "        output.append(word + 'way')  # adds this word to the end of output\n",
    "    else:\n",
    "        output.append(word[1:] + word[0] + 'ay')  # adds this word to the end of output\n",
    "        \n",
    "print(' '.join(output))  # get a new string back, the result of joining output with spaces between words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "028099de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "histay\tisway\taway\testtay\n"
     ]
    }
   ],
   "source": [
    "print('\\t'.join(output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "e4284092",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'list' object has no attribute 'join'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/rr/0mnyyv811fs5vyp22gf4fxk00000gn/T/ipykernel_32202/1832916148.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# people wonder why join is a string method, not a list method\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0moutput\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m' '\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# this fails!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'join'"
     ]
    }
   ],
   "source": [
    "# people wonder why join is a string method, not a list method\n",
    "output.join(' ')  # this fails!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "305feeef",
   "metadata": {},
   "source": [
    "# Tuples\n",
    "\n",
    "Python has three core data types that are all \"sequences\":\n",
    "\n",
    "- Strings\n",
    "- Lists\n",
    "- Tuples\n",
    "\n",
    "It's common to think that tuples are just \"immutable lists,\" or \"locked lists.\" But that's not really supposed to be the difference. \n",
    "\n",
    "- Lists are for sequences of the same type -- a list of strings, of ints, of lists, of tuples.\n",
    "- Tuples are for sequences of *different* types -- sort of like records, or structs in other languages.\n",
    "\n",
    "To represent a person, I might want their first name (string), last name (string), and shoe size (integer):\n",
    "\n",
    "```python\n",
    "p = ('Reuven', 'Lerner', 46)\n",
    "```\n",
    "\n",
    "When do we use tuples? When do we see tuples?\n",
    "\n",
    "- If you read from a database (many records), you'll get a list of tuples\n",
    "- If you break dictionaries (our topic for next week) into pieces, you get a list of tuples\n",
    "- When you call a function, the arguments are (behind the scenes) passed via a tuple\n",
    "\n",
    "Python uses tuples all over. How much will we use them?  Some people love them... not me.  I use them when I need to."
   ]
  },
  {
   "cell_type": "raw",
   "id": "9dd7e6e8",
   "metadata": {},
   "source": [
    "How are sequences similar / different?\n",
    "\n",
    "              Contain       Mutable/Immutable\n",
    "Strings       strings          immutable\n",
    "Lists         anything           mutable\n",
    "Tuples        anything         immutable\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "71733185",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's create a tuple!\n",
    "# we use () to create tuples!\n",
    "\n",
    "t = (10, 20, 30, 40, 50, 60)\n",
    "\n",
    "# but they're sequences, so they do all sequence-y things:\n",
    "\n",
    "t[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "742b76db",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(30, 40, 50, 60)"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t[2:7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "4de5af66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "30 in t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "eacc27c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n",
      "50\n",
      "60\n"
     ]
    }
   ],
   "source": [
    "for one_item in t:\n",
    "    print(one_item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "e53af5d0",
   "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)",
      "\u001b[0;32m/var/folders/rr/0mnyyv811fs5vyp22gf4fxk00000gn/T/ipykernel_32202/187899779.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# tuples are immutable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'!'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# tuples are immutable\n",
    "t[2] = '!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "c37a3bb6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tuples are a bit weird when we define them, because they use ()\n",
    "\n",
    "t = (10, 20, 30)\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "50d0ba89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (10, 20)\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "2f1b2eb4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (10) # because we use () for many different things in Python, this is *not* a tuple\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "94a28dbc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (10,)  # use a comma, and Python knows you want a 1-element tuple\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "4c6630bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = ()\n",
    "type(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "ed0b9feb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 20, 30, 100, 200, 300)"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = (10, 20, 30)\n",
    "t2 = (100, 200, 300)\n",
    "\n",
    "t1 + t2   # returns a new tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "70977635",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 20, 30, 100, 200, 300)"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 += t2  # creates a new tuple, and assigns it to t1 (so no, we're not modifying t1)\n",
    "t1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "3e7baa9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = (10, 20, 30)\n",
    "t2 = (100, 200, 300)\n",
    "\n",
    "t1 += t2  # this creates a new tuple, and then assigns that new tuple to t1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "071420cf",
   "metadata": {},
   "source": [
    "# Tuple unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "0a20ea3c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30]"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [10, 20, 30]\n",
    "x = mylist\n",
    "\n",
    "x  # what's the value of x?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "5d592a25",
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y,z = mylist   # three variables and three elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "1bd6b9b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "248292dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "f70c53f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "8cbdb124",
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is known as tuple unpacking, because we really have a tuple of variables on the left\n",
    "# (you don't really need parentheses to create a tuple, it turns out)\n",
    "\n",
    "# if you have the same number of variables on the left and elements on the right, you can use this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "63da15d5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a math expression: 2 + 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'2'"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = input('Enter a math expression: ').strip()\n",
    "\n",
    "first, op, second = s.split()  # always returns a list of strings\n",
    "\n",
    "first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "51f68bf4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'+'"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "9a856ab1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3'"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "50ac88b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "if op == '+':\n",
    "    print(int(first) + int(second))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "5fafcc29",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [10, 20, 30]\n",
    "\n",
    "# the tuple is the threesome of variables: x, y, z\n",
    "# we cannot refer to that tuple as a special data structure\n",
    "x,y,z = mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "e18e665d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "6599757e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "283f0d6e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "69b6b4e2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 200)"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# remember that in assignment, the right side evaluates before the left side\n",
    "x = 100\n",
    "y = 200\n",
    "\n",
    "t = x,y   \n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "80e170bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y,x = x,y   # I can swap variables like this!\n",
    "\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "1f186ce1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "9af7c968",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 200)"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this creates a new anonymous tuple:\n",
    "\n",
    "x = 100\n",
    "y = 200\n",
    "\n",
    "(x,y)  # there is no way to get this tuple by itself"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "c279af6b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 200)"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (x,y)  # now t refers to that tuple\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "933a7abc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# tuple unpacking, I can assign the elements of t to two variables\n",
    "y,x = t     # t[0] will be assigned to y, and t[1] will be assigned to x\n",
    "\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "fabbb0c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "90d43b22",
   "metadata": {},
   "outputs": [],
   "source": [
    "y,x = x,y   # on the right, we have a tuple. On the left, we have a tuple. That's how we swap variable values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "afa8f766",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "3fdc2f68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ebd3e45",
   "metadata": {},
   "source": [
    "# Next week:\n",
    "\n",
    "1. Dictionaries\n",
    "2. Files (reading from and writing to files)\n",
    "\n",
    "Grab the zipfile for intro Python from https://files.lerner.co.il/ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6a7d884",
   "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.10.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}