10-Working-with-Simple-Text-Files.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10-Working with Simple Text Files\n",
    "\n",
    "Hello Highlanders!!\n",
    "\n",
    "In this oportunity we are going tho work with files. At the end of this lesson you will be able to open files and work with them programmatically. \n",
    "\n",
    "Python can easily handle working with .txt files (later on you will be trained in working with other file formats, such as .csv or .pdf). Let's go over best practices for working with simple text files in Python.\n",
    "\n",
    "## Opening a File\n",
    "\n",
    "Let's being by opening the file test.txt that is located in the same directory as this notebook. For now we will work with files located in the **same directory** you are using. \n",
    "\n",
    "To use a file and do something with it, the first thing we need to do is open it. Yes, like a book.\n",
    "\n",
    "To do that we will use the **open()** funtion, with the file name including its extension inside:\n",
    "\n",
    "```Python\n",
    "my_file = open('file_name.extension')\n",
    "```\n",
    "\n",
    "**my_file** is the name we choose for the object where the content of **file_name.extension** file will be stored.\n",
    "\n",
    "It is very easy to get an error on this step:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# For instance if the file doesn't exist we will get an error like this ...\n",
    "\n",
    "errorfile = open('wrong_name.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means two possible things occured, either the name of the file is wrong, or you didn't provide the correct file path (more on that later).\n",
    "\n",
    "Let's now provide the correct file name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfile = open('test_file.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we open a file we assign it content to a new object. In this case the object is called *myfile* <br>\n",
    "Let's see its type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(myfile)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Method asociated to our new object\n",
    "Now we can call various read methods off this text file:\n",
    "\n",
    "**.read()** returns the entire contents as a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfile.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you run this again, you will recieve a blank:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfile.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is because the \"cursor\" is at the end of the file. You can reset the cursor to the start using seek:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfile.seek(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfile.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='green'>Task:</font> See what happens if you use a seek() with the cursor in different positions\n",
    "Put the cursor in different positions like 10, 45, 88\n",
    "Tip: \n",
    "1. Use the method seek(your_number)\n",
    "2. The use myfile.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here ...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**readlines()**\n",
    "\n",
    "Because so many files often have **line breaks (\\n)** often people want to use these as separators and read in the entire text file as list, where each item in the list is a string representing a line in the text file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfile.seek(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfile.readlines()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='green'>Task:</font> What kind of type object returns readlines() method?\n",
    "Determine the object type that is returned by readline method\n",
    "\n",
    "Tip: \n",
    "1. Use the type() function over myfile.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "____"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### File Locations\n",
    "\n",
    "\n",
    "\n",
    "If want to open files at another location on your computer, simply pass in the entire file path.\n",
    "\n",
    "For Windows you need to use double \\\\ so python doesn't treat the second \\ as an escape character, a file path is in the form:\n",
    "\n",
    "    myfile = open(\"C:\\\\Users\\\\YourUserName\\\\Home\\\\Folder\\\\myfile.txt\")\n",
    "    \n",
    "For MacOS and Linux you use slashes in the opposite direction:\n",
    "\n",
    "    myfile = open(\"/Users/YouUserName/Folder/myfile.txt\")\n",
    "    \n",
    "This was an example, try to open and read the file using *YOUR OWN PATH*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='green'>Task:</font> Open the text_file.txt using your own path\n",
    "\n",
    "Tip:\n",
    "1. Look for your path using the Explorer of your Windows or the Finder in your Mac.\n",
    "2. Open the file this way:\n",
    "```Python\n",
    "    myfile = open(\"C:\\\\your_path_goes_here\\\\myfile.txt\")\n",
    "```\n",
    "3. Remember to separate the folders in your path with double backslashes (** \\\\\\ **) in Windows or a single slash (** / **) in Mac.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here ...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Don't forget to close the door when you leave\n",
    "\n",
    "Like with the book, when you finish to use (read) it ... you close it.\n",
    "\n",
    "In Python we *always* close the files we opened. To do that we use the **close()** method this way:\n",
    "\n",
    "```Python\n",
    "    myfile.close()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='green'>Task:</font> Close the file\n",
    "\n",
    "Tip:\n",
    "1. Close the opened file this way:\n",
    "```Python\n",
    "    myfile.close()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here ...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's see a full example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myfile = open('test_file.txt')\n",
    "lines = myfile.read()\n",
    "print(lines)\n",
    "myfile.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Best Practice ... the Paythonist way !!\n",
    "\n",
    "It's a good practice to use the **with** statement for opening files, this allows you to not worry about closing the file after you open it. Here is the syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('test_file.txt') as myfile:\n",
    "    # Notice the indentation!\n",
    "    # We'll discuss this a lot more later on\n",
    "    lines = myfile.read()\n",
    "    \n",
    "    \n",
    "# File auto closed after this with statment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(lines)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read and Write Options\n",
    "\n",
    "The open() function has a second parameter that allows you to specify whether you only want to be able to read the file, or write to it as well, or do both.\n",
    "\n",
    "Here is a table of some of the important options:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table>\n",
    "<tr>\n",
    "<th style=\"text-align:center;\">Modes &amp; Description</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td><p><b>r</b></p>\n",
    "<p>Opens a file for reading only. The file pointer is placed at the beginning of the file. This is the default mode.</p></td>\n",
    "</tr>\n",
    "\n",
    "<tr>\n",
    "<td><p><b>r+</b></p>\n",
    "<p>Opens a file for both reading and writing. The file pointer placed at the beginning of the file.</p></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td><p><b>w</b></p>\n",
    "<p>Opens a file for writing only. Overwrites the file if the file exists. If the file does not exist, creates a new file for writing.</p></td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td><p><b>w+</b></p>\n",
    "<p>Opens a file for both writing and reading. Overwrites the existing file if the file exists. If the file does not exist, creates a new file for reading and writing.</p></td>\n",
    "</tr> \n",
    "<tr>\n",
    "<td><p><b>a</b></p>\n",
    "<p>Opens a file for appending. The file pointer is at the end of the file if the file exists. That is, the file is in the append mode. If the file does not exist, it creates a new file for writing.</p></td>\n",
    "</tr> \n",
    "<tr>\n",
    "<td><p><b>ab</b></p>\n",
    "<p>Opens a file for appending in binary format. The file pointer is at the end of the file if the file exists. That is, the file is in the append mode. If the file does not exist, it creates a new file for writing.</p></td>\n",
    "</tr> \n",
    "<tr>\n",
    "<td><p><b>a+</b></p>\n",
    "<p>Opens a file for both appending and reading. The file pointer is at the end of the file if the file exists. The file opens in the append mode. If the file does not exist, it creates a new file for reading and writing.</p></td>\n",
    "</tr> \n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('second_file.txt')\n",
    "f.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's try to write to the file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This code will give us an error...\n",
    "\n",
    "f = open('second_file.txt')\n",
    "f.write(\"new line\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is because, we need to tell to open() function that we want to write in the file. So let's add in the 'w' code at the open time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('test_file.txt','w')\n",
    "# Returns the number of characters written\n",
    "f.write('new line')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('test_file.txt')\n",
    "f.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the entire file has been overwritten! If you want to add to the file, you need to use the **'a'** append mode for writing to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('totally_new_file.txt','w+')\n",
    "f.write(\"I Created a new file\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='green'>Task:</font> Add new lines to the file\n",
    "Add two new lines to the file\n",
    "\n",
    "Tip:\n",
    "1. You need to open it with 'a' mode\n",
    "```Python\n",
    "    file_to_add = open('totally_new_file.txt','a')\n",
    "```\n",
    "2. Write two lines\n",
    "```Pythom\n",
    "    file_to_add.write('New line')\n",
    "```\n",
    "3. Read the file using **read()**\n",
    "4. Close the file using **close()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your code here ...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='green'>Task:</font> Do the same thing from the previous cell but using *with* statement\n",
    "The Pythonist way to open files\n",
    "\n",
    "Tip:\n",
    "1. You need to open it with *with open ... * statement\n",
    "```Python\n",
    "    with open('test_file.txt') as archivo:\n",
    "```\n",
    "2. Write two lines\n",
    "```Pythom\n",
    "    archivo.write('This time we open like a Pythonist and add a new line')\n",
    "```\n",
    "3. Read the file using **read()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Your ode here ...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Good job Highlanders !!"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}