Lesson 6 -- 2020 Apr 24.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: abcdefg\n",
      "Enter a letter: g\n",
      "I found g at index 6\n",
      "Its neighbors are at fg\n"
     ]
    }
   ],
   "source": [
    "# ask user to enter a string\n",
    "# ask the user to enter a letter\n",
    "\n",
    "# print the index at which the letter is located.\n",
    "# also print the letter preceding and following that letter\n",
    "\n",
    "s = input(\"Enter a string: \").strip()\n",
    "look_for = input(\"Enter a letter: \").strip()\n",
    "\n",
    "i = s.find(look_for)\n",
    "\n",
    "if i == -1:\n",
    "    print(f'{look_for} is not in {s}')\n",
    "else:\n",
    "    print(f'I found {s[i]} at index {i}')\n",
    "    if i > 0:\n",
    "        print(f'Its neighbors are at {s[i-1:i+2]}')   # start:stop+1\n",
    "    else:\n",
    "        print(f'Its neighbors are at {s[i:i+2]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-1:2] # index of -1 is the FINAL CHARACTER in the string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'f'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[i-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-24-9fcb2e7e3d41>\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[0mi\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m   \u001b[0;31m# you cannot request an INDEX greater than len(s)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "s[i+2]   # you cannot request an INDEX greater than len(s)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'g'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# but you can have a slice whose index goes beyond the string\n",
    "s[i:10000000]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.find('!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a string: abcdefg\n",
      "Enter start index: \n",
      "Enter stop index: \n",
      "You must enter numbers for the start and stop!\n"
     ]
    }
   ],
   "source": [
    "# Ask the user to enter a string\n",
    "# Ask the user to enter two numbers (separate inputs)\n",
    "# Print the string from the first to the second\n",
    "\n",
    "s = input(\"Enter a string: \").strip()\n",
    "start = input(\"Enter start index: \").strip()\n",
    "stop = input(\"Enter stop index: \").strip()\n",
    "\n",
    "if start.isdigit() and stop.isdigit():\n",
    "    start = int(start)\n",
    "    stop = int(stop)\n",
    "    \n",
    "    if start < 0:\n",
    "        print(f'{start} is < 0')\n",
    "    elif start >= len(s):\n",
    "        print(f'{start} is too big')\n",
    "    elif stop < 0:\n",
    "        print(f'{stop} is < 0')\n",
    "    elif stop >= len(s):\n",
    "        print(f'{stop} is too big')\n",
    "    elif start > stop:\n",
    "        print(f'{start} is greater than {stop}')\n",
    "    else:\n",
    "        print(s[start:stop])\n",
    "else:\n",
    "    print(f'You must enter numbers for the start and stop!')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0123456\n",
    "abcdefg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-34-b035325af127>\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;36m7\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "s[7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# loops!\n",
    "# for loops\n",
    "#    looping over strings\n",
    "#    looping a number of times\n",
    "# while loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n",
      "f\n"
     ]
    }
   ],
   "source": [
    "s = 'abcdef'\n",
    "\n",
    "# DRY -- don't repeat yourself!\n",
    "\n",
    "print(s[0])\n",
    "print(s[1])\n",
    "print(s[2])\n",
    "print(s[3])\n",
    "print(s[4])\n",
    "print(s[5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before\n",
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n",
      "f\n",
      "after\n"
     ]
    }
   ],
   "source": [
    "# print each character of s,\n",
    "# starting at the beginning and ending at the end\n",
    "\n",
    "# for loop -- executes some code for every element of a string\n",
    "\n",
    "print('before')\n",
    "for one_character in s:   # for asks s: are you iterable?\n",
    "    print(one_character)\n",
    "print('after')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before\n",
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n",
      "f\n",
      "after\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print('before')\n",
    "for one_gb in s:   # for asks s: are you iterable?\n",
    "    print(one_gb)\n",
    "print('after')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for VARIABLE in COLLECTION:\n",
    "    body_line_1\n",
    "    body_line_2\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n",
      "d\n",
      "e\n",
      "f\n"
     ]
    }
   ],
   "source": [
    "for thingee in s:\n",
    "    print(thingee)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abcdef'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'c' in s  # return True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I found c in abcdabcdabcdccc!\n",
      "I found c in abcdabcdabcdccc!\n",
      "I found c in abcdabcdabcdccc!\n",
      "I found c in abcdabcdabcdccc!\n",
      "I found c in abcdabcdabcdccc!\n",
      "I found c in abcdabcdabcdccc!\n"
     ]
    }
   ],
   "source": [
    "s = 'abcdabcdabcdccc'\n",
    "look_for = 'c'\n",
    "\n",
    "for one_character in s:\n",
    "    if one_character == look_for:\n",
    "        print(f'I found {one_character} in {s}!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: elephant\n",
      "elephant contains 3 vowels\n"
     ]
    }
   ],
   "source": [
    "# let's count vowels in the user's input!\n",
    "\n",
    "count = 0\n",
    "s = input(\"Enter a word: \")\n",
    "\n",
    "for one_letter in s:\n",
    "    if one_letter in 'aeiou':\n",
    "        count += 1   # add 1 to the \"count\" variable\n",
    "        \n",
    "print(f'{s} contains {count} vowels')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hooray!\n",
      "Hooray!\n",
      "Hooray!\n",
      "Hooray!\n",
      "Hooray!\n"
     ]
    }
   ],
   "source": [
    "print('Hooray!')\n",
    "print('Hooray!')\n",
    "print('Hooray!')\n",
    "print('Hooray!')\n",
    "print('Hooray!')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hooray!\n",
      "Hooray!\n",
      "Hooray!\n",
      "Hooray!\n",
      "Hooray!\n"
     ]
    }
   ],
   "source": [
    "for number in range(5):\n",
    "    print('Hooray!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to iterate over each character in a string, use\n",
    "#   for one_character in s\n",
    "\n",
    "# to iterate a certain number of times, use\n",
    "#   for one_item in range(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Hooray!\n",
      "1 Hooray!\n",
      "2 Hooray!\n",
      "3 Hooray!\n",
      "4 Hooray!\n"
     ]
    }
   ],
   "source": [
    "for number in range(5):  # from 0 until (and not including) 5\n",
    "    print(f'{number} Hooray!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 123abc4!5\n",
      "Ignoring non-digit a\n",
      "Ignoring non-digit b\n",
      "Ignoring non-digit c\n",
      "Ignoring non-digit !\n",
      "total = 15\n"
     ]
    }
   ],
   "source": [
    "# ask the user to enter a \"word\" containing only digits\n",
    "# sum the digits in that word\n",
    "\n",
    "# So if the user enters 123\n",
    "# you should print 6 at the end\n",
    "\n",
    "# bonus: check to see if each digit is really a digit\n",
    "\n",
    "s = input(\"Enter a number: \").strip()\n",
    "total = 0\n",
    "\n",
    "for one_character in s:\n",
    "    if one_character.isdigit():\n",
    "        total += int(one_character)\n",
    "    else:\n",
    "        print(f'Ignoring non-digit {one_character}')\n",
    "    \n",
    "print(f'total = {total}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'123abc4!5'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index is 0, character is a\n",
      "index is 1, character is b\n",
      "index is 2, character is c\n",
      "index is 3, character is d\n",
      "index is 4, character is e\n",
      "index is 5, character is f\n",
      "index is 6, character is g\n"
     ]
    }
   ],
   "source": [
    "s = 'abcdefg'\n",
    "\n",
    "for index in range(len(s)):\n",
    "    print(f'index is {index}, character is {s[index]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is 5\n"
     ]
    }
   ],
   "source": [
    "# while loops\n",
    "\n",
    "# while loops are just like \"if\" statements...\n",
    "# except that so long as the condition is True,\n",
    "# the loop executes additional times.\n",
    "\n",
    "x = 5\n",
    "\n",
    "if x > 0:\n",
    "    print(f'x is {x}')\n",
    "    x -= 1    # reduce x by 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is 5\n",
      "x is 4\n",
      "x is 3\n",
      "x is 2\n",
      "x is 1\n"
     ]
    }
   ],
   "source": [
    "\n",
    "x = 5\n",
    "\n",
    "while x > 0:\n",
    "    print(f'x is {x}')\n",
    "    x -= 1    # reduce x by 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "# infinite loop == never stops, goes on forever\n",
    "\n",
    "# (1) Apple's HQ used to be at 1 Infinite Loop\n",
    "# (2) loop, infinite -- see infinite loop\n",
    "#     infinite loop -- see loop, infinite\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "# these words can be used in either for or while loops:\n",
    "\n",
    "# break -- exit the loop RIGHT NOW\n",
    "# continue -- exit the current iteration, continue with the next one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start\n",
      "a\n",
      "b\n",
      "c\n",
      "end\n"
     ]
    }
   ],
   "source": [
    "s = 'abcdefg'\n",
    "look_for = 'd'\n",
    "\n",
    "print(f'start')\n",
    "for one_letter in s:\n",
    "    if one_letter == look_for:\n",
    "        break  # if we encountered 'd', stop the loop right away\n",
    "    print(one_letter)\n",
    "print('end')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start\n",
      "a\n",
      "b\n",
      "c\n",
      "e\n",
      "f\n",
      "g\n",
      "end\n"
     ]
    }
   ],
   "source": [
    "s = 'abcdefg'\n",
    "look_for = 'd'\n",
    "\n",
    "print(f'start')\n",
    "for one_letter in s:\n",
    "    if one_letter == look_for:\n",
    "        continue   # stop this iteration, but go onto the next one\n",
    "    print(one_letter)\n",
    "print('end')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 10\n",
      "Enter a number: 20\n",
      "Enter a number: 30\n",
      "Total is 60\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "\n",
    "for i in range(3):\n",
    "    n = input(\"Enter a number: \").strip()\n",
    "    if n.isdigit():\n",
    "        total += int(n)\n",
    "print(f'Total is {total}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 10\n",
      "Enter a number: 20\n",
      "Enter a number: 30\n",
      "Enter a number: 100\n",
      "Enter a number: 5126\n",
      "Enter a number: \n",
      "total = 5286\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "\n",
    "while True:    # an infinite loop!\n",
    "    n = input(\"Enter a number: \").strip()\n",
    "    if n.isdigit():\n",
    "        total += int(n)\n",
    "    else:\n",
    "        break   # if we got a non-number, stop asking + leave the loop\n",
    "\n",
    "print(f'total = {total}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's count vowels in the user's input!\n",
    "\n",
    "count = 0\n",
    "s = input(\"Enter a word: \")\n",
    "\n",
    "for one_letter in s:\n",
    "    if one_letter in 'aeiou':\n",
    "        count += 1   # add 1 to the \"count\" variable\n",
    "        \n",
    "print(f'{s} contains {count} vowels')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: hello\n",
      "Enter a word: text\n",
      "Enter a word: pretend\n",
      "Enter a word: octopus\n",
      "Enter a word: elephant\n",
      "Enter a word: \n",
      " contains 11 vowels\n"
     ]
    }
   ],
   "source": [
    "# write a program that asks the user to enter\n",
    "# any number of words.  When they enter an \n",
    "# empty string, stop asking, and print\n",
    "# the number of vowels in all words entered.\n",
    "\n",
    "count = 0\n",
    "\n",
    "while True:\n",
    "    s = input(\"Enter a word: \").strip()\n",
    "    \n",
    "    if s == '': # stop when we get an empty string\n",
    "        break\n",
    "        \n",
    "    for one_letter in s:\n",
    "        if one_letter in 'aeiou':\n",
    "            count += 1   # add 1 to the \"count\" variable\n",
    "    \n",
    "print(f'{s} contains {count} vowels')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for loops -- iterate over (a string)\n",
    "# for  .. in range(n)  -- iterate n times\n",
    "# while loops -- if statements that repeat\n",
    "\n",
    "# break -- stop the loop\n",
    "# continue -- stop the iteration\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}