Lesson 7 -- 2020 May 1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a sentence: Is this a test?\n",
      "vowels: 4\n",
      "digits: 0\n",
      "other: 11\n"
     ]
    }
   ],
   "source": [
    "# (1) Ask the user to enter a sentence.\n",
    "# Print the number of vowels, digits, and other characters \n",
    "# that were in the user’s sentence\n",
    "\n",
    "vowel_count = 0\n",
    "digit_count = 0\n",
    "other_count = 0\n",
    "\n",
    "s = input(\"Enter a sentence: \").strip()\n",
    "\n",
    "for one_character in s:\n",
    "    if one_character.lower() in 'aeiou':\n",
    "        vowel_count += 1\n",
    "        \n",
    "    elif one_character.isdigit():\n",
    "        digit_count += 1\n",
    "        \n",
    "    else:\n",
    "        other_count += 1\n",
    "        \n",
    "print(f'vowels: {vowel_count}')\n",
    "print(f'digits: {digit_count}')\n",
    "print(f'other: {other_count}')     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a    b  c'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = '   a    b  c    '\n",
    "s.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your name: Reuven\n"
     ]
    }
   ],
   "source": [
    "# (2) Ask the user to enter their name. \n",
    "# Print a “name triangle,” meaning: \n",
    "# On the first line, print just the first letter.\n",
    "# Then on the second line, print the first two letters.\n",
    "# Then on the third line, print the first three letters…\n",
    "# If the name is n letter long, then there should be n lines,\n",
    "# with the nth line printing the user’s name (as entered).\n",
    "\n",
    "name = input(\"Enter your name: \").strip()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R\n",
      "Re\n",
      "Reu\n",
      "Reuv\n",
      "Reuve\n",
      "Reuven\n"
     ]
    }
   ],
   "source": [
    "# run the \"for\" loop as many times\n",
    "# as there are letters in \"name\"\n",
    "\n",
    "for counter in range(len(name)):   # range(6) -- 0,1,2,3,4,5\n",
    "    print(name[:counter+1])   \n",
    "    \n",
    "\n",
    "# R           # name[:1]\n",
    "# Re          # name[:2]\n",
    "# Reu         # name[:3]\n",
    "# Reuv        # name[:4]\n",
    "# Reuve       # name[:5]\n",
    "# Reuven      # name[:6]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 12\n",
      "Enter a number: 58\n",
      "Enter a number: abcd\n",
      "abcd is not a number!  Try again!\n",
      "Enter a number: 1b\n",
      "1b is not a number!  Try again!\n",
      "Enter a number: 39\n",
      "Enter a number: \n",
      "Total is 109\n"
     ]
    }
   ],
   "source": [
    "# Ask the user, repeatedly, to enter numbers.\n",
    "# If they enter an empty/blank string, \n",
    "# then stop asking and print the total. \n",
    "# If the user enters a non-number, then scold them and ask again.\n",
    "\n",
    "total = 0\n",
    "\n",
    "while True:\n",
    "    number = input(\"Enter a number: \").strip()\n",
    "    \n",
    "    if number == '':\n",
    "        break   # exit the \"while\" loop right away!\n",
    "        \n",
    "    if not number.isdigit():\n",
    "        print(f'{number} is not a number!  Try again!')\n",
    "        continue\n",
    "        \n",
    "    total += int(number)\n",
    "    \n",
    "print(f'Total is {total}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lists\n",
    "\n",
    "# a list is a generic container for other objects\n",
    "# a list can contain *ANY NUMBER* of *ANY TYPE* of objects\n",
    "\n",
    "# Define a list with [] and , between elements\n",
    "mylist = [10, 20, 30, 40]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(mylist)   # what data type is this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [10, 20, 30, 40, 'hello', 'out', 'there']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "# retrieve via index, with 0 being the first element\n",
    "print(mylist[0])\n",
    "print(mylist[1])\n",
    "print(mylist[2])\n",
    "print(mylist[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[20, 30, 40]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# slices work, too!\n",
    "mylist[1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "30 in mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "for one_item in mylist:\n",
    "    print(one_item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd\n",
      "efgh\n",
      "ijkl\n"
     ]
    }
   ],
   "source": [
    "mylist = ['abcd', 'efgh', 'ijkl']\n",
    "\n",
    "for one_item in mylist:\n",
    "    print(one_item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [10, 20, 30, 40]\n",
    "\n",
    "biglist = [mylist, mylist, mylist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(biglist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'abcd'\n",
    "s[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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<ipython-input-33-f0d3010d989d>\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# try to change s[0] -- strings are immutable!\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] = '!' # try to change s[0] -- strings are immutable!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist[0] = '!'  # succeeds, because lists are mutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['!', 20, 30, 40]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['!', 20, 30, 40], ['!', 20, 30, 40], ['!', 20, 30, 40]]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biglist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [10, 20, 30, 40]\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, '!!!', 40]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[2] = '!!!'\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [10, 20, 30, 40]\n",
    "mylist.append(50)  # meaning: add the int 50 to mylist\n",
    "\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 30, 20, 15, 3, 7]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [10, 30, 20, 15, 3, 7]\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist.sort()  # this changes mylist, ordering the elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 7, 10, 15, 20, 30]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[30, 20, 15, 10, 7, 3]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.sort(reverse=True)  # now in descending order\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[10, 20, 30, 40], [10, 20, 30, 40], [10, 20, 30, 40]]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [10, 20, 30, 40]\n",
    "biglist = [mylist, mylist, mylist]\n",
    "\n",
    "biglist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['!', 20, 30, 40]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mylist == biglist[0] == biglist[1] == biglist[2]\n",
    "\n",
    "mylist[0] = '!'\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['!', 20, 30, 40], ['!', 20, 30, 40], ['!', 20, 30, 40]]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biglist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['!', '?', 30, 40], ['!', '?', 30, 40], ['!', '?', 30, 40]]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biglist[1][1] = '?'\n",
    "biglist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['!', '?', 30, 40]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = []  # creates an empty list, and assigns to \"mylist\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total = 139, mean = 27.8\n"
     ]
    }
   ],
   "source": [
    "# (1) Create a list containing several integers\n",
    "# (2) Use a \"for\" loop to iterate over the list,\n",
    "#    totalling the numbers\n",
    "# (3) Print the total and the mean/average\n",
    "#  remember: len(mylist) returns the length\n",
    "\n",
    "mylist = [10, 15, 23, 79, 12]\n",
    "\n",
    "total = 0\n",
    "for one_item in mylist:\n",
    "    total += one_item\n",
    "    \n",
    "print(f'total = {total}, mean = {total/len(mylist)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "emond.d\n",
      "xinetd.d-migrated2launchd\n",
      "ssh_config.system_default\n",
      "ssh_config.applesaved\n",
      "periodic\n",
      "manpaths\n",
      "services~previous\n",
      "rc.common\n",
      "csh.logout~orig\n",
      "auto_master\n",
      "php.ini.default-5.2-previous~orig\n",
      "csh.login\n",
      "syslog.conf\n",
      "rtadvd.conf~previous\n",
      "syslog.conf~previous\n",
      "krb5.keytab\n",
      "sudoers.d\n",
      "bash_completion.d\n",
      "ssl\n",
      "kern_loader.conf.applesaved\n",
      "nanorc\n",
      "ttys~previous\n",
      "csh.logout\n",
      "aliases.db\n",
      "hosts.lpd\n",
      "bashrc_Apple_Terminal\n",
      "racoon\n",
      "snmp\n",
      "zshrc_Apple_Terminal\n",
      "named.conf.applesaved\n",
      "gettytab\n",
      "master.passwd~orig\n",
      "kern_loader.conf\n",
      "authorization.user_modified\n",
      "networks~orig\n",
      "paths.d\n",
      "asl\n",
      "csh.login~orig\n",
      "rtadvd.conf\n",
      "security\n",
      "protocols~previous\n",
      "group\n",
      "printcap\n",
      "auto_home\n",
      "php.ini.default-previous\n",
      "sudoers~\n",
      "manpaths.d\n",
      "smb.conf.applesaved\n",
      "ppp\n",
      "shells\n",
      "pear.conf-previous\n",
      "crontab\n",
      "slpsa.conf.applesaved\n",
      "rc.common~previous\n",
      "xinetd.d\n",
      "ttys\n",
      "php-fpm.d\n",
      "group~previous\n",
      "php-fpm.conf.default\n",
      "paths\n",
      "rmtab\n",
      "csh.cshrc~orig\n",
      "inetd.conf.applesaved\n",
      "xtab\n",
      "php.ini.default\n",
      "syslog.conf.applesaved\n",
      "localtime\n",
      "pf.conf\n",
      "6to4.conf.applesaved\n",
      "CiscoSystemsVPNClient\n",
      "launchd.conf\n",
      "sudoers\n",
      "ftpusers~orig\n",
      "bashrc\n",
      "find.codes~orig\n",
      "auto_master~orig\n",
      "newsyslog.d\n",
      "emacs\n",
      "irbrc\n",
      "pam.d\n",
      "zshrc\n",
      "defaults\n",
      "hosts.equiv\n",
      "networks\n",
      "find.codes\n",
      "rpc~previous\n",
      "apache2\n",
      "autofs.conf\n",
      "ssh\n",
      "ftpusers\n",
      "postgres-reg.ini\n",
      "slpsa.conf\n",
      "profile\n",
      "csh.cshrc\n",
      "fstab.hd~previous\n",
      "ntp.conf.applesaved\n",
      "ntp_opendirectory.conf\n",
      "ssh_config~orig\n",
      "profile~orig\n",
      "authorization.deprecated\n",
      "locate.rc\n",
      "resolv.conf\n",
      "nfs.conf\n",
      "crontab.applesaved\n",
      "dictionaries-common\n",
      "sudoers~orig\n",
      "sudo_lecture\n",
      "asl.conf\n",
      "ttys.applesaved\n",
      "moduli~previous\n",
      "rc.netboot\n",
      "X11\n",
      "afpovertcp.cfg~orig\n",
      "hosts~orig\n",
      "fstab\n",
      "opt\n",
      "nfs.conf~orig\n",
      "hostconfig\n",
      "smb.conf.old\n",
      "kern_loader.conf~previous\n",
      "xinetd.conf.applesaved\n",
      "rtadvd.conf.applesaved\n",
      "sshd_config.system_default\n",
      "hosts\n",
      "efax.rc~previous\n",
      "postfix\n",
      "pf.os\n",
      "pf.anchors\n",
      "php.ini.default-previous~orig\n",
      "ntp.conf\n",
      "php.ini.default-5.2-previous\n",
      "gettytab~orig\n",
      "passwd~orig\n",
      "rpc\n",
      "master.passwd\n",
      "sshd_config~previous\n",
      "fstab.hd\n",
      "openldap\n",
      "aliases\n",
      "paths~orig\n",
      "fonts\n",
      "openssl\n",
      "com.apple.screensharing.agent.launchd\n",
      "wfs\n",
      "hostconfig.system_default\n",
      "shells~orig\n",
      "sshd_config.applesaved\n",
      "dumpdates\n",
      "protocols\n",
      "AFP.conf\n",
      "cups\n",
      "man.conf\n",
      "services\n",
      "mail.rc~orig\n",
      "resolver\n",
      "passwd\n",
      "zprofile\n",
      "afpovertcp.cfg\n",
      "newsyslog.conf\n",
      "bashrc~previous\n",
      "mail.rc\n",
      "notify.conf\n",
      "sysctl.conf.pg\n"
     ]
    }
   ],
   "source": [
    "import os   # use the \"operating system\" module in Python\n",
    "\n",
    "for one_filename in os.listdir('/etc/'):\n",
    "    print(one_filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average filename length is 12.423312883435583\n"
     ]
    }
   ],
   "source": [
    "# what's the average length of a filename in /etc/?\n",
    "\n",
    "import os   # use the \"operating system\" module in Python\n",
    "\n",
    "lengths = [ ]  # build up the list from nothing with info collected\n",
    "for one_filename in os.listdir('/etc/'):\n",
    "    lengths.append(len(one_filename))\n",
    "    \n",
    "total = 0      # iterate over the list to get the total length\n",
    "for one_length in lengths:\n",
    "    total += one_length\n",
    "    \n",
    "print(f'Average filename length is {total/len(lengths)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7,\n",
       " 25,\n",
       " 25,\n",
       " 21,\n",
       " 8,\n",
       " 8,\n",
       " 17,\n",
       " 9,\n",
       " 15,\n",
       " 11,\n",
       " 33,\n",
       " 9,\n",
       " 11,\n",
       " 20,\n",
       " 20,\n",
       " 11,\n",
       " 9,\n",
       " 17,\n",
       " 3,\n",
       " 27,\n",
       " 6,\n",
       " 13,\n",
       " 10,\n",
       " 10,\n",
       " 9,\n",
       " 21,\n",
       " 6,\n",
       " 4,\n",
       " 20,\n",
       " 21,\n",
       " 8,\n",
       " 18,\n",
       " 16,\n",
       " 27,\n",
       " 13,\n",
       " 7,\n",
       " 3,\n",
       " 14,\n",
       " 11,\n",
       " 8,\n",
       " 18,\n",
       " 5,\n",
       " 8,\n",
       " 9,\n",
       " 24,\n",
       " 8,\n",
       " 10,\n",
       " 19,\n",
       " 3,\n",
       " 6,\n",
       " 18,\n",
       " 7,\n",
       " 21,\n",
       " 18,\n",
       " 8,\n",
       " 4,\n",
       " 9,\n",
       " 14,\n",
       " 20,\n",
       " 5,\n",
       " 5,\n",
       " 14,\n",
       " 21,\n",
       " 4,\n",
       " 15,\n",
       " 22,\n",
       " 9,\n",
       " 7,\n",
       " 20,\n",
       " 21,\n",
       " 12,\n",
       " 7,\n",
       " 13,\n",
       " 6,\n",
       " 15,\n",
       " 16,\n",
       " 11,\n",
       " 5,\n",
       " 5,\n",
       " 5,\n",
       " 5,\n",
       " 8,\n",
       " 11,\n",
       " 8,\n",
       " 10,\n",
       " 12,\n",
       " 7,\n",
       " 11,\n",
       " 3,\n",
       " 8,\n",
       " 16,\n",
       " 10,\n",
       " 7,\n",
       " 9,\n",
       " 17,\n",
       " 19,\n",
       " 22,\n",
       " 15,\n",
       " 12,\n",
       " 24,\n",
       " 9,\n",
       " 11,\n",
       " 8,\n",
       " 18,\n",
       " 19,\n",
       " 12,\n",
       " 12,\n",
       " 8,\n",
       " 15,\n",
       " 15,\n",
       " 10,\n",
       " 3,\n",
       " 19,\n",
       " 10,\n",
       " 5,\n",
       " 3,\n",
       " 13,\n",
       " 10,\n",
       " 12,\n",
       " 25,\n",
       " 22,\n",
       " 22,\n",
       " 26,\n",
       " 5,\n",
       " 16,\n",
       " 7,\n",
       " 5,\n",
       " 10,\n",
       " 29,\n",
       " 8,\n",
       " 28,\n",
       " 13,\n",
       " 11,\n",
       " 3,\n",
       " 13,\n",
       " 20,\n",
       " 8,\n",
       " 8,\n",
       " 7,\n",
       " 10,\n",
       " 5,\n",
       " 7,\n",
       " 37,\n",
       " 3,\n",
       " 25,\n",
       " 11,\n",
       " 22,\n",
       " 9,\n",
       " 9,\n",
       " 8,\n",
       " 4,\n",
       " 8,\n",
       " 8,\n",
       " 12,\n",
       " 8,\n",
       " 6,\n",
       " 8,\n",
       " 14,\n",
       " 14,\n",
       " 15,\n",
       " 7,\n",
       " 11,\n",
       " 14]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lengths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average filename length is 12.423312883435583\n"
     ]
    }
   ],
   "source": [
    "# what's the average length of a filename in /etc/?\n",
    "\n",
    "import os   # use the \"operating system\" module in Python\n",
    "\n",
    "lengths = [ ]  # build up the list from nothing with info collected\n",
    "for one_filename in os.listdir('/etc/'):\n",
    "    lengths.append(len(one_filename))\n",
    "\n",
    "print(f'Average filename length is {sum(lengths)/len(lengths)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: abc\n",
      "Enter a word: defg\n",
      "Enter a word: hijklmnop\n",
      "Enter a word: \n",
      "Average length is 5.333333333333333\n"
     ]
    }
   ],
   "source": [
    "# Ask the user to enter a bunch of words, one at a time\n",
    "# If the user enters an empty string, stop asking\n",
    "# Print the average length of the words they gave \n",
    "\n",
    "lengths = []\n",
    "while True:\n",
    "    s = input(\"Enter a word: \").strip()\n",
    "    \n",
    "    if s == '':\n",
    "        break\n",
    "        \n",
    "    lengths.append(len(s))\n",
    "    \n",
    "print(f'Average length is {sum(lengths)/len(lengths)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a word: this\n",
      "Enter a word: is\n",
      "Enter a word: a\n",
      "Enter a word: test\n",
      "Enter a word: sentence\n",
      "Enter a word: broken\n",
      "Enter a word: up\n",
      "Enter a word: into\n",
      "Enter a word: many\n",
      "Enter a word: words\n",
      "Enter a word: \n"
     ]
    }
   ],
   "source": [
    "# Ask the user to enter words, one at a time\n",
    "# When they enter an empty string, stop asking\n",
    "#  and print the first and last words, alphabetically, \n",
    "#  that the user entered\n",
    "\n",
    "words = []\n",
    "while True:\n",
    "    s = input(\"Enter a word: \").strip()\n",
    "    \n",
    "    if s == '':\n",
    "        break\n",
    "        \n",
    "    words.append(s)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['this',\n",
       " 'is',\n",
       " 'a',\n",
       " 'test',\n",
       " 'sentence',\n",
       " 'broken',\n",
       " 'up',\n",
       " 'into',\n",
       " 'many',\n",
       " 'words']"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if we sort the list, the first element is the earliest ,\n",
    "# and the last element is the last alphabetically\n",
    "\n",
    "words.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First word is a\n",
      "Last word is words\n"
     ]
    }
   ],
   "source": [
    "print(f'First word is {words[0]}')\n",
    "print(f'Last word is {words[-1]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [10, 20, 30, 40, 50, 60]\n",
    "\n",
    "# remove based on location\n",
    "mylist.pop()   # remove + return the elmement at -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "# stack is known as a LIFO -- last in, first out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to remove from somewhere that's *not* the end, use \"pop\" with an index\n",
    "\n",
    "mylist.pop(2)  # remove + return the item at index 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 40]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# remove based on value\n",
    "mylist.remove(20)  # removes the leftmost item with this value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 40]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "removed = mylist.pop() \n",
    "removed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [10, 20, 30, 40, 50]\n",
    "alias = mylist\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50, 60]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.append(60)\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50, 60]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 50, 60]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.pop(3)\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 50, 60]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [10, 20, 30, 40, 50]\n",
    "alias = mylist.copy()   # returns a copy of mylist... same content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, [40, 50, 60]]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# add multiple things to a list\n",
    "\n",
    "mylist = [10, 20, 30]\n",
    "other_stuff = [40, 50, 60]\n",
    "\n",
    "mylist.append(other_stuff)\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50, 60]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to REALLY add multiple things to a list\n",
    "\n",
    "mylist = [10, 20, 30]\n",
    "other_stuff = [40, 50, 60]\n",
    "\n",
    "# extend runs a \"for\" loop on other_stuff, appending each item to mylist\n",
    "mylist.extend(other_stuff)  \n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 'abcd']"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [10, 20, 30]\n",
    "mylist.append('abcd')\n",
    "\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 'abcd', 'e', 'f', 'g', 'h']"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist.extend('efgh')\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 40, 50, 60]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# += is almost identical to extend\n",
    "mylist = [10, 20, 30]\n",
    "mylist += [40, 50, 60]\n",
    "\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 10, 10, 20, 20, 30, 40, 50, 40, 30, 20]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist = [10, 10, 10, 20, 20, 30, 40, 50, 40, 30, 20]\n",
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 5, 6, 10, 12, 15, 30]"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# instead of using the \"sort\" method on a list, \n",
    "# many people nowadays suggest using the \"sorted\" function\n",
    "\n",
    "mylist = [10, 5, 30, 2, 12, 15, 6]\n",
    "\n",
    "sorted(mylist)  # returns a new , sorted list -- "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 5, 30, 2, 12, 15, 6]"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c']"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted('cba')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.428571428571429"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(mylist) / len(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(sum(mylist) / len(mylist))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.43"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(sum(mylist) / len(mylist),    2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}