Lesson 15 -- 2020 July 3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function that gets a directory name, and returns a dict whose keys are the file extensions (i.e., the stuff at the end, like .txt or .jpg, but following the dot) and whose values are the number of files with such an extension. You’ll likely want to use os.listdir or glob.glob, which work a bit differently; the first is easier to use, if you’re not sure!\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'d': 9,\n",
       " 'd-migrated2launchd': 1,\n",
       " 'system_default': 3,\n",
       " 'applesaved': 14,\n",
       " 'common': 1,\n",
       " 'logout~orig': 1,\n",
       " '2-previous~orig': 1,\n",
       " 'login': 1,\n",
       " 'conf': 16,\n",
       " 'conf~previous': 3,\n",
       " 'keytab': 1,\n",
       " 'logout': 1,\n",
       " 'db': 1,\n",
       " 'lpd': 1,\n",
       " 'passwd~orig': 1,\n",
       " 'user_modified': 1,\n",
       " 'login~orig': 1,\n",
       " 'default-previous': 1,\n",
       " 'conf-previous': 1,\n",
       " 'common~previous': 1,\n",
       " 'default': 2,\n",
       " 'cshrc~orig': 1,\n",
       " 'codes~orig': 1,\n",
       " 'equiv': 1,\n",
       " 'codes': 1,\n",
       " 'ini': 1,\n",
       " 'cshrc': 1,\n",
       " 'hd~previous': 1,\n",
       " 'deprecated': 1,\n",
       " 'rc': 2,\n",
       " 'netboot': 1,\n",
       " 'cfg~orig': 1,\n",
       " 'conf~orig': 1,\n",
       " 'old': 1,\n",
       " 'rc~previous': 1,\n",
       " 'os': 1,\n",
       " 'anchors': 1,\n",
       " 'default-previous~orig': 1,\n",
       " '2-previous': 1,\n",
       " 'passwd': 1,\n",
       " 'hd': 1,\n",
       " 'launchd': 1,\n",
       " 'rc~orig': 1,\n",
       " 'cfg': 1,\n",
       " 'pg': 1}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "def ext_counter(dirname):\n",
    "    output = {}\n",
    "    \n",
    "    for one_filename in os.listdir(dirname):\n",
    "        if '.' not in one_filename:\n",
    "            continue\n",
    "            \n",
    "        ext = one_filename.split('.')[-1]\n",
    "               \n",
    "        if ext in output:  # have we seen this extension before?\n",
    "            output[ext] += 1\n",
    "        else:\n",
    "            output[ext] = 1\n",
    "    \n",
    "    return output\n",
    "\n",
    "ext_counter('/etc/')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The random module includes a function, random.choice, that can return a random element from any sequence (including a string). Write a function that takes a list, chooses a random element from it, and then asks the user to repeatedly guess which element has been chosen. When the user guesses correctly, the function returns the number of guesses it took."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def count_guesses(options):\n",
    "    chosen = random.choice(options)\n",
    "    count = 0\n",
    "\n",
    "    while True:\n",
    "        count += 1\n",
    "        guess = input(\"Enter your guess: \").strip()\n",
    "        \n",
    "        if guess == chosen:\n",
    "            print(f'Right!')\n",
    "            break\n",
    "            \n",
    "        print(f'Wrong!')\n",
    "        \n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your guess: a\n",
      "Wrong!\n",
      "Enter your guess: b\n",
      "Wrong!\n",
      "Enter your guess: c\n",
      "Wrong!\n",
      "Enter your guess: d\n",
      "Right!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count_guesses(['a', 'b', 'c', 'd', 'e', 'f'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a bit harder, but worth trying a bit: The pickle module lets you turn data structures into bytestrings, and back. That’s normally used for storing data on disk and then retrieving it later. You take a data structure and turn it into a bytestring with pickle.dumps, which returns a bytestring. You can then take a bytestring and turn it back into data with pickle.loads. Create a dict in which the keys are strings and the values are ints, strings, and lists (not too many). Use pickle.dumps to turn it into a bytestring. Then turn it back into a data structure… are they the same?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "d = {'a':1, 'b':2, 'c':'this is a test', 'd':[10, 20, 30]}\n",
    "\n",
    "b = pickle.dumps(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'\\x80\\x04\\x954\\x00\\x00\\x00\\x00\\x00\\x00\\x00}\\x94(\\x8c\\x01a\\x94K\\x01\\x8c\\x01b\\x94K\\x02\\x8c\\x01c\\x94\\x8c\\x0ethis is a test\\x94\\x8c\\x01d\\x94]\\x94(K\\nK\\x14K\\x1eeu.'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "also_a_d = pickle.loads(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 'c': 'this is a test', 'd': [10, 20, 30]}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "also_a_d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def count_guesses(options):\n",
    "    chosen = random.choice(options)\n",
    "    print(f'Shh, do not tell the user, but {chosen=}')\n",
    "    already_guessed = []\n",
    "    count = 0\n",
    "\n",
    "    while True:\n",
    "        count += 1\n",
    "        guess = input(\"Enter your guess: \").strip()\n",
    "        \n",
    "        if guess in already_guessed:\n",
    "            print(f'You already guessed {guess} -- try something new!')\n",
    "            count -= 1\n",
    "            continue\n",
    "            \n",
    "        already_guessed.append(guess)\n",
    "\n",
    "        if guess == chosen:\n",
    "            print(f'Right!')\n",
    "            break\n",
    "            \n",
    "        print(f'Wrong!')\n",
    "        \n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shh, do not tell the user, but chosen='b'\n",
      "Enter your guess: c\n",
      "Wrong!\n",
      "Enter your guess: d\n",
      "Wrong!\n",
      "Enter your guess: d\n",
      "You already guessed d -- try something new!\n",
      "Enter your guess: d\n",
      "You already guessed d -- try something new!\n",
      "Enter your guess: d\n",
      "You already guessed d -- try something new!\n",
      "Enter your guess: d\n",
      "You already guessed d -- try something new!\n",
      "Enter your guess: b\n",
      "Right!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count_guesses(['a', 'b', 'c', 'd', 'e', 'f'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hey, I found a problem.  You should address it.\n"
     ]
    }
   ],
   "source": [
    "x = [10, 20, 30]\n",
    "\n",
    "try:\n",
    "    print(x[99999])\n",
    "except:\n",
    "    print(f'Hey, I found a problem.  You should address it.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# comprehension"
   ]
  }
 ],
 "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
}