Lesson 11 -- 2020 June 5.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.8.3 (default, May 27 2020, 20:54:22) \\n[Clang 11.0.3 (clang-1103.0.32.59)]'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 100\n"
     ]
    }
   ],
   "source": [
    "x = 100\n",
    "print(f'x = {x}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x=100\n"
     ]
    }
   ],
   "source": [
    "print(f'{x=}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MEAP -- Manning Early Action Purchase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "print(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# This is a headline\n",
    "\n",
    "This is some text.  It even has a [hyperlink](https://lerner.co.il)  in it.\n",
    "\n",
    "- Thing 1\n",
    "- Thing 2\n",
    "- Thing 3 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Read through nums.txt, and sum the numbers. (There’s a blank line in there, so you’ll need to deal with that!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tSo far, total=5\n",
      "\tSo far, total=15\n",
      "\tSo far, total=35\n",
      "\tSo far, total=38\n",
      "\tSo far, total=58\n",
      "\tSo far, total=83\n",
      "total = 83\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "\n",
    "for one_line in open('nums.txt'):\n",
    "    if one_line.strip() != '':\n",
    "        total += int(one_line)\n",
    "        print(f'\\tSo far, {total=}')\n",
    "print(f'total = {total}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total = 0\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "\n",
    "for one_line in open('nums.txt'):\n",
    "    if one_line.strip().isdigit():\n",
    "        total += int(one_line)\n",
    "        print(f'\\tSo far, {total=}')\n",
    "print(f'total = {total}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'12345\\n'.isdigit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Read through linux-etc-passwd.txt, a version of what we discussed in class. Print all of the usernames that you see. And yes, you’ll need to avoid two types of lines — comments and blank lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "root\n",
      "daemon\n",
      "bin\n",
      "sys\n",
      "sync\n",
      "games\n",
      "man\n",
      "lp\n",
      "mail\n",
      "news\n",
      "uucp\n",
      "proxy\n",
      "www-data\n",
      "backup\n",
      "list\n",
      "irc\n",
      "gnats\n",
      "nobody\n",
      "syslog\n",
      "messagebus\n",
      "landscape\n",
      "jci\n",
      "sshd\n",
      "user\n",
      "reuven\n",
      "postfix\n",
      "colord\n",
      "postgres\n",
      "dovecot\n",
      "dovenull\n",
      "postgrey\n",
      "debian-spamd\n",
      "memcache\n",
      "genadi\n",
      "shira\n",
      "atara\n",
      "shikma\n",
      "amotz\n",
      "mysql\n",
      "clamav\n",
      "amavis\n",
      "opendkim\n",
      "gitlab-redis\n",
      "gitlab-psql\n",
      "git\n",
      "opendmarc\n",
      "dkim-milter-python\n",
      "deploy\n",
      "redis\n"
     ]
    }
   ],
   "source": [
    "for one_line in open('linux-etc-passwd.txt'):\n",
    "    # if one_line.lstrip().startswith('#'):\n",
    "    if one_line.startswith('#'):\n",
    "        continue  # go back to the \"for\" loop, and start the next iteration\n",
    "        \n",
    "    if one_line.startswith('\\n'):\n",
    "        continue\n",
    "        \n",
    "    fields = one_line.split(':')\n",
    "    print(fields[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Now for the real challenge: The Unix wc program is a “word count” utility, which tells you how many words, lines, and characters there are in a file. Write a program that will report the number of lines, words (separated by spaces), and characters (yes, including whitespace) there are in a file. There’s a file, wcfile.txt, that tells you what the answers should be."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 11  28 165 wcfile.txt\r\n"
     ]
    }
   ],
   "source": [
    "# wc == word count\n",
    "\n",
    "!wc wcfile.txt  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'lines': 11, 'characters': 165, 'words': 28}\n"
     ]
    }
   ],
   "source": [
    "counts = {'lines':0,\n",
    "         'characters':0,\n",
    "         'words':0}\n",
    "\n",
    "for one_line in open('wcfile.txt'):\n",
    "    counts['lines'] += 1    # add 1 to our count of lines\n",
    "    counts['characters'] += len(one_line)\n",
    "    counts['words'] += len(one_line.split())\n",
    "    \n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a test file.\r\n",
      "\r\n",
      "It contains 28 words and 20 different words.\r\n",
      "\r\n",
      "It also contains 165 characters.\r\n",
      "\r\n",
      "It also contains 11 lines.\r\n",
      "\r\n",
      "It is also self-referential.\r\n",
      "\r\n",
      "Wow!\r\n"
     ]
    }
   ],
   "source": [
    "!cat wcfile.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<_io.TextIOWrapper name='/etc/passwd' mode='r' encoding='UTF-8'>\n"
     ]
    }
   ],
   "source": [
    "f = open('/etc/passwd')\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'##\\n# '"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.read(5)  # get 5 characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnsupportedOperation",
     "evalue": "not writable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnsupportedOperation\u001b[0m                      Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-87f096e8ba98>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'abcd'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mUnsupportedOperation\u001b[0m: not writable"
     ]
    }
   ],
   "source": [
    "f.write('abcd')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# when you open a file in 'w' mode, one of these will happen:\n",
    "\n",
    "# (1) the file is opened for writing AND ALL PREVIOUS CONTENTS ARE ERASED!\n",
    "# (2) you get an exception/error that you cannot open the file for writing\n",
    "\n",
    "f = open('myfile.txt', 'w')  # second argument 'w' means: write mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<_io.TextIOWrapper name='myfile.txt' mode='w' encoding='UTF-8'>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "ename": "UnsupportedOperation",
     "evalue": "not readable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnsupportedOperation\u001b[0m                      Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-32-8013280f4ff8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mUnsupportedOperation\u001b[0m: not readable"
     ]
    }
   ],
   "source": [
    "f.read(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.write('abcd\\n')   # The 'write' method DOES NOT AUTOMATICALLY add \\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.write('efghij\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.write('klmnopqrs\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# when we write to a file, the OS actually writes that data to a memory \"buffer\"\n",
    "# when the buffer fills up (every so often), the contents are \"flushed\" to disk\n",
    "\n",
    "# use the \"flush\" method to force a flush  -- don't do this!\n",
    "f.flush()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# another way to force data to be flushed is to close the file\n",
    "# when the file is closed, it's automatically flushed\n",
    "\n",
    "f.write('+++abcd\\n')\n",
    "f.write('---abcd\\n')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd\r\n",
      "efghij\r\n",
      "klmnopqrs\r\n"
     ]
    }
   ],
   "source": [
    "!cat myfile.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.close()  # flush + close"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abcd\r\n",
      "efghij\r\n",
      "klmnopqrs\r\n",
      "+++abcd\r\n",
      "---abcd\r\n"
     ]
    }
   ],
   "source": [
    "!cat myfile.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "I/O operation on closed file.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-41-d65dab144a9b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'qqqqq\\n'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: I/O operation on closed file."
     ]
    }
   ],
   "source": [
    "f.write('qqqqq\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the \"with\" keyword\n",
    "\n",
    "with open('myfile.txt', 'w') as f:\n",
    "    f.write('aaabbb\\n')\n",
    "    f.write('cccdddddd\\n')\n",
    "    f.write('eeefffff\\n')\n",
    "    # at the end of the \"with\" block, the file is flushed + closed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<_io.TextIOWrapper name='myfile.txt' mode='w' encoding='UTF-8'>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aaabbb\r\n",
      "cccdddddd\r\n",
      "eeefffff\r\n"
     ]
    }
   ],
   "source": [
    "!cat myfile.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "I/O operation on closed file.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-45-e13f560e0f0d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'zzzz\\n'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: I/O operation on closed file."
     ]
    }
   ],
   "source": [
    "f.write('zzzz\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('myfile.txt', 'a') as f:  # open in \"append\" mode -- write to the end of the file\n",
    "    f.write('even more!\\n')\n",
    "    f.write('more more more\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.closed  # is it closed?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aaabbb\r\n",
      "cccdddddd\r\n",
      "eeefffff\r\n",
      "even more!\r\n",
      "more more more\r\n"
     ]
    }
   ],
   "source": [
    "!cat myfile.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read mode is 'r'\n",
    "# write mode is 'w'\n",
    "# append mode is 'a'\n",
    "\n",
    "# read-write mode is 'r+'  # My advice: avoid it, if you can"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "67.218.116.165 - - [30/Jan/2010:00:03:18 +0200] \"GET /robots.txt HTTP/1.0\" 200 99 \"-\" \"Mozilla/5.0 (Twiceler-0.9 http://www.cuil.com/twiceler/robot.html)\"\r\n",
      "66.249.71.65 - - [30/Jan/2010:00:12:06 +0200] \"GET /browse/one_node/1557 HTTP/1.1\" 200 39208 \"-\" \"Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)\"\r\n",
      "65.55.106.183 - - [30/Jan/2010:01:29:23 +0200] \"GET /robots.txt HTTP/1.1\" 200 99 \"-\" \"msnbot/2.0b (+http://search.msn.com/msnbot.htm)\"\r\n",
      "65.55.106.183 - - [30/Jan/2010:01:30:06 +0200] \"GET /browse/one_model/2162 HTTP/1.1\" 200 2181 \"-\" \"msnbot/2.0b (+http://search.msn.com/msnbot.htm)\"\r\n",
      "66.249.71.65 - - [30/Jan/2010:02:07:14 +0200] \"GET /browse/browse_applet_tab/2593 HTTP/1.1\" 200 10305 \"-\" \"Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)\"\r\n",
      "66.249.71.65 - - [30/Jan/2010:02:10:39 +0200] \"GET /browse/browse_files_tab/2499?tab=true HTTP/1.1\" 200 446 \"-\" \"Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)\"\r\n",
      "66.249.65.12 - - [30/Jan/2010:03:13:34 +0200] \"GET /robots.txt HTTP/1.1\" 200 99 \"-\" \"Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)\"\r\n",
      "66.249.65.12 - - [30/Jan/2010:03:13:34 +0200] \"GET /browse/one_node/2715 HTTP/1.1\" 200 26433 \"-\" \"Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)\"\r\n",
      "66.249.65.12 - - [30/Jan/2010:03:43:39 +0200] \"GET /browse/download_model/1969 HTTP/1.1\" 200 31713 \"-\" \"Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)\"\r\n",
      "66.249.65.12 - - [30/Jan/2010:04:05:43 +0200] \"GET /browse/one_node/1406 HTTP/1.1\" 302 118 \"-\" \"Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)\"\r\n"
     ]
    }
   ],
   "source": [
    "!head mini-access-log.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How can I read through `mini-access-log.txt`, and write the IP addresses to another file?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('ip-address-report.txt', 'w') as outfile:\n",
    "    for one_line in open('mini-access-log.txt'):\n",
    "        ip_address = one_line.split()[0]\n",
    "        outfile.write(f'{ip_address}\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "67.218.116.165\r\n",
      "66.249.71.65\r\n",
      "65.55.106.183\r\n",
      "65.55.106.183\r\n",
      "66.249.71.65\r\n",
      "66.249.71.65\r\n",
      "66.249.65.12\r\n",
      "66.249.65.12\r\n",
      "66.249.65.12\r\n",
      "66.249.65.12\r\n"
     ]
    }
   ],
   "source": [
    "!head ip-address-report.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('ip-address-report.txt', 'w') as outfile, open('mini-access-log.txt') as infile:\n",
    "    for one_line in infile:\n",
    "        ip_address = one_line.split()[0]\n",
    "        outfile.write(f'{ip_address}\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'a':1, 'b':2, 'c':3, 'd':4}\n",
    "\n",
    "with open('mydict.csv', 'w') as outfile:\n",
    "    for key, value in d.items():\n",
    "        outfile.write(f'{key},{value}\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a,1\r\n",
      "b,2\r\n",
      "c,3\r\n",
      "d,4\r\n"
     ]
    }
   ],
   "source": [
    "!cat mydict.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "!open mydict.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'Lesson 10 -- 2020 May 22.ipynb'        Untitled.ipynb\r\n",
      "'Lesson 11 -- 2020 June 5.ipynb'        ip-address-report.txt\r\n",
      "'Lesson 5 -- 2020 April 17.ipynb'       linux-etc-passwd.txt\r\n",
      "'Lesson 6 -- 2020 Apr 24.ipynb'         mini-access-log.txt\r\n",
      "'Lesson 7 -- 2020 May 1.ipynb'\t        movies.dat\r\n",
      "'Lesson 9 -- 2020 May 15.ipynb'         mydict.csv\r\n",
      "'Non-programmers 2020 April 10.ipynb'   myfile.txt\r\n",
      "'Non-programmers 2020 April 3.ipynb'    nums.txt\r\n",
      "'Non-programmers 2020 March 20.ipynb'   shoe-data.txt\r\n",
      "'Non-programmers 2020 March 27.ipynb'   taxi.csv\r\n",
      "'Non-programmers, 2020 May 8.ipynb'     wcfile.txt\r\n",
      " README.md\r\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Useful ! commands (using Unix)\n",
    "\n",
    "- !ls -- directory listing\n",
    "- !pwd -- current directory\n",
    "- !head -- top of a file\n",
    "\n",
    "Sometimes, you can use `%ls` or `%pwd` and Jupyter will understand.\n",
    "\n",
    "!open is special -- is uses the Mac's \"open\" command, which opens a file in its appropriate application."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ip-address-report.txt  mini-access-log.txt  nums.txt\t   wcfile.txt\r\n",
      "linux-etc-passwd.txt   myfile.txt\t    shoe-data.txt\r\n"
     ]
    }
   ],
   "source": [
    "!ls *.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\r\n",
      "\t10     \r\n",
      "\t20\r\n",
      "  \t3\r\n",
      "\t\t   \t20        \r\n",
      "\r\n",
      " 25\r\n"
     ]
    }
   ],
   "source": [
    "!cat nums.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise: Selective number writing\n",
    "\n",
    "1. Ask the user to enter a number\n",
    "2. Read from `nums.txt`, and ignore blank lines.\n",
    "3. Write the line from `nums.txt` to `selected-nums.txt`, only if the number is >= the number that the user gave.\n",
    "\n",
    "If the user enters 10, then we'll write all of the contents of `nums.txt` except for 5 and 3.\n",
    "\n",
    "If the user enters 20, we'll write all of the contents of `nums.txt` except for 5, 10, and 3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 10\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Enter a number: \"))\n",
    "\n",
    "with open('selected-nums.txt', 'w') as outfile:\n",
    "    for one_line in open('nums.txt'):\n",
    "        if one_line.strip() == '':  # ignore blank lines\n",
    "            continue\n",
    "\n",
    "        if int(one_line) < n:\n",
    "            continue\n",
    "\n",
    "        outfile.write(f'{one_line.strip()}\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\r\n",
      "20\r\n",
      "20\r\n",
      "25\r\n"
     ]
    }
   ],
   "source": [
    "!cat selected-nums.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('hello', \n",
    "      file=open('myoutput.txt', 'w'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\r\n"
     ]
    }
   ],
   "source": [
    "!cat myoutput.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a number: 1\n",
      "Enter a number: 10\n",
      "Enter a number: 15\n",
      "Enter a number: 12\n",
      "Enter a number: 14\n",
      "Enter a number: 100\n",
      "Enter a number: 101\n",
      "Enter a number: \n"
     ]
    }
   ],
   "source": [
    "with open('even-nums.txt', 'w') as even_file, open('odd-nums.txt', 'w') as odd_file:\n",
    "    while True:\n",
    "        n = input(\"Enter a number: \").strip()\n",
    "        \n",
    "        if n == '':\n",
    "            break\n",
    "            \n",
    "        if not n.isdigit():\n",
    "            break\n",
    "            \n",
    "        n = int(n)\n",
    "        if n %2 == 1:  # odd number!\n",
    "            print(f'{n}\\n', file=odd_file)\n",
    "        else:\n",
    "            print(f'{n}\\n', file=even_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\r\n",
      "\r\n",
      "15\r\n",
      "\r\n",
      "101\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "!cat odd-nums.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\r\n",
      "\r\n",
      "12\r\n",
      "\r\n",
      "14\r\n",
      "\r\n",
      "100\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "!cat even-nums.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://forum.lerner.co.il"
   ]
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}