io/File_IO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![NASA](http://www.nasa.gov/sites/all/themes/custom/nasatwo/images/nasa-logo.svg)\n",
    "\n",
    "<center>\n",
    "<h1><font size=\"+3\">GSFC Python Bootcamp</font></h1>\n",
    "</center>\n",
    "\n",
    "---\n",
    "<center>\n",
    "<H1 style=\"color:red\">\n",
    "File Input and Output (IO)\n",
    "</H1>\n",
    "</center>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "slide = Image(filename = 'fileFormats.jpg')\n",
    "slide"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "### Reading text files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "help(open)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "file_object = open('demo.txt', 'r') # 'r' is default"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "A file_object can be treated as a sequence of strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### What type of object is file_object?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"file_object is of type: \", type(file_object))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# file_object.<TAB>\n",
    "dir(file_object) # attributes and methods of file objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Examples\n",
    "print(file_object.name)\n",
    "print(file_object.mode)\n",
    "print(file_object.closed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Print all the lines and count the number of lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "my_file = open ('demo.txt','r')\n",
    "count = 0\n",
    "for line in my_file: # treating my_file as a sequence of strings\n",
    "    count = count + 1\n",
    "    print(line)\n",
    "print(\"My file has \"+str(count)+\" lines.\")    \n",
    "my_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Note: Each line includes a non-printing character called the newline character \"\\n\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise \n",
    "Read the text file demo.txt and count the number of lines excluding empty lines."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading the entire file at once"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "my_file = open ('demo.txt','r')\n",
    "\n",
    "# read() reads the _entire_ file, returns a string object\n",
    "data = my_file.read()           \n",
    "print(\"Contents of file are of type: \", type(data))\n",
    "\n",
    "# close file handle\n",
    "my_file.close()\n",
    "\n",
    "# Now data is in memory\n",
    "heading=\"Contents of file\"\n",
    "print(\"\\n\"+heading+\"\\n\"+\"-\"*len(heading))\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read file chunks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "my_file = open('demo.txt', 'r')\n",
    "data = my_file.read()          \n",
    "#print(data)\n",
    "while data != \"\":\n",
    "   data = my_file.read(64)   # read in 64-byte chunk sizes\n",
    "   print(data)\n",
    "my_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read one line at a time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "my_file = open ('demo.txt')\n",
    "data = my_file.readline()\n",
    "print (data)\n",
    "my_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read all the lines in the text file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_file = open ('demo.txt')\n",
    "data = my_file.readlines()                        \n",
    "print(data)                # Note data is a list\n",
    "my_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise \n",
    "Read the text file demo.txt and find all instances of the word \"Luke\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Automatically closing files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to open a file, process its contents, and make sure to close it, you can simply do:\n",
    "\n",
    "with open ('demo.txt', 'r') as f:\n",
    "    data = f.read() \n",
    "    print('--> Is file closed? ', f.closed)\n",
    "    # file will be closed after exiting this block of code\n",
    "    \n",
    "print('<-- Is file closed? ', f.closed)\n",
    "print(f.mode)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary of open() file access modes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"width:100%\">\n",
    "  <tr>\n",
    "    <th>Mode</th>\n",
    "    <th>Description</th> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>r</td>\n",
    "    <td>Opens a file for reading only. Default mode.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>rb</td>\n",
    "    <td>Opens a file for reading only in binary format.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>r+</td>\n",
    "    <td>Opens a file for both reading and writing.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>rb+</td>\n",
    "    <td>Opens a file for both reading and writing in binary format.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>w</td>\n",
    "    <td>Opens a file for writing only. Overwrites file if it exists. Creates a new file if it does not exist.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>wb</td>\n",
    "    <td>Opens a file for writing only in binary format.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>w+</td>\n",
    "    <td>Opens a file for both writing and reading.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>wb+</td>\n",
    "    <td>Opens a file for both writing and reading in binary format.</td> \n",
    "  </tr>\n",
    "    <td>a</td>\n",
    "    <td>Opens a file for appending. The file pointer is at the end of the file if it exists. </td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>ab</td>\n",
    "    <td>Opens a file for appending in binary format.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>a+</td>\n",
    "    <td>Opens a file for both appending and reading.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>ab+</td>\n",
    "    <td>Opens a file for both appending and reading in binary format.</td> \n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing Text Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example:\n",
    "with open('elements.txt', 'w') as f: # 'w' creates a new file\n",
    "    f.write('Noble gases:')              \n",
    "    f.writelines(['He', 'Ne', 'Ar'])  # writelines writes each element on its own"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    !cat elements.txt\n",
    "except:\n",
    "    with open('elements.txt', 'r') as f:\n",
    "        contents = f.read()\n",
    "        print(contents)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: python will not write '\\n' for you"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 'a+' vs 'r+'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('elements.txt', 'a') as f:  # 'a' is 'append' mode, no reading\n",
    "    contents = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "with open('elements.txt', 'a+') as f:  # 'a++' appending and reading\n",
    "    contents = f.read()               \n",
    "    print (f.tell())                \n",
    "    f.write('Kr\\n')                    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f.tell() tells me that file pointer is at EOF and I appended 'Kr\\n' at that position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    !cat elements.txt\n",
    "except:\n",
    "    with open('elements.txt', 'r') as f:\n",
    "        contents = f.read()\n",
    "        print(contents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('elements.txt', 'r+') as f: # 'r+' reading and writing\n",
    "    print (f.tell())                  # file pointer is at 'beginning of file'\n",
    "    f.write('Halogens:\\n')          \n",
    "    f.writelines(['F\\n', 'Cl\\n'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f.tell() tells me that file pointer is at BOF and I wrote text starting at that position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    !cat elements.txt\n",
    "except:\n",
    "    with open('elements.txt', 'r') as f:\n",
    "        contents = f.read()\n",
    "        print(contents)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "Write a program that reads file 'demo.txt' and writes out a new file with the lines in reversed order (i.e. the first line in the old file becomes the last one in the new file.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary of basic file IO functions and methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"width:100%\">\n",
    "  <tr>\n",
    "    <th>Methods and functions</th>\n",
    "    <th>Description</th> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>open()</td>\n",
    "    <td>Returns a file object and is most commonly used with two arguments: open(filename, mode)</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>file.close()</td>\n",
    "    <td>Close the file.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>file.read([size])</td>\n",
    "    <td>Read the entire file. If size is specified then read at most size bytes.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>file.readline([size])</td>\n",
    "    <td>Read one line from the file. If size is specified then read at most size bytes.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>file.readlines([size])</td>\n",
    "    <td>Read all the lines from the file. If size is specified then read at most size bytes.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>file.tell()</td>\n",
    "    <td>Returns file object's current position in the file.</td> \n",
    "  </tr>\n",
    "  <tr>\n",
    "    <td>file.seek(int)</td>\n",
    "    <td>Changes the file object's current position to the given int.</td> \n",
    "  <tr>\n",
    "    <td>file.write(string)</td>\n",
    "    <td>Writes the contents of string to the file.</td> \n",
    "  </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Handling delimited files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    !cat grades.csv\n",
    "except:\n",
    "    with open('grades.csv', 'r') as f:\n",
    "        contents = f.read()\n",
    "        print(contents)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One could use csv package: import csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('grades.csv', 'r') as f:\n",
    "    for line in f:\n",
    "        print(line.strip().split(','))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Each row of the input data is parsed and converted to a list of strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binary data IO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = b\"Hello world!\"\n",
    "\n",
    "with open('hello.bin','wb') as f:\n",
    "    f.write(s)\n",
    "    \n",
    "with open('hello.bin','rb') as f:\n",
    "    data = f.read()\n",
    "print(data)\n",
    "\n",
    "with open('hello.bin','rb') as f:\n",
    "    byte = f.read(1)\n",
    "    print(byte,)\n",
    "    while byte != \"\":\n",
    "        byte = f.read(1)\n",
    "        print(byte,)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The differences between binary and ascii encoding won't be obvious for simple alphanumeric strings, but will become important if you're processing text that includes characters not in the ascii character set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "with open('cat.jpg', 'rb') as f:\n",
    "    data = f.readline()\n",
    "print (data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "':'.join(x.encode('hex') for x in data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hex dump is useful for debugging. In a hex dump, each byte (8-bits) is represented as a two-digit hexadecimal number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('cat.jpg', 'rb') as f:\n",
    "    data = f.read()\n",
    " \n",
    "    if data.startswith(b'\\xff\\xd8'):\n",
    "        info = 'This is a jpeg file (%d bytes long)'\n",
    "    else:\n",
    "        info = 'This is a random file (%d bytes long)'\n",
    "\n",
    "    print (info % len(data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "kitty = Image(filename = 'cat.jpg')\n",
    "kitty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### OS dependent functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Python os module provides methods that help you perform all kinds of file-processing operations, such as renaming and deleting files (as well as file IO)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(os.read)\n",
    "fd = os.open('demo.txt', os.O_RDWR)\n",
    "ret = os.read(fd, 15)\n",
    "print('Result from os.read:'+'\\n'+20*'-'+'\\n'+ret)\n",
    "os.close(fd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### You need to test whether or not a file or directory exists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(os.path.exists('/etc/passwd'))\n",
    "print(os.path.exists('/etc/spam'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename = '/etc/spam'\n",
    "if os.path.exists(filename):\n",
    "    with open(filename) as f:\n",
    "        data = f.readline()\n",
    "    print(data)    \n",
    "else:\n",
    "    print (filename + ' does not exist')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List files in current directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "listdir =  os.listdir(\".\")\n",
    "for file in listdir:\n",
    "   print file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dealing with directories"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.mkdir(\"newdir\")\n",
    "os.chdir(\"newdir\")\n",
    "print(os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir(\"..\")\n",
    "print(os.getcwd())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.rmdir(\"newdir\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Accessing environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(os.environ['HOME'])\n",
    "print(os.environ.has_key(\"HOME\"))\n",
    "\n",
    "# using get will return `None` if a key is not present rather than raise a `KeyError`\n",
    "print(os.environ.get('KEY_THAT_MIGHT_EXIST'))\n",
    "\n",
    "# os.getenv is equivalent, and can also give a default value instead of `None`\n",
    "print(os.getenv('KEY_THAT_MIGHT_EXIST', 'SOME_KEY'))\n",
    "\n",
    "# Setting variable\n",
    "os.environ['PythonTraining'] = 'is fun'\n",
    "print(os.environ.get('PythonTraining'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Other utilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(os.path.isfile('/etc/passwd'))\n",
    "print(os.path.isdir('/etc/passwd'))\n",
    "print(os.path.islink('python'))\n",
    "print(os.path.realpath('python'))\n",
    "print(os.path.getsize('/etc/passwd'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shutil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The shutil module offers a number of high-level operations on <b>files and collections of files</b>. In particular, functions are provided which support file copying and removal. \n",
    "For operations on individual files, see also the os module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help (shutil.copy)\n",
    "help (shutil.move)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extra material"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "### Python object serialization\n",
    "\n",
    "The pickle module turns an arbitrary Python object into a series of bytes. This process is also called serialization. \n",
    "  - Useful for storing data\n",
    "  - Inter process communication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the pickle module\n",
    "import pickle\n",
    "\n",
    "data1 = [ { 'a':'A', 'b':2, 'c':3.0 } ]\n",
    "print('DATA:',)\n",
    "print(data1)\n",
    "\n",
    "# Use pickle.dumps() to create a string representation of the value of the object.\n",
    "data_string = pickle.dumps(data1)\n",
    "print()'PICKLE:', data_string )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, the pickle will contain only ASCII characters. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once the data is serialized, you can write it to a file, socket, pipe, etc. \n",
    "Then later you can read the file and unpickle the data to construct a new \n",
    "object with the same values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data1 = [ { 'a':'A', 'b':2, 'c':3.0 } ]\n",
    "print('BEFORE:',)\n",
    "print(data1)\n",
    "\n",
    "data2 = pickle.loads(data_string)\n",
    "print('AFTER:',)\n",
    "print(data2)\n",
    "\n",
    "print('EQUAL?:', (data1 == data2))\n",
    "print('SAME ?:', (data1 is data2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Write pickled data to a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "with open('pickledData.bin', 'wb') as f:\n",
    "    pickle.dump(data1, f)\n",
    "with open('pickledData.bin', 'rb') as f:\n",
    "    data2 = pickle.load(f)\n",
    "print('Data:',)\n",
    "print(data1)\n",
    "print('EQUAL?:', (data1 == data2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### File position"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open ('demo.txt') as f:\n",
    "    f.seek(5)                   # seek(offset) Changes file object's position\n",
    "    data = f.readline() \n",
    "    print (data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open ('demo.txt') as f:\n",
    "    f.seek(5)\n",
    "    data = f.readline() \n",
    "    print (data)\n",
    "    k = f.tell()              # tell() returns current position in file\n",
    "    print (k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using print  to automatically add new lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open ('elementsWithNewLine.txt', 'w') as f:\n",
    "    print('Noble gases', file=f)       # print automatically adds newline\n",
    "    for gas in ['He', 'Ne', 'Ar', 'Kr']:\n",
    "        print(gas, file=f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!cat elementsWithNewLine.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}