DS109-Python/DS109-L7-Modules.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "50e6ddbb-52d3-4a02-9b69-100a4181e3b0",
   "metadata": {},
   "source": [
    "# DS109 Python : Lesson Seven Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1bd4bfc-9b15-4b80-87b4-b8b60eb56371",
   "metadata": {},
   "source": [
    "### Table of Contents <a class=\"anchor\" id=\"DS109L7_toc\"></a>\n",
    "\n",
    "* [Table of Contents](#DS109L7_toc)\n",
    "    * [Page 1 - Standard Library Intro](#DS109L7_page_1)\n",
    "    * [Page 2 - Standard Library](#DS109L7_page_2)\n",
    "    * [Page 3 - Modules](#DS109L7_page_3)\n",
    "    * [Page 4 - Python Standard Modules](#DS109L7_page_4)\n",
    "    * [Page 5 - The **math** Module](#DS109L7_page_5)\n",
    "    * [Page 6 - Modules Activity](#DS109L7_page_6)\n",
    "    * [Page 7 - **pip** Packages](#DS109L7_page_7)\n",
    "    * [Page 8 - Accessing and Modifying Files](#DS109L7_page_8)\n",
    "    * [Page 9 - Reading From And Writing To Files](#DS109L7_page_9)\n",
    "    * [Page 10 - Updating File Strings](#DS109L7_page_10)\n",
    "    * [Page 11 - Lesson 7 Practice Hands-On](#DS109L7_page_11)\n",
    "    * [Page 12 - Lesson 7 Practice Hands-On Solution](#DS109L7_page_12)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef5a8c65-ed48-4354-a257-e01b0fd733d4",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 1 - Standard Library Intro<a class=\"anchor\" id=\"DS109L7_page_1\"></a>\n",
    "\n",
    "[Back to Top](#DS109L7_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0dfbfeea-f279-4a69-ae97-14c70fe0e614",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/238447925\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x7fefa10eb100>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Standard Library\n",
    "VimeoVideo('238447925', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b6ad526-95fa-43c4-bc43-1fe807708ed3",
   "metadata": {},
   "source": [
    "# Standard Library Intro\n",
    "\n",
    "Thus far, you have learned about the fundamentals of programming in Python, and you've seen and used several data types and keywords that are built into the language. Python also has a _standard library_, that has an extensive range of built-in modules that provide access to system functionality. In this lesson, you will learn about Python's standard library and a few of the more widely-used Python packages that are built and shared by third-party developers.\n",
    "\n",
    "---\n",
    "## Setup\n",
    "\n",
    "1. First, open up your command prompt/terminal\n",
    "2. Now that you are in your command prompt/terminal, run the following command:\n",
    "    ```text\n",
    "    cd desktop\n",
    "    ```\n",
    "3. Next, move your command prompt/terminal's location to the new `python_course` you just created by running the following:\n",
    "    ```text\n",
    "    cd python_course\n",
    "    ```\n",
    "4. Create a _new_ directory within the `python_course` directory. This new folder is the project you will be working in for this lesson. Run the following:\n",
    "    ```text\n",
    "    mkdir lesson_seven\n",
    "    ```\n",
    "5. Open up a new window in VSCode.\n",
    "6. Open the `lesson_seven` directory in VSCode\n",
    "7. Create a new file named `main.py`\n",
    "\n",
    "Once the `main.py` file is created, you are ready to go! As you work through this lesson, add the code examples into your project so you can see the output yourself. Remember, to see the output within the VSCode terminal, right-click within your file and choose \"Run Python File in Terminal\".\n",
    "\n",
    "The creation of this new project is for you to practice your new skills. It is highly recommended that you add the code from this lesson into your `lesson_seven` project as you learn it. As you are going through this lesson and adding code to your project, you may find it helpful to include `comments` with a brief sentence explaining what is going on in the code. That way, you will have an easy reference to the topics explained in this lesson. Happy coding!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7990ac7a-5a2f-4744-af14-1b7e385ea484",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 2 - Standard Library<a class=\"anchor\" id=\"DS109L7_page_2\"></a>\n",
    "\n",
    "[Back to Top](#DS109L7_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "612429df-e4ef-4d85-8460-5bc8914079c3",
   "metadata": {},
   "source": [
    "# Standard Library\n",
    "\n",
    "Python's standard library contains data types, built-in functions, and exceptions as well as objects that can be used by _all_ Python code. The bulk of the library consists of a collection of modules. Some of these modules are written in the C language and built into the Python interpreter; others are written in Python and must be imported. Some of these modules provide interfaces that are specific to particular operating systems, such as access to a specific piece of hardware.\n",
    "\n",
    "You've already seen several of the built-in functions that are part of the Python standard library. The most common one you've seen thus far is `print()`, which outputs information to the standard output device (which has been VS Code's integrated terminal so far). You've also seen `len()`, which returns the number of items in a collection or the number of characters in a text string.\n",
    "\n",
    "Some other built-in functions you'll find useful are `str()`, which is used to convert the given object into a _string_; `min()`, which returns the smallest value in a collection or a list of two or more arguments.\n",
    "\n",
    "```python\n",
    "pi = 3.14159\n",
    "pi_string = str(pi)\n",
    "print(\"The value of Pi is \" + pi_string)\n",
    "\n",
    "number_list = [33, 19, 25, 7, 18]\n",
    "min_number = min(number_list)\n",
    "print(\"The minimum number in the list is \" + str(min_number))\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "The value of Pi is 3.14159\n",
    "The minimum number in the list is 7\n",
    "```\n",
    "\n",
    "You can read about all of the available built-in function of Python's library at the link below:\n",
    "\n",
    "> [View the built-in functions of the Python standard library](https://docs.python.org/3/library/functions.html).\n",
    "\n",
    "Next you will learn about a few Python standard modules that you can use for specific functionality. However, in order to use them, you need to learn about modules and importing them into your program.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "832358fd-55fa-420a-8aa2-46fbf2097986",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 3 - Modules<a class=\"anchor\" id=\"DS109L7_page_3\"></a>\n",
    "\n",
    "[Back to Top](#DS109L7_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f564e3e7-3a7f-4936-b3a3-2e0a9ab78512",
   "metadata": {},
   "source": [
    "# Modules\n",
    "\n",
    "A `module` is groups of related code, including classes and functions, that allows you to logically organize your Python code. Creating modules of re-usable code is the goal. As you grow into developing Python programs, you'll eventually find yourself writing the same or similar functions and classes in several of them. Putting that code in modules and importing them into your new program will save you time and money.\n",
    "\n",
    "The most straightforward approach to creating a module is placing the related code into a single Python file, with the extension \".py\" as you've seen throughout this course. In it, you would place your variables, classes, and functions. Once you've created a module, you can reuse the code by importing it into your new code. This mechanism, thus, allows you to import code from other developers to use in your programs.\n",
    "\n",
    "**OLD**\n",
    "To illustrate, go ahead and create two files in the same directory (folder). Name one of them `icecream.py` and the other `icecream_cone.py`.\n",
    "\n",
    "**NEW**\n",
    "\"To illustrate, go ahead and create two files in the same directory (folder) that you created on page 1. Name one of the files  icecream.py and the other file icecream_cone.py.\"\n",
    "\n",
    "Add the following code snippet to the `icecream.py` file.\n",
    "\n",
    "<b>icecream.py</b> file:\n",
    "\n",
    "```python\n",
    "def scoop_icecream(size, *toppings):\n",
    "    \"\"\"Give a summary of the ice cream cone you are making.\"\"\"\n",
    "\n",
    "    print(\"\\nMaking a \" + size + \" ice cream cone with the following toppings:\")\n",
    "    for topping in toppings:\n",
    "        print(\"- \" + topping)\n",
    "```\n",
    "\n",
    "Next, in your `icecream_cone.py` file add the following:\n",
    "\n",
    "<b>icecream_cone.py</b> file:\n",
    "\n",
    "```python\n",
    "import icecream\n",
    "\n",
    "icecream.scoop_icecream('small', 'sprinkles', 'chocolate', 'cherries')\n",
    "icecream.scoop_icecream('large', 'peanuts')\n",
    "```\n",
    "\n",
    "Run the file in the terminal and you should see the output below.\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```text\n",
    "Making a small ice cream cone with the following toppings:\n",
    "- sprinkles\n",
    "- chocolate\n",
    "- cherries\n",
    "\n",
    "Making a large ice cream cone with the following toppings:\n",
    "- peanuts\n",
    "```\n",
    "\n",
    "Now, these code samples will be broken down to help you understand what's going on.\n",
    "\n",
    "Starting with the `icecream.py` file:\n",
    "\n",
    "- The function `scoop_icecream` is defined with two parameters `size` and `toppings`. The asterisk `*` in front of the `toppings` parameter indicates that you can pass in one or more values for toppings when calling the function.\n",
    "\n",
    "- The function `scoop_icecream`, when called, prints to the console a message that includes the passed values of `size` and `toppings`. Due to the `*` you see preceding the `toppings` parameter, you can treat `toppings` like a collection, which is why you see the `for` loops to print the toppings.\n",
    "\n",
    "Next, the `icecream_cone.py` file:\n",
    "\n",
    "- `import icecream` - This line pulls in (imports) the code from the other file `icecream.py`, giving you access to the `scoop_icecream` function defined in it. The keyword `import` is followed by the name of the file __without__ the `py` extension. You never add the `py` extension when you import files.\n",
    "\n",
    "- The next two lines call the function `scoop_icecream` that was imported, passing in different sets of toppings (remember the *). As you can see, the function name is prefixed with `icecream.`, which is the name of the module file and a dot. So, when calling an imported function, you see that you specify the module file name, followed by a dot `.`, then the function name. You will see variations to this shortly.\n",
    "\n",
    "---\n",
    "## import\n",
    "\n",
    "The keyword `import` tells Python to open the file and copy all the function from it into the current program. You do not see this occurring, though; Python does all of this behind the scenes as the program runs. Once imported, any function that is in the targeted file will be available in your current file.\n",
    "\n",
    "You can import an entire module, making every function and class it contains available to your program:\n",
    "\n",
    "```python\n",
    "import icecream\n",
    "```\n",
    "\n",
    "---\n",
    "## Using Functions from Imported Module\n",
    "\n",
    "To call a function from an imported module, enter the name of the module you imported, followed by the name of the function separated by a dot(`.`).\n",
    "\n",
    "Here is the syntax used to invoke a function from an imported module.\n",
    "\n",
    "```python\n",
    "module_name.function_name()\n",
    "```\n",
    "\n",
    "---\n",
    "## Importing Specific Functions\n",
    "\n",
    "If a module is large, but you only need one function, there's no point plugging up memory with unnecessary code; you can import a single function. Below is the general syntax:\n",
    "\n",
    "```python\n",
    "from module_name import function_name\n",
    "```\n",
    "\n",
    "Above, you can see the keywords `from` and `import` are used. When importing a specific function, you use the `from` keyword to specify the module from which it will be imported. You then use the `import` keyword to specify the specific function you wish to import.\n",
    "\n",
    "You can also import as many functions as you would like from a module by separating each function name with a comma like so:\n",
    "\n",
    "```python\n",
    "from module_name import function_1, function_2, function_3\n",
    "```\n",
    "\n",
    "Below shows an example of importing one function using the ice cream example:\n",
    "\n",
    "```python\n",
    "from icecream import scoop_icecream\n",
    "```\n",
    "\n",
    "When you import a function in this fashion, you no longer need to use the dot notation when calling the function. Instead of doing _module.function()_, you can simply do _function()_. In the example below, the `scoop_icecream()` function is imported specifically, and then called:\n",
    "\n",
    "```python\n",
    "from icecream import scoop_icecream\n",
    "\n",
    "scoop_icecream('small', 'sprinkles', 'chocolate', 'cherries')\n",
    "```\n",
    "\n",
    "---\n",
    "## as\n",
    "\n",
    "When you import a module, what if there's a function that is defined that has the same name as a function in the new file, or in another module you've already imported? Fortunately, Python provides a mechanism for giving an imported function an alias: `as`.\n",
    "\n",
    "```python\n",
    "from icecream import scoop_icecream as scoop\n",
    "\n",
    "scoop('small', 'sprinkles', 'chocolate', 'cherries')\n",
    "```\n",
    "\n",
    "The `import` statement above renames the function `scoop_icecream()` to `scoop()` in this specific file. Anytime you want to call `scoop_icecream()`, you can now call `scoop()` instead.\n",
    "\n",
    "In general, the syntax is as follows:\n",
    "\n",
    "```python\n",
    "from module_name import function_name as alias\n",
    "```\n",
    "\n",
    "Not only can functions be given an alias, but modules can be given an alias as well. Giving a module a short alias like `i` for `icecream` allows you to call the module's functions more quickly. Calling `i.scoop_icecream()` is more concise than calling `icecream.scoop_icecream()`.\n",
    "\n",
    "```python\n",
    "import icecream as i\n",
    "\n",
    "i.scoop_icecream('small', 'sprinkles', 'chocolate', 'cherries')\n",
    "```\n",
    "\n",
    "When giving the module an alias, remember that all the function names will retain their original names. Calling `i.scoop_icecream()` is not only more concise than writing `icecream.scoop_icecream()`, but also directs your attention from the module name and allows you to focus on the more descriptive names of the functions. The function names, which tell you what each function does, are more important to the readability of your code than using full module names.\n",
    "\n",
    "The general syntax for assigning an alias to a module is:\n",
    "\n",
    "```python\n",
    "import module_name as alias\n",
    "```\n",
    "\n",
    "---\n",
    "## Importing All Functions\n",
    "\n",
    "You can tell Python to import every function from a module by using the asterisk `*` operator. Of course, anytime you import a large amount of functionality, be sure to check if there are any conflicts.\n",
    "\n",
    "```python\n",
    "from icecream import *\n",
    "\n",
    "scoop_icecream('small', 'sprinkles', 'chocolate', 'cherries')\n",
    "```\n",
    "\n",
    "In the example above, all functions are imported using the `*` (although there's currently only one function in the file). This allows for the use of the function name without having to include the module name and dot notation for all of the imported functions.\n",
    "\n",
    "----\n",
    "## Importing Classes\n",
    "\n",
    "What you learned about importing a specific, multiple, or all functions also applies to classes. The general syntax for importing a class is below:\n",
    "\n",
    "```python\n",
    "from module_name import class_name[, more_class_names]|*\n",
    "```\n",
    "\n",
    "The above general notation includes some syntax you've not yet seen. The square brackets `[]` indicate something is optional. Above, this mean that you can import a class name and optionally more class names separated by a comma. The pipe symbol `|` is used to separate options from which you choose one. Above, the option is to either choose one or more class names or to use the asterisk `*` to import all of them.\n",
    "\n",
    "Also, when importing a specific class, you can set an alias just like you can with a function. You can even import functions and classes, both with aliases, in a simple import statement.\n",
    "\n",
    "```python\n",
    "from module_name import function_name as function_alias, class_name as class_alias\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb1aade2-59af-4cbc-b5ed-da31e39f266d",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 4 - Python Standard Modules<a class=\"anchor\" id=\"DS109L7_page_4\"></a>\n",
    "\n",
    "[Back to Top](#DS109L7_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eba2ed6e-98dd-43f7-8761-6ecc9a13af08",
   "metadata": {},
   "source": [
    "# Python Standard Modules\n",
    "\n",
    "Now that you understand modules, you will be introduced to Python's library of standard modules. To start off, Python includes two modules that are useful for interacting with the Python system itself. These modules are `sys` and `keyword`. The `keyword` module contains a list of all Python reserved keywords. The `sys` module allows you to explore many features including the _Interactive Mode_ help system.\n",
    "\n",
    "----\n",
    "## sys\n",
    "\n",
    "To import this module, the syntax is the same as if you were importing a module you created.\n",
    "\n",
    "```python\n",
    "import sys\n",
    "```\n",
    "\n",
    "Now that `sys` (or _system_) has been imported, you can access the version of Python:\n",
    "\n",
    "```python\n",
    "import sys\n",
    "\n",
    "print('Python Version:', sys.version)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```html\n",
    "Python Version: 3.6.2 (v3.6.2:5fd33b5926, Jul 16 2017, 20:11:06)\n",
    "[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)]\n",
    "```\n",
    "\n",
    "What if you wanted to locate the Python interpreter?\n",
    "\n",
    "**INPUT:**\n",
    "\n",
    "```python\n",
    "import sys\n",
    "\n",
    "print('Interpreter Location:', sys.executable)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```html\n",
    "Interpreter Location: /Library/Frameworks/Python.framework/Versions/3.6/bin/python3\n",
    "```\n",
    "\n",
    "---\n",
    "## keyword\n",
    "\n",
    "Like for `sys`, you need to import this module:\n",
    "\n",
    "```python\n",
    "import keyword\n",
    "```\n",
    "\n",
    "With the `keyword` library, you can print out a list of Python's reserved keywords with the following syntax:\n",
    "\n",
    "```python\n",
    "import keyword\n",
    "\n",
    "print('Keywords: ')\n",
    "for word in keyword.kwlist:\n",
    "    print(word)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```html\n",
    "Keywords:\n",
    "False\n",
    "None\n",
    "True\n",
    "and\n",
    "as\n",
    "assert\n",
    "break\n",
    "class\n",
    "continue\n",
    "def\n",
    "del\n",
    "elif\n",
    "else\n",
    "except\n",
    "finally\n",
    "for\n",
    "from\n",
    "global\n",
    "if\n",
    "import\n",
    "in\n",
    "is\n",
    "lambda\n",
    "nonlocal\n",
    "not\n",
    "or\n",
    "pass\n",
    "raise\n",
    "return\n",
    "try\n",
    "while\n",
    "with\n",
    "yield\n",
    "```\n",
    "\n",
    "You can also check to see if a word you'd like to use is a reserved keyword or not by using the `iskeyword()` method.\n",
    "\n",
    "```python\n",
    "import keyword\n",
    "\n",
    "print(keyword.iskeyword('def'))\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```html\n",
    "True\n",
    "```\n",
    "\n",
    "Python returns `True`, in the above example, because `def` is a reserved keyword (used to define a function).\n",
    "\n",
    "Many developers that use Python perform a lot of mathematical operations, and Python has a math module with numerous built-in functions that you will learn about next.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ead4ad3c-2fe6-457e-8924-1410e951bebd",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 5 - The **math** Module<a class=\"anchor\" id=\"DS109L7_page_5\"></a>\n",
    "\n",
    "[Back to Top](#DS109L7_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbbc06a2-e702-47a1-942f-cbcbe31221a7",
   "metadata": {},
   "source": [
    "# The **math** Module\n",
    "\n",
    "Python's library also includes a `math` module that provides a plethora of methods you can use to perform mathematical operations.\n",
    "\n",
    "Importing the `math` modules into your code will give you access to such functions as `floor()` and `ceil()`. The first rounds a floating point number down to the nearest integer, while the second rounds up.\n",
    "\n",
    "* **`math.ceil()`** - This function rounds **up** to the nearest integer.\n",
    "* **`math.floor()`** - This function rounds **down** to the nearest integer.\n",
    "\n",
    "If you were to print out the results of a call to these functions, you would see that although they are whole number integers, the data type is still a float. So, instead of 4, you'd see 4.0, for example.\n",
    "\n",
    "You'll also have access to functions like `pow()` and `sqrt()`:\n",
    "\n",
    "* **`math.pow(x,y)`** - This function returns a float of _x_ raised to the power _y_.\n",
    "* **`math.sqrt(x)`** - This functions returns a float of the square root of _x_.\n",
    "\n",
    "Below you'll find an example of each of the above functions. Take note of the first comment to remind you about importing entire modules and the need for dot syntax.\n",
    "\n",
    "```python\n",
    "# since the entire module is imported, the module name\n",
    "# must precede the function names (dot syntax)\n",
    "import math\n",
    "\n",
    "# round 8.5 down using `floor`\n",
    "print(\"Round the number 8.5 down: \", math.floor(8.5))\n",
    "\n",
    "# round 8.5 up using `ceil`\n",
    "print(\"Round the number 8.5 up: \", math.ceil(8.5))\n",
    "\n",
    "# compute 5^10 using `pow`\n",
    "print(\"5 to the power of 10 = \", math.pow(5, 10))\n",
    "\n",
    "# compute the square root of 82 using `sqrt`\n",
    "print(\"The Square Root of 82 is: \", math.sqrt(82))\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```html\n",
    "8\n",
    "9\n",
    "5 to the power of 10 =  9765625.0\n",
    "The Square Root of 82 is:  9.055385138137417\n",
    "```\n",
    "\n",
    "---\n",
    "## The **random** Module\n",
    "\n",
    "Python includes a `random` module that can be used to produce pseudo-random numbers once imported into a program. Below are a few of the functions that are available from the `random` module.\n",
    "\n",
    "* **`random.random()`** - Produces a single floating-point number between `0` and `1.0`.\n",
    "* **`random.sample()`** - Produces a list of elements selected at random from a sequence. This function requires two arguments to specify the sequence to select from, and the length of the list to be produced. Using the `range()` function will allow you to specify a sequence as the first argument.\n",
    "\n",
    "Using the `random` module, here's an example of using `random.random()`:\n",
    "\n",
    "```python\n",
    "import random\n",
    "\n",
    "print(\"A random float between 0 - 1.0: \", random.random())\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```html\n",
    "A random float between 0 - 1.0:  0.7939999233344973\n",
    "```\n",
    "\n",
    "Now, the second function `random.sample()`:\n",
    "\n",
    "```python\n",
    "import random\n",
    "\n",
    "numbers = random.sample(range(1, 49), 7) # The first argument given is the range from 1 to 49. The second argument is how many numbers you want to be returned from that range.\n",
    "\n",
    "print('Your lucky numbers are: ', numbers)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```html\n",
    "Your lucky numbers are:  [42, 43, 36, 6, 44, 31, 23]\n",
    "```\n",
    "\n",
    "You've now seen a few of some common built-in functions available to you via the Python standard library. There are many more! You can find the rest in the [Python Docs](https://docs.python.org/3/library/index.html).\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3685f733-1942-4804-ba84-4954b072f352",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    from DS_Students import MultipleChoice  \n",
    "except:\n",
    "    !pip install DS_Students\n",
    "    from DS_Students import MultipleChoice\n",
    "from ipynb.fs.full.DS109Questions import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9af33522-86df-4359-8293-2d705c3f0d7e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0bbcb0f80540444599177d055d4f6585",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(), RadioButtons(layout=Layout(width='max-content'), options=(('A. list()', 0), ('B. keyw…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "eec3adde743740ff9cf28bb12cff5f36",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(), RadioButtons(layout=Layout(width='max-content'), options=(('A. True', 0), ('B. False'…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e738c461629b4b3797a309ef9823d7ae",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(), RadioButtons(layout=Layout(width='max-content'), options=(('A. math.ceil()', 0), ('B.…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "10ffa6f654cd49c9a6c831ad8e9f3791",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(), RadioButtons(layout=Layout(width='max-content'), options=(('A. math.random()', 0), ('…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L7P5Q1, L7P5Q2, L7P5Q3, L7P5Q4)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd9e3b8a-9224-447f-8cf7-5035cae86421",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 6 - Modules Activity<a class=\"anchor\" id=\"DS109L7_page_6\"></a>\n",
    "\n",
    "[Back to Top](#DS109L7_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81e2098-28ef-4ff5-a155-afe824de4323",
   "metadata": {},
   "source": [
    "or this exercise, you will need to __import__ the `math` and `random` Python modules.\n",
    "\n",
    "Generate a random number between 0 and 100 and store it in the variable `my_random`. Remember, the `random` method returns a value between 0 and 1. You can scale it by multiplying the result by 100.\n",
    "\n",
    "Compute the _square root_ of `my_random` and store the result in the variable `square_root`.\n",
    "\n",
    "__Note__: If you do not see any output in the preview window, it may be due to failing to import the correct module(s).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4c34f942-3183-444b-9495-2733a6e2fffc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.738307857535123\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "import random\n",
    "\n",
    "my_random = random.random() * 100\n",
    "square_root = math.sqrt(my_random)\n",
    "\n",
    "print(square_root)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42cb7d8a-aced-42e5-ac24-32acf8c95473",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 7 - **pip** Packages<a class=\"anchor\" id=\"DS109L7_page_7\"></a>\n",
    "\n",
    "[Back to Top](#DS109L7_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf0debaf-5fae-4035-8e7d-ae62e62456cb",
   "metadata": {},
   "source": [
    "# **pip** Packages\n",
    "\n",
    "You've seen how to create and import modules. You've seen how to import and use Python's standard library of modules. When other developers create their own modules that they wish to share, they are distributed as _packages_.\n",
    "\n",
    "Now that we have discussed how to use modules out of Python's standard library, and built-in functions, let's talk about custom modules which commonly referred to as packages. These modules are built and maintained by other developers and can be imported just like the Python Standard Library. One of the most popular packages is `NumPy`.\n",
    "\n",
    "---\n",
    "## NumPy\n",
    "\n",
    "__NumPy__, or _Numerical Python_, is one of the more popular Python packages available to the public.\n",
    "\n",
    "NumPy is described as:\n",
    "\n",
    "> _\"The fundamental package for scientific computing with Python. It contains among other things: a powerful N-dimensional array object, sophisticated (broadcasting) functions, tools for integrating C/C++ and Fortran code, useful linear algebra, Fourier transform, and random number capabilities. Besides its obvious scientific uses, NumPy can also be used as an efficient multi-dimensional container of generic data. Arbitrary data-types can be defined. This allows NumPy to seamlessly and speedily integrate with a wide variety of databases\"_. - [NumPy.org](https://www.numpy.org)\n",
    "\n",
    "The use of NumPy allows a developer to perform the following operations:\n",
    "\n",
    "* Mathematical and logical operations on arrays.\n",
    "* Shape manipulation\n",
    "* Operations related to linear algebra.\n",
    "\n",
    "To demonstrate `NumPy`, it must be installed using `pip`. Either open a terminal/command-prompt, or open the integrated terminal in VS Code. To install `NumPy`, enter the following into the terminal:\n",
    "\n",
    "**For Mac users**:\n",
    "\n",
    "```html\n",
    "pip3 install numpy\n",
    "```\n",
    "\n",
    "**For Windows users**:\n",
    "\n",
    "```html\n",
    "python -m pip install numpy\n",
    "```\n",
    "\n",
    "Upon entering the command, you should see something similar to the following:\n",
    "\n",
    "```html\n",
    "Collecting numpy\n",
    "  Downloading numpy-1.13.1-cp36-cp36m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl (4.5MB)\n",
    "    100% |████████████████████████████████| 4.6MB 286kB/s\n",
    "Installing collected packages: numpy\n",
    "Successfully installed numpy-1.13.1\n",
    "```\n",
    "\n",
    "Now that you've installed the package, you can see one of the more important objects defined in NumPy. The N-dimensional array type (keyword `ndarray`) is a homogenous collection that is multi-dimensional. Think of it like an array of arrays or a grid, where each item is of the same type and size (in memory). Items are accessed in an __ndarray__ using a zero-based index. Each item is an object with a data type of `dtype`.\n",
    "\n",
    "The syntax to create a basic **ndarray** is:\n",
    "\n",
    "```python\n",
    "numpy.array\n",
    "```\n",
    "\n",
    "The `array` keyword here is a function built into NumPy.\n",
    "\n",
    "Below are a few examples using the __numpy.array__. As you should have expected, NumPy needs to be imported. The code below imports it with an alias of __np__.\n",
    "\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "x = np.array([1,2,3])\n",
    "print(x)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```html\n",
    "[1 2 3]\n",
    "```\n",
    "\n",
    "What about with more than one dimension?\n",
    "\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "x = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "print(x)\n",
    "```\n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Did you notice the outside set of square brackets <code>[]</code>? This is what is called a <b>multidimensional array</b>. It is essentially an array of arrays. An <b>array</b> is the same as a <b>list</b>, which you learned about in previous lessons</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```html\n",
    "[[1 2 3]\n",
    " [4 5 6]]\n",
    "```\n",
    "\n",
    "Above, the number of _dimensions_ was determined by the input you provided. An _ndarray_ is mutable, so you can add values to it. If you need to start with an empty or initial array, but you know how many dimensions will be needed, you can specify it at creation. You simply need to add another parameter to the initializer of the array, assigning `ndmin` to the minimum number of dimensions:\n",
    "\n",
    "```python\n",
    "import numpy as np\n",
    "\n",
    "x = np.array([1, 2, 3, 4, 5], ndmin=2)\n",
    "print(x)\n",
    "```\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```html\n",
    "[[1 2 3 4 5]]\n",
    "```\n",
    "\n",
    "As you can see above, a 2-dimensional array was created, despite only providing a single dimension for the input.\n",
    "\n",
    "You've only seen a small amount of what NumPy has to offer. You can read more about it on [the NumPy website](https://www.numpy.org) if you'd like. However, the main idea of this section in the lesson was to demonstrate how to install using and import a custom package and access its features. You used `pip` to install it, and then you imported and used it like any other module.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b3f800-0a14-4d13-8c32-390965c537ca",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 8 - Accessing and Modifying Files<a class=\"anchor\" id=\"DS109L7_page_8\"></a>\n",
    "\n",
    "[Back to Top](#DS109L7_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4597e4b4-ce22-448d-843e-eab5ba74a9c4",
   "metadata": {},
   "source": [
    "# Accessing and Modifying Files\n",
    "\n",
    "In this section, you're going to learn about Python file operations. You'll discover how to open a file, read a file, write into a file, and close the file when done.\n",
    "\n",
    "When reading and writing to a file in Python, you must first open the file. When finished using the file, it must be closed. Python file operations take place in a specific order.\n",
    "\n",
    "1.  Open a file\n",
    "2.  Read or write. Referred to as performing an operation.\n",
    "3.  Close the file.\n",
    "\n",
    "---\n",
    "## Opening And Closing A File\n",
    "\n",
    "The Python library contains the built-in function `open()` to open a file. This function returns the file object often called a _handle_.\n",
    "\n",
    "When using the `open()` function, it requires two _string_ arguments: one to specify the name and location of the file, and the second to specify one of the following _modes_ that determine how the file is opened:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td nowrap><b>File Mode</b></th>\n",
    "        <td><b>Operation</b></th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td><b>r</b></td>\n",
    "        <td>Open an existing file to read.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td><b>w</b></td>\n",
    "        <td>Open an existing file to write. Creates a new file if none exists or opens an existing file and discards all its previous contents.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td><b>a</b></td>\n",
    "        <td>Append text.  Opens or creates a text file for writing at the end of the file.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td><b>r+</b></td>\n",
    "        <td>Open a text file to read from or write to.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td><b>w+</b></td>\n",
    "        <td>Opens a text file to write to or read from</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td><b>a+</b></td>\n",
    "        <td>Open or creates a text file to read from or write to at the end of the file.</td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "Once the file is open and you have a file object (what's returned from the call to _open()_), you can get different details about the file from the object's properties, such as:\n",
    "\n",
    "<table>\n",
    "    <tr>\n",
    "        <td><b>Property</b></th>\n",
    "        <td><b>Description</b></th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td><b>name</b></td>\n",
    "        <td>Name of the opened file.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td><b>mode</b></td>\n",
    "        <td>Mode in which the file was opened</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td><b>closed</b></td>\n",
    "        <td>Status boolean value of True or False</td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "Go ahead and create a new file in the same folder as your current file in VSCode and save it as `example.txt`. This file will be used to read and write data.\n",
    "\n",
    "You can also go ahead and create another Python file for this exercise, you'd like. Or, you can continue using the `lesson_7.py` file. For the sake of this section of the lesson, it will assume you are using a new file named `file_test.py`.\n",
    "\n",
    "First, in `file_test.py`, you will be adding the following line of code that will open the __example.txt__ file in _write_ mode. The result of the call to open the file will be a _file_ object assigned to the variable `file`:\n",
    "\n",
    "\n",
    "```python\n",
    "file = open('example.txt', 'w')\n",
    "```\n",
    "\n",
    "Remember, both arguments in the `open()` function must be **strings**.\n",
    "\n",
    "Next, add the following two lines below the previous one. The first line will print the name of the file, and the second will print the mode in which the file was opened:\n",
    "\n",
    "```python\n",
    "print('File Name:', file.name)\n",
    "print('File Open Mode:', file.mode)\n",
    "```\n",
    "\n",
    "Now, when you save this file and run it in the terminal, you should see the following:\n",
    "\n",
    "```html\n",
    "File Name: example.txt\n",
    "File Open Mode: w\n",
    "```\n",
    "\n",
    "Now, you're going to define a function that allows you to determine if a file is open or closed.\n",
    "\n",
    "```python\n",
    "def status(file):\n",
    "    if(file.closed != False):\n",
    "        return 'Closed'\n",
    "    else:\n",
    "        return 'Open'\n",
    "```\n",
    "\n",
    "You also need to add another statement to `file_test.py` to display the current file status. Add the following line to the end of the code file\n",
    "\n",
    "```python\n",
    "print('File Status:', status(file))\n",
    "```\n",
    "\n",
    "Your file, now, should look like the following:\n",
    "\n",
    "```python\n",
    "file = open('example.txt', 'w')\n",
    "\n",
    "print('File Name:', file.name)\n",
    "print('File Open Mode:', file.mode)\n",
    "\n",
    "def status(x):\n",
    "    if (x.closed != False):\n",
    "        return 'Closed'\n",
    "    else:\n",
    "        return 'Open'\n",
    "\n",
    "\n",
    "print('File Status:', status(file))\n",
    "```\n",
    "\n",
    "Once you save the file and run it in the terminal, your output should be:\n",
    "\n",
    "```html\n",
    "File Name: example.txt\n",
    "File Open Mode: w\n",
    "File Status: Open\n",
    "```\n",
    "\n",
    "Now, that you know how to open a file and view its open status, mode, and file name, it's time to close the file:\n",
    "\n",
    "```python\n",
    "file.close()\n",
    "\n",
    "print('File Status:', status(file))\n",
    "```\n",
    "\n",
    "Once the code above is added to the `file_test.py` file, you should have the following:\n",
    "\n",
    "```python\n",
    "file = open('example.txt', 'w')\n",
    "\n",
    "print('File Name:', file.name)\n",
    "print('File Open Mode:', file.mode)\n",
    "\n",
    "def status(x):\n",
    "    if (x.closed != False):\n",
    "        return 'Closed'\n",
    "    else:\n",
    "        return 'Open'\n",
    "\n",
    "\n",
    "print('File Status:', status(file))\n",
    "\n",
    "file.close()\n",
    "\n",
    "print('File Status:', status(file))\n",
    "```\n",
    "\n",
    "Now you will see the additional output `File Status: Closed` once you run the script.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36943bcd-7e16-4af1-97d3-c09e81ae5e99",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 9 - Reading From And Writing To Files<a class=\"anchor\" id=\"DS109L7_page_9\"></a>\n",
    "\n",
    "[Back to Top](#DS109L7_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdf2cdde-9447-49b5-8936-17d80f46b45e",
   "metadata": {},
   "source": [
    "# Reading From And Writing To Files\n",
    "\n",
    "Once you have successfully opened a file, it can now be read or new text can be written to the file, depending on the mode associated with the call of the `open()` method. Using the `read()` method will return the entire content of the file, and the `write()` method adds content to the file.\n",
    "\n",
    "Go ahead and either comment out or delete the code in your `file_test.py` file.\n",
    "\n",
    "You are going to start with a variable named `story`. Then, you can write a short line for the beginning of your story. Be sure to end each line with the new line characters `\\n`, as you will be concatenating other lines to this first one.\n",
    "\n",
    "```python\n",
    "story = \"Once upon a time there was\\n\"\n",
    "```\n",
    "\n",
    "Now that you have the beginning of your story, go ahead and add a few more lines.\n",
    "\n",
    "```python\n",
    "story = \"Once upon a time there was\\n\"\n",
    "story += \"a dog who loved to play ball.\\n\"\n",
    "story += \"This dog could run as fast as the wind.\\n\"\n",
    "```\n",
    "\n",
    "You should be able to print `story` and each line should print to the terminal.\n",
    "\n",
    "```html\n",
    "Once upon a time there was\n",
    "a dog who loved to play ball.\n",
    "This dog could run as fast as the wind.\n",
    "```\n",
    "\n",
    "Since the story is complete, you can create a new file object and add the story to the file.\n",
    "\n",
    "```python\n",
    "file = open('story.txt', 'w')\n",
    "file.write(story)\n",
    "```\n",
    "\n",
    "Above, a new file named __story.txt__ is created and opened in _write_ mode. The second line writes what's stored in `story` to the file.\n",
    "\n",
    "Now, you need to close the file when you're done:\n",
    "\n",
    "```python\n",
    "file = open('story.txt', 'w')\n",
    "file.write(story)\n",
    "file.close()\n",
    "```\n",
    "\n",
    "Next, you're going to open the file again, but this time in _read_ mode:\n",
    "\n",
    "```python\n",
    "file = open('story.txt', 'w')\n",
    "file.write(story)\n",
    "file.close()\n",
    "\n",
    "file = open('story.txt', 'r')\n",
    "```\n",
    "\n",
    "Finally, you'll display the contents of the text file and close the file:\n",
    "\n",
    "```python\n",
    "file = open('story.txt', 'w')\n",
    "file.write(story)\n",
    "file.close()\n",
    "\n",
    "file = open('story.txt', 'r')\n",
    "\n",
    "for line in file:\n",
    "    print(line, end = '')\n",
    "file.close()\n",
    "```\n",
    "\n",
    "Your `file_test.py` file should contain the following code:\n",
    "\n",
    "```python\n",
    "story = \"Once upon a time there was\\n\"\n",
    "story += \"a dog who loved to play ball.\\n\"\n",
    "story += \"This dog could run as fast as the wind.\\n\"\n",
    "\n",
    "file = open('story.txt', 'w')\n",
    "file.write(story)\n",
    "file.close()\n",
    "\n",
    "file = open('story.txt', 'r')\n",
    "\n",
    "for line in file:\n",
    "    print(line)\n",
    "file.close()\n",
    "```\n",
    "\n",
    "Once you save the file and run it in the terminal, you will see that a new file named `story.txt` was created in the same folder with your other files. As well, the story should be printed to the terminal. And, about that....\n",
    "\n",
    "When you first _open_ a text file in read mode, the file object that is returned can be iterated to print out each line. This is the `for` loop you see above.\n",
    "\n",
    "Alternatively, you can _read_ the contents in using the `read()` function of the file object. To try it, replace the following code:\n",
    "\n",
    "```python\n",
    "for line in file:\n",
    "    print(line)\n",
    "```\n",
    "\n",
    "with the following new code:\n",
    "\n",
    "```python\n",
    "contents = file.read()\n",
    "print(contents)\n",
    "```\n",
    "\n",
    "Saving and running the file will show you that the output to the terminal changed in format, but the contents of the file did not change. If you ran the program more than once, shouldn't the file contain the story multiple times?\n",
    "\n",
    "No. Any time you open a file using the _write_ mode, or `'w'`, it truncates the file to the beginning, overwriting everything that was there before.\n",
    "\n",
    "If you want to _add_ more text to an existing file, you'll need to use the _append_ mode, or `'a'`. To demonstrate, change the mode flag from `w` to `a` in your code:\n",
    "\n",
    "```python\n",
    "file = open('story.txt', 'a')\n",
    "```\n",
    "\n",
    "Now, go ahead and save and run the file. You should now see the story __twice__ in both the `story.txt` file and the console/terminal:\n",
    "\n",
    "```\n",
    "Once upon a time there was\n",
    "a dog who loved to play ball.\n",
    "This dog could run as fast as the wind.\n",
    "Once upon a time there was\n",
    "a dog who loved to play ball.\n",
    "This dog could run as fast as the wind.\n",
    "```\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "676baa26-cb0d-4d17-a3cc-a6fa43ae53fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3ca1deccc6714ca1b7b5bf0e12ef3eb5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. Which of the following must come first to use Nu…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "c963dc51636848f992d2383097d50f77",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. Which file mode is used to append text to a file…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "083754acb26f4ab8a68ac3ad12ebbb6c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. What is the proper syntax to open a file named h…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L7P9Q1, L7P9Q2, L7P9Q3)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a0d02d5-04fa-4220-9637-d02c3b32dce5",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 10 - Updating File Strings<a class=\"anchor\" id=\"DS109L7_page_10\"></a>\n",
    "\n",
    "[Back to Top](#DS109L7_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2c3525d-d45a-4fc0-9165-0fe9b0e83168",
   "metadata": {},
   "source": [
    "# Updating File Strings\n",
    "\n",
    "A file object's `read()` method will, by default, read the entire contents of the file from index position zero to the very end at the index position associated with the final character. Optionally, the `read()` method can take an argument to specify how many characters it should read.\n",
    "\n",
    "The position in the file, from which to read or at which to write, can be controlled using the file object's `seek()` method. The `seek()` method takes an integer argument specifying how many characters to move _position_ as an offset from the start of the file.\n",
    "\n",
    "You can discover the current position from within the file at any time using the file object's `tell()` method to return an integer location (which character).\n",
    "\n",
    "When working with file objects, it is good practice to use the Python keyword `with` to group the file operational statements within a block. When doing file operations within a `with` block, after the final statement has completed, the file is closed for you.\n",
    "\n",
    "In your `file_test.py` file go ahead and comment out any current code you have in the file or erase it.\n",
    "\n",
    "Start by creating a string variable with the following value:\n",
    "\n",
    "```python\n",
    "new_text = 'Python was conceived in the late 1990s by Guido van Rossum'\n",
    "```\n",
    "\n",
    "Next, add the statements to write the `new_text` string into a file and display the file's current status using a `with` block.\n",
    "\n",
    "```python\n",
    "with open('updating.txt', 'w') as file:\n",
    "    file.write(new_text)\n",
    "    print('\\nFile Now Closed?:', file.closed)\n",
    "```\n",
    "\n",
    "Next, add another print statement to check the file's new status.\n",
    "\n",
    "```python\n",
    "print('File Now Closed?:', file.closed)\n",
    "```\n",
    "\n",
    "Next, add code to open the file once again and display its contents to confirm it now contains the entire `new_text` string.\n",
    "\n",
    "```python\n",
    "with open('updating.txt', 'r+') as file:\n",
    "    new_text = file.read()\n",
    "    print('\\nString:', new_text)\n",
    "```\n",
    "\n",
    "Now, add the following code to the end of the last `with` block. Each statement should be indented to match the previous two statements in the block. The first line of code print's the file's current position. The second statement moves the file's current position `33` characters toward the end of the file. The final line prints the file's current position again to show that it moved.\n",
    "\n",
    "```python\n",
    "    print('\\nPosition In File Now:', file.tell())\n",
    "    position = file.seek(33)\n",
    "    print('Position In File Now:', file.tell())\n",
    "```\n",
    "\n",
    "Next, add the following line to the same `with` block to write `1980s` to the file at the current file position. This will overwrite what was there previously.\n",
    "\n",
    "```python\n",
    "    file.write('1980s')\n",
    "```\n",
    "\n",
    "Finally, add three more statements to the `with` block to return to the start of the file and display its entire updated contents.\n",
    "\n",
    "```python\n",
    "    file.seek(0)\n",
    "    new_text = file.read()\n",
    "    print('\\nString:', new_text)\n",
    "```\n",
    "\n",
    "All of the new code combined is as follows:\n",
    "\n",
    "```python\n",
    "new_text = 'Python was conceived in the late 1990s by Guido van Rossum.'\n",
    "with open('updating.txt', 'w') as file:\n",
    "    file.write(new_text)\n",
    "    print('\\nFile Now Closed?:', file.closed)\n",
    "print('File Now Closed?:', file.closed)\n",
    "\n",
    "with open('updating.txt', 'r+') as file:\n",
    "    new_text = file.read()\n",
    "    print('\\nString:', new_text)\n",
    "    print('\\nPosition In File Now:', file.tell())\n",
    "    position = file.seek(33)\n",
    "    print('Position In File Now:', file.tell())\n",
    "    file.write('1980s')\n",
    "    file.seek(0)\n",
    "    new_text = file.read()\n",
    "    print('\\nString:', new_text)\n",
    "```\n",
    "\n",
    "Once this file is saved, you will see a new file created with the `new_text` string added. You will also see the following output in the terminal:\n",
    "\n",
    "**OUTPUT:**\n",
    "\n",
    "```html\n",
    "File Now Closed?: False\n",
    "File Now Closed?: True\n",
    "\n",
    "String: Python was conceived in the late 1990s by Guido van Rossum.\n",
    "\n",
    "Position In File Now: 59\n",
    "Position In File Now: 33\n",
    "\n",
    "String: Python was conceived in the late 1980s by Guido van Rossum.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a16ff296-b1e1-453b-af07-03607ccbd9a8",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 11 - Lesson 7 Practice Hands-On<a class=\"anchor\" id=\"DS109L7_page_11\"></a>\n",
    "\n",
    "[Back to Top](#DS109L7_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b012ff24-aec9-46b8-b2ea-48bc2d9e1b8c",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "For your Lesson 7 Practice Hands-On, you will be working with your new knowledge of Python's Standard Library. For this project, you will be creating a new directory, so please follow the below setup instructions. This Hands-On will **not** be graded, but we encourage you to complete it. The best way to become a great programmer is to practice! Once you have submitted your project, you will be able to access the solution on the next page.\n",
    "\n",
    "---\n",
    "\n",
    "## Setup\n",
    "\n",
    "1. First, open up your command prompt/terminal\n",
    "2. Now that you are in your command prompt/terminal, run the following command:\n",
    "    ```text\n",
    "    cd desktop\n",
    "    ``` \n",
    "3. Next, move your command prompt/terminal's location to the new `python_course` you just created by running the following:\n",
    "    ```text\n",
    "    cd python_course\n",
    "    ```\n",
    "4. Run the following to create a new directory for this project:\n",
    "    ```text\n",
    "    mkdir lesson_seven_handson\n",
    "    ```\n",
    "5. Open up a new window in VSCode. \n",
    "6. Open the `lesson_seven_handson` directory in VSCode\n",
    "7. Create a new file named `main.py`\n",
    "\n",
    "Now you are ready to get started on your Lesson 7 Practice Hands-On!\n",
    "\n",
    "---\n",
    "\n",
    "## Requirements\n",
    "\n",
    "This hands-on is broken into two parts. Please complete each part within your `main.py` file.\n",
    "\n",
    "---\n",
    "## Part 1\n",
    "\n",
    "1. Create a program that imports the `datetime` module from the Python standard library and creates a variable that is set to today's date. \n",
    "2. Print out the full date. \n",
    "3. Separately, print out only the time: hour and minute.\n",
    "\n",
    "You did not cover the `datetime` module in the lesson, so you can read up on it at the link below. Looking up information is something that you will need to do rather regularly as a programmer, so it's good practice.\n",
    "\n",
    "> [Documentation for the `datetime` module](https://docs.python.org/3/library/datetime.html#module-datetime).\n",
    "\n",
    "The expected output is below (the actual date and time below will be different for you):\n",
    "\n",
    "```text\n",
    "Today is: 2018-07-09 08:59:08.385290\n",
    "Time: 08:59:08.385437\n",
    "```\n",
    "\n",
    "The time will be in 24/hr format. This is acceptable.\n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>You will need to use the <code>.now()</code> attribute.</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "## Part 2\n",
    "\n",
    "1. Create the following new string variable that is constructed over four lines: \"Tiny little secrets Get buried in the dirt, And if they were dug up, Someone would probably get hurt.\"\n",
    "    - The variable name for the above string should be `poem_string` \n",
    "    - The new lines should happen where you see capital letters\n",
    "    > Hint! Use the new line character\n",
    "2. Create and open a new file object named `poem.txt` in _write_ mode.\n",
    "    - This variable name should be `poem_file`\n",
    "3. Write the above string to the `poem.txt` file.\n",
    "4. Close the `poem.txt` file.\n",
    "5. Re-open the `poem.txt` file in _read_ mode.\n",
    "    - This variable name should be `poem_file`\n",
    "6. Read the contents of the file and print to the console.\n",
    "7. Close the file once again.\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Be sure to zip and submit your entire <code>lesson_seven_handson</code> directory when finished!</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d04bbaf-586c-419f-9478-05c75a7f38c0",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 12 - Lesson 7 Practice Hands-On Solution<a class=\"anchor\" id=\"DS109L7_page_12\"></a>\n",
    "\n",
    "[Back to Top](#DS109L7_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c07a6823-f398-4633-904a-028f2ee1a77f",
   "metadata": {},
   "source": [
    "# Solution\n",
    "\n",
    "Below is the solution to your Lesson 7 Practice Hands-On.\n",
    "\n",
    "```python\n",
    "# Part 1\n",
    "import datetime\n",
    "\n",
    "todays_date = datetime.datetime.now()\n",
    "print(\"Today is:\", todays_date)\n",
    "\n",
    "current_time = datetime.datetime.now().time()\n",
    "print(\"Time:\", current_time)\n",
    "\n",
    "# Part 2\n",
    "\n",
    "poem_string = \"Tiny little secrets,\\n\"\n",
    "poem_string += \"Get buried in the dirt,\\n\"\n",
    "poem_string += \"And if they were dug up,\\n\"\n",
    "poem_string += \"Someone would probably get hurt.\"\n",
    "\n",
    "poem_file = open('poem.txt', 'w')\n",
    "poem_file.write(poem_string)\n",
    "poem_file.close()\n",
    "\n",
    "poem_file = open('poem.txt', 'r')\n",
    "print(poem_file.read())\n",
    "poem_file.close()\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}