notebooks/unit03/unit03_02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook was prepared by Cayetano Benavent, 2016."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Working with files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "my_file = \"testfile.txt\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reading entire file and store in a string object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f = open(my_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "fr = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(fr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)\n",
      "\n",
      "Create an array.\n",
      "\n",
      "Parameters\n",
      "----------\n",
      "object : array_like\n",
      "    An array, any object exposing the array interface, an\n",
      "    object whose __array__ method returns an array, or any\n",
      "    (nested) sequence.\n",
      "dtype : data-type, optional\n",
      "    The desired data-type for the array.  If not given, then\n",
      "    the type will be determined as the minimum type required\n",
      "    to hold the objects in the sequence.  This argument can only\n",
      "    be used to 'upcast' the array.  For downcasting, use the\n",
      "    .astype(t) method.\n",
      "copy : bool, optional\n",
      "    If true (default), then the object is copied.  Otherwise, a copy\n",
      "    will only be made if __array__ returns a copy, if obj is a\n",
      "    nested sequence, or if a copy is needed to satisfy any of the other\n",
      "    requirements (`dtype`, `order`, etc.).\n",
      "order : {'C', 'F', 'A'}, optional\n",
      "    Specify the order of the array.  If order is 'C', then the array\n",
      "    will be in C-contiguous order (last-index varies the fastest).\n",
      "    If order is 'F', then the returned array will be in\n",
      "    Fortran-contiguous order (first-index varies the fastest).\n",
      "    If order is 'A' (default), then the returned array may be\n",
      "    in any order (either C-, Fortran-contiguous, or even discontiguous),\n",
      "    unless a copy is required, in which case it will be C-contiguous.\n",
      "subok : bool, optional\n",
      "    If True, then sub-classes will be passed-through, otherwise\n",
      "    the returned array will be forced to be a base-class array (default).\n",
      "ndmin : int, optional\n",
      "    Specifies the minimum number of dimensions that the resulting\n",
      "    array should have.  Ones will be pre-pended to the shape as\n",
      "    needed to meet this requirement.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(fr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Read entire file and store in a list object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f = open(my_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "frl = f.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)\\n', '\\n', 'Create an array.\\n', '\\n', 'Parameters\\n', '----------\\n', 'object : array_like\\n', '    An array, any object exposing the array interface, an\\n', '    object whose __array__ method returns an array, or any\\n', '    (nested) sequence.\\n', 'dtype : data-type, optional\\n', '    The desired data-type for the array.  If not given, then\\n', '    the type will be determined as the minimum type required\\n', '    to hold the objects in the sequence.  This argument can only\\n', \"    be used to 'upcast' the array.  For downcasting, use the\\n\", '    .astype(t) method.\\n', 'copy : bool, optional\\n', '    If true (default), then the object is copied.  Otherwise, a copy\\n', '    will only be made if __array__ returns a copy, if obj is a\\n', '    nested sequence, or if a copy is needed to satisfy any of the other\\n', '    requirements (`dtype`, `order`, etc.).\\n', \"order : {'C', 'F', 'A'}, optional\\n\", \"    Specify the order of the array.  If order is 'C', then the array\\n\", '    will be in C-contiguous order (last-index varies the fastest).\\n', \"    If order is 'F', then the returned array will be in\\n\", '    Fortran-contiguous order (first-index varies the fastest).\\n', \"    If order is 'A' (default), then the returned array may be\\n\", '    in any order (either C-, Fortran-contiguous, or even discontiguous),\\n', '    unless a copy is required, in which case it will be C-contiguous.\\n', 'subok : bool, optional\\n', '    If True, then sub-classes will be passed-through, otherwise\\n', '    the returned array will be forced to be a base-class array (default).\\n', 'ndmin : int, optional\\n', '    Specifies the minimum number of dimensions that the resulting\\n', '    array should have.  Ones will be pre-pended to the shape as\\n', '    needed to meet this requirement.\\n']\n"
     ]
    }
   ],
   "source": [
    "print(frl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(frl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(frl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Handling files in a Pythonic way with the WITH clause:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open(my_file) as f:\n",
    "    frl_w = f.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)\\n', '\\n', 'Create an array.\\n', '\\n', 'Parameters\\n', '----------\\n', 'object : array_like\\n', '    An array, any object exposing the array interface, an\\n', '    object whose __array__ method returns an array, or any\\n', '    (nested) sequence.\\n', 'dtype : data-type, optional\\n', '    The desired data-type for the array.  If not given, then\\n', '    the type will be determined as the minimum type required\\n', '    to hold the objects in the sequence.  This argument can only\\n', \"    be used to 'upcast' the array.  For downcasting, use the\\n\", '    .astype(t) method.\\n', 'copy : bool, optional\\n', '    If true (default), then the object is copied.  Otherwise, a copy\\n', '    will only be made if __array__ returns a copy, if obj is a\\n', '    nested sequence, or if a copy is needed to satisfy any of the other\\n', '    requirements (`dtype`, `order`, etc.).\\n', \"order : {'C', 'F', 'A'}, optional\\n\", \"    Specify the order of the array.  If order is 'C', then the array\\n\", '    will be in C-contiguous order (last-index varies the fastest).\\n', \"    If order is 'F', then the returned array will be in\\n\", '    Fortran-contiguous order (first-index varies the fastest).\\n', \"    If order is 'A' (default), then the returned array may be\\n\", '    in any order (either C-, Fortran-contiguous, or even discontiguous),\\n', '    unless a copy is required, in which case it will be C-contiguous.\\n', 'subok : bool, optional\\n', '    If True, then sub-classes will be passed-through, otherwise\\n', '    the returned array will be forced to be a base-class array (default).\\n', 'ndmin : int, optional\\n', '    Specifies the minimum number of dimensions that the resulting\\n', '    array should have.  Ones will be pre-pended to the shape as\\n', '    needed to meet this requirement.\\n']\n"
     ]
    }
   ],
   "source": [
    "print(frl_w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The file is closed (an error is triggered if you try to access):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "I/O operation on closed file.",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-30-bacd0e0f09a3>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mf\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: I/O operation on closed file."
     ]
    }
   ],
   "source": [
    "f.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Writing data to file (the file does not exist):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "testfile = '/tmp/testfile.txt'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open(testfile,'w') as f:\n",
    "    for i in range(20):\n",
    "        f.write('This is the loop number {0}.\\n'.format(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reading file previously created:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open('/tmp/testfile.txt') as f:\n",
    "    frl_w = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is the loop number 0.\n",
      "This is the loop number 1.\n",
      "This is the loop number 2.\n",
      "This is the loop number 3.\n",
      "This is the loop number 4.\n",
      "This is the loop number 5.\n",
      "This is the loop number 6.\n",
      "This is the loop number 7.\n",
      "This is the loop number 8.\n",
      "This is the loop number 9.\n",
      "This is the loop number 10.\n",
      "This is the loop number 11.\n",
      "This is the loop number 12.\n",
      "This is the loop number 13.\n",
      "This is the loop number 14.\n",
      "This is the loop number 15.\n",
      "This is the loop number 16.\n",
      "This is the loop number 17.\n",
      "This is the loop number 18.\n",
      "This is the loop number 19.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(frl_w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Working with path files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import ```os``` module to handle paths (in Python >= 3.4 you can also use ```pathlib```):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "myfilename = \"testfile.txt\"\n",
    "myfolder = \"/tmp\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The proper way to build paths:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "myfilepath = os.path.join(myfolder,myfilename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/tmp/testfile.txt'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfilepath"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check if the path exists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.exists(myfilepath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.isfile(myfilename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.isdir(myfilename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.isdir(myfolder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Handling path and extracting info:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "550"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.getsize(myfilepath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'testfile.txt'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.basename(myfilepath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/tmp'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.dirname(myfilepath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pth = os.path.split(myfilepath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('/tmp', 'testfile.txt')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['testfile', 'txt']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pth[1].split('.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create folders"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Creating folders:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "testfolder = \"/tmp/testfolder\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.exists(testfolder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "os.makedirs(testfolder)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.exists(testfolder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A better way to create folders:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if not os.path.exists(testfolder):\n",
    "    os.makedirs(testfolder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to create folders (removing if it exists using ```shutil```):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import shutil\n",
    "\n",
    "if not os.path.exists(testfolder):\n",
    "    os.makedirs(testfolder)\n",
    "else:\n",
    "    shutil.rmtree(testfolder)\n",
    "    os.makedirs(testfolder)"
   ]
  }
 ],
 "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}