CE302-Week6-Exercise.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Motivation\n",
    "Storing data and the results of your programming efforts is important for working over multiple sessions and sharing your results with collaborators. Since when Python closes, all the variables in the memory are lost, data must be stored in some other way. Sometimes data must also be readable by or written in a form that can be read by other programs.\n",
    "\n",
    "This chapter shows you how you can use Python to read and write data in several common formats."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. TXT Files\n",
    "\n",
    "So far, we used print function to display the data to the screen. But there are many ways to store data onto your disk and share it with other program or colleagues. For example, if I have some strings in this notebook, but I want to use them in another notebook, the easiest way is to store the strings into a text file, and then open it in another notebook. A text file, many times with an extension .txt, is a file containing only plain text. However, programs you write and programs that read your text file will usually expect the text file to be in a certain format; that is, organized in a specific way.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To work with text files, we need to use open function which returns a file object. \n",
    "# It is commonly used with two arguments:\n",
    "\n",
    "f = open(filename, mode) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f is the returned file object. The filename is a string where the location of the file you want to open, and the mode is another string containing a few characters describing the way in which the file will be used, the common modes are:\n",
    "\n",
    "* ‘r’, this is the default mode, which opens a file for reading\n",
    "\n",
    "* ‘w’, this mode opens a file for writing, if the file does not exist, it creates a new file.\n",
    "\n",
    "* ‘a’, open a file in append mode, append data to end of file. If the file does not exist, it creates a new file.\n",
    "\n",
    "* ‘b’, open a file in binary mode.\n",
    "\n",
    "* ‘r+’, open a file (do not create) for reading and writing.\n",
    "\n",
    "* ‘w+’, open or create a file for writing and reading, discard existing contents.\n",
    "\n",
    "* ‘a+’, open or create file for reading and writing, and append data to end of file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name's Firat\n"
     ]
    }
   ],
   "source": [
    "print('My name\\'s Firat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a file\n",
    "# TRY IT! Create a text file called test.txt and write a couple lines in it.\n",
    "\n",
    "f = open('./CodeOutputs/test.txt', 'w')\n",
    "for i in range(5):\n",
    "    f.write(f\"This is line {i}\\n\")\n",
    "    \n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NOTE! It is good practice to close the file using f.close() in the end. If you do not close them yourself, Python will eventually close them for you. But sometimes, when writing to a file, the data may not written to disk until you close the file. Therefore, the longer you keep the file open, the greater chances you will lose your data.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Append to a file\n",
    "# Now, let’s append some string to the test.txt file. It is very similar to how we write the file, with only one difference - change the mode to ‘a’ instead.\n",
    "\n",
    "f = open('./CodeOutputs/test.txt', 'a')\n",
    "f.write(f\"This is another line\\n\")\n",
    "f.close()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is line 0\n",
      "This is line 1\n",
      "This is line 2\n",
      "This is line 3\n",
      "This is line 4\n",
      "This is another line\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Read a file\n",
    "# We could read a file from disk and store all the contents to a variable. \n",
    "# Let’s read in the test.txt file we created above and store all the contents in the file to a variable content.\n",
    "\n",
    "f = open('./CodeOutputs/test.txt', 'r')\n",
    "content = f.read()\n",
    "f.close()\n",
    "print(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['This is line 0\\n', 'This is line 1\\n', 'This is line 2\\n', 'This is line 3\\n', 'This is line 4\\n', 'This is another line\\n']\n"
     ]
    }
   ],
   "source": [
    "# But sometimes we want to read in the contents in the files line by line and store it in a list. \n",
    "# We could use f.readlines() to achieve this.\n",
    "\n",
    "f = open('./CodeOutputs/test.txt', 'r')\n",
    "contents = f.readlines()\n",
    "f.close()\n",
    "print(contents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(contents)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dealing with numbers and arrays\n",
    "Since we are working with numerical methods later, and many times, we work with the numbers or arrays. We could use the above methods to save the numbers or arrays to a file and read it back to the memory. But it is not so convenient this way. Instead, commonly we use the numpy package to directly save/read an array. Let’s see an example.\n",
    "\n",
    "TRY IT! \n",
    "\n",
    "Store an array [[1.20, 2.20, 3.00], [4.14, 5.65, 6.42]] to a file named my_array.txt and read it back to a variable called my_arr."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.2 , 2.2 , 3.  ],\n",
       "       [4.14, 5.65, 6.42]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "arr = np.array([[1.20, 2.20, 3.00], [4.14, 5.65, 6.42]])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt('./CodeOutputs/my_arr.txt', arr, fmt='%.2f', header = 'Col1 Col2 Col3')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mSignature:\u001b[0m\n",
       "\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msavetxt\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mfname\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mX\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mfmt\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'%.18e'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mdelimiter\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m' '\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mnewline\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'\\n'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mheader\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m''\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mfooter\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m''\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mcomments\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'# '\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mencoding\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mDocstring:\u001b[0m\n",
       "Save an array to a text file.\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "fname : filename or file handle\n",
       "    If the filename ends in ``.gz``, the file is automatically saved in\n",
       "    compressed gzip format.  `loadtxt` understands gzipped files\n",
       "    transparently.\n",
       "X : 1D or 2D array_like\n",
       "    Data to be saved to a text file.\n",
       "fmt : str or sequence of strs, optional\n",
       "    A single format (%10.5f), a sequence of formats, or a\n",
       "    multi-format string, e.g. 'Iteration %d -- %10.5f', in which\n",
       "    case `delimiter` is ignored. For complex `X`, the legal options\n",
       "    for `fmt` are:\n",
       "\n",
       "    * a single specifier, `fmt='%.4e'`, resulting in numbers formatted\n",
       "      like `' (%s+%sj)' % (fmt, fmt)`\n",
       "    * a full string specifying every real and imaginary part, e.g.\n",
       "      `' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns\n",
       "    * a list of specifiers, one per column - in this case, the real\n",
       "      and imaginary part must have separate specifiers,\n",
       "      e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns\n",
       "delimiter : str, optional\n",
       "    String or character separating columns.\n",
       "newline : str, optional\n",
       "    String or character separating lines.\n",
       "\n",
       "    .. versionadded:: 1.5.0\n",
       "header : str, optional\n",
       "    String that will be written at the beginning of the file.\n",
       "\n",
       "    .. versionadded:: 1.7.0\n",
       "footer : str, optional\n",
       "    String that will be written at the end of the file.\n",
       "\n",
       "    .. versionadded:: 1.7.0\n",
       "comments : str, optional\n",
       "    String that will be prepended to the ``header`` and ``footer`` strings,\n",
       "    to mark them as comments. Default: '# ',  as expected by e.g.\n",
       "    ``numpy.loadtxt``.\n",
       "\n",
       "    .. versionadded:: 1.7.0\n",
       "encoding : {None, str}, optional\n",
       "    Encoding used to encode the outputfile. Does not apply to output\n",
       "    streams. If the encoding is something other than 'bytes' or 'latin1'\n",
       "    you will not be able to load the file in NumPy versions < 1.14. Default\n",
       "    is 'latin1'.\n",
       "\n",
       "    .. versionadded:: 1.14.0\n",
       "\n",
       "\n",
       "See Also\n",
       "--------\n",
       "save : Save an array to a binary file in NumPy ``.npy`` format\n",
       "savez : Save several arrays into an uncompressed ``.npz`` archive\n",
       "savez_compressed : Save several arrays into a compressed ``.npz`` archive\n",
       "\n",
       "Notes\n",
       "-----\n",
       "Further explanation of the `fmt` parameter\n",
       "(``%[flag]width[.precision]specifier``):\n",
       "\n",
       "flags:\n",
       "    ``-`` : left justify\n",
       "\n",
       "    ``+`` : Forces to precede result with + or -.\n",
       "\n",
       "    ``0`` : Left pad the number with zeros instead of space (see width).\n",
       "\n",
       "width:\n",
       "    Minimum number of characters to be printed. The value is not truncated\n",
       "    if it has more characters.\n",
       "\n",
       "precision:\n",
       "    - For integer specifiers (eg. ``d,i,o,x``), the minimum number of\n",
       "      digits.\n",
       "    - For ``e, E`` and ``f`` specifiers, the number of digits to print\n",
       "      after the decimal point.\n",
       "    - For ``g`` and ``G``, the maximum number of significant digits.\n",
       "    - For ``s``, the maximum number of characters.\n",
       "\n",
       "specifiers:\n",
       "    ``c`` : character\n",
       "\n",
       "    ``d`` or ``i`` : signed decimal integer\n",
       "\n",
       "    ``e`` or ``E`` : scientific notation with ``e`` or ``E``.\n",
       "\n",
       "    ``f`` : decimal floating point\n",
       "\n",
       "    ``g,G`` : use the shorter of ``e,E`` or ``f``\n",
       "\n",
       "    ``o`` : signed octal\n",
       "\n",
       "    ``s`` : string of characters\n",
       "\n",
       "    ``u`` : unsigned decimal integer\n",
       "\n",
       "    ``x,X`` : unsigned hexadecimal integer\n",
       "\n",
       "This explanation of ``fmt`` is not complete, for an exhaustive\n",
       "specification see [1]_.\n",
       "\n",
       "References\n",
       "----------\n",
       ".. [1] `Format Specification Mini-Language\n",
       "       <https://docs.python.org/library/string.html#format-specification-mini-language>`_,\n",
       "       Python Documentation.\n",
       "\n",
       "Examples\n",
       "--------\n",
       ">>> x = y = z = np.arange(0.0,5.0,1.0)\n",
       ">>> np.savetxt('test.out', x, delimiter=',')   # X is an array\n",
       ">>> np.savetxt('test.out', (x,y,z))   # x,y,z equal sized 1D arrays\n",
       ">>> np.savetxt('test.out', x, fmt='%1.4e')   # use exponential notation\n",
       "\u001b[1;31mFile:\u001b[0m      c:\\users\\frtbz\\anaconda3\\lib\\site-packages\\numpy\\lib\\npyio.py\n",
       "\u001b[1;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?np.savetxt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function savetxt in module numpy:\n",
      "\n",
      "savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\\n', header='', footer='', comments='# ', encoding=None)\n",
      "    Save an array to a text file.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    fname : filename or file handle\n",
      "        If the filename ends in ``.gz``, the file is automatically saved in\n",
      "        compressed gzip format.  `loadtxt` understands gzipped files\n",
      "        transparently.\n",
      "    X : 1D or 2D array_like\n",
      "        Data to be saved to a text file.\n",
      "    fmt : str or sequence of strs, optional\n",
      "        A single format (%10.5f), a sequence of formats, or a\n",
      "        multi-format string, e.g. 'Iteration %d -- %10.5f', in which\n",
      "        case `delimiter` is ignored. For complex `X`, the legal options\n",
      "        for `fmt` are:\n",
      "    \n",
      "        * a single specifier, `fmt='%.4e'`, resulting in numbers formatted\n",
      "          like `' (%s+%sj)' % (fmt, fmt)`\n",
      "        * a full string specifying every real and imaginary part, e.g.\n",
      "          `' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns\n",
      "        * a list of specifiers, one per column - in this case, the real\n",
      "          and imaginary part must have separate specifiers,\n",
      "          e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns\n",
      "    delimiter : str, optional\n",
      "        String or character separating columns.\n",
      "    newline : str, optional\n",
      "        String or character separating lines.\n",
      "    \n",
      "        .. versionadded:: 1.5.0\n",
      "    header : str, optional\n",
      "        String that will be written at the beginning of the file.\n",
      "    \n",
      "        .. versionadded:: 1.7.0\n",
      "    footer : str, optional\n",
      "        String that will be written at the end of the file.\n",
      "    \n",
      "        .. versionadded:: 1.7.0\n",
      "    comments : str, optional\n",
      "        String that will be prepended to the ``header`` and ``footer`` strings,\n",
      "        to mark them as comments. Default: '# ',  as expected by e.g.\n",
      "        ``numpy.loadtxt``.\n",
      "    \n",
      "        .. versionadded:: 1.7.0\n",
      "    encoding : {None, str}, optional\n",
      "        Encoding used to encode the outputfile. Does not apply to output\n",
      "        streams. If the encoding is something other than 'bytes' or 'latin1'\n",
      "        you will not be able to load the file in NumPy versions < 1.14. Default\n",
      "        is 'latin1'.\n",
      "    \n",
      "        .. versionadded:: 1.14.0\n",
      "    \n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    save : Save an array to a binary file in NumPy ``.npy`` format\n",
      "    savez : Save several arrays into an uncompressed ``.npz`` archive\n",
      "    savez_compressed : Save several arrays into a compressed ``.npz`` archive\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    Further explanation of the `fmt` parameter\n",
      "    (``%[flag]width[.precision]specifier``):\n",
      "    \n",
      "    flags:\n",
      "        ``-`` : left justify\n",
      "    \n",
      "        ``+`` : Forces to precede result with + or -.\n",
      "    \n",
      "        ``0`` : Left pad the number with zeros instead of space (see width).\n",
      "    \n",
      "    width:\n",
      "        Minimum number of characters to be printed. The value is not truncated\n",
      "        if it has more characters.\n",
      "    \n",
      "    precision:\n",
      "        - For integer specifiers (eg. ``d,i,o,x``), the minimum number of\n",
      "          digits.\n",
      "        - For ``e, E`` and ``f`` specifiers, the number of digits to print\n",
      "          after the decimal point.\n",
      "        - For ``g`` and ``G``, the maximum number of significant digits.\n",
      "        - For ``s``, the maximum number of characters.\n",
      "    \n",
      "    specifiers:\n",
      "        ``c`` : character\n",
      "    \n",
      "        ``d`` or ``i`` : signed decimal integer\n",
      "    \n",
      "        ``e`` or ``E`` : scientific notation with ``e`` or ``E``.\n",
      "    \n",
      "        ``f`` : decimal floating point\n",
      "    \n",
      "        ``g,G`` : use the shorter of ``e,E`` or ``f``\n",
      "    \n",
      "        ``o`` : signed octal\n",
      "    \n",
      "        ``s`` : string of characters\n",
      "    \n",
      "        ``u`` : unsigned decimal integer\n",
      "    \n",
      "        ``x,X`` : unsigned hexadecimal integer\n",
      "    \n",
      "    This explanation of ``fmt`` is not complete, for an exhaustive\n",
      "    specification see [1]_.\n",
      "    \n",
      "    References\n",
      "    ----------\n",
      "    .. [1] `Format Specification Mini-Language\n",
      "           <https://docs.python.org/library/string.html#format-specification-mini-language>`_,\n",
      "           Python Documentation.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> x = y = z = np.arange(0.0,5.0,1.0)\n",
      "    >>> np.savetxt('test.out', x, delimiter=',')   # X is an array\n",
      "    >>> np.savetxt('test.out', (x,y,z))   # x,y,z equal sized 1D arrays\n",
      "    >>> np.savetxt('test.out', x, fmt='%1.4e')   # use exponential notation\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.savetxt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see from the above example to save a 2D array into a text file using np.savetxt. The first argument is the file name, second argument is the arr object we wave to save, and the third argument is to define the format for the output (I use ‘%.2f’ to indicate we want the output numbers with 2 decimals). The fourth argument is the header we want to write into the file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CSV Files\n",
    "There are many scientific data are stored in the comma-separated values (CSV) file format, a delimited text file that uses a comma to separate values. It is a very useful format that can store large tables of data (numbers and text) in plain text. Each line (row) in the data is one data record, and each record consists of one or more fields, separated by commas. It also can be opened using Microsoft Excel, and visualize the rows and columns.\n",
    "\n",
    "Python has its own csv module that could handle the reading and writing of the csv file, you can see the details in the documentation. But we are not going to introduce this csv module here. Instead, we will use the numpy package to deal with the csv file since many times we will read csv file directly to a numpy array.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write and open a CSV file\n",
    "# Let’s see a simple example of generating 100 rows and 5 columns of data.\n",
    "\n",
    "import numpy as np\n",
    "data = np.random.random((100,5))\n",
    "np.savetxt('./CodeOutputs/test.csv', data, fmt = '%.2f', delimiter=',', header = 'c1, c2, c3, c4, c5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We first generate the random data for 100 rows and 5 columns using the np.random function and assign it to data variable. We use the np.savetxt function to save the data to a csv file. We can see that the first 3 arguments are the same for the ones used in the previous section, but here we set the delimiter argument to ‘,’, which indicate that we want to separate the data using comma."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read a CSV file\n",
    "As before, we could read in the csv file using the np.loadtxt function. Let’s read in the csv file we just saved to the disk to a variable my_csv, and output the first 5 rows. Note here we use the delimiter again to specify that the data in the file is separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.31, 0.78, 0.19, 0.93, 0.98],\n",
       "       [0.4 , 0.68, 0.48, 0.24, 0.15],\n",
       "       [0.26, 0.29, 0.15, 0.51, 0.95],\n",
       "       [0.5 , 0.03, 0.15, 0.52, 0.1 ],\n",
       "       [0.33, 0.19, 0.28, 0.78, 0.09],\n",
       "       [0.66, 0.87, 0.95, 0.21, 0.05],\n",
       "       [0.2 , 0.53, 0.21, 0.96, 0.88],\n",
       "       [0.83, 0.61, 0.76, 0.88, 0.44],\n",
       "       [0.37, 0.17, 0.98, 0.12, 0.43],\n",
       "       [0.31, 0.73, 0.46, 0.89, 0.56]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_csv = np.loadtxt('./CodeOutputs/test.csv', delimiter=',')\n",
    "my_csv[:10, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open(\"./CodeOutputs/testfile.txt\",\"w\") \n",
    " \n",
    "file.write('Hello World\\n') \n",
    "file.write('This is our new text file') \n",
    "file.write('and this is another line.') \n",
    "file.write('Why? Because we can.') \n",
    " \n",
    "file.close() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "This is our new text fileand this is another line.Why? Because we can.\n"
     ]
    }
   ],
   "source": [
    "file = open('./CodeOutputs/testfile.txt', 'r') \n",
    "print(file.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "\n",
      "This is our new text fileand this is another line.Why? Because we can.\n"
     ]
    }
   ],
   "source": [
    "file = open('./CodeOutputs/testfile.txt', 'r') \n",
    "for line in file:\n",
    "    print(line) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2.95e-04,  2.89e-04,  2.73e-04,  2.50e-04,  2.22e-04],\n",
       "       [ 1.91e-04,  1.59e-04,  1.23e-04,  8.11e-05,  3.01e-05],\n",
       "       [-3.04e-05, -9.93e-05, -1.76e-04, -2.58e-04, -3.45e-04],\n",
       "       ...,\n",
       "       [ 5.94e-04,  5.85e-04,  5.77e-04,  5.69e-04,  5.60e-04],\n",
       "       [ 5.52e-04,  5.43e-04,  5.35e-04,  5.26e-04,  5.17e-04],\n",
       "       [ 5.09e-04,  5.00e-04,  4.91e-04,  4.82e-04,  4.73e-04]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_acc = np.loadtxt('./CodeOutputs/RSN779_LOMAP_LGP000AT2.csv', delimiter=',', skiprows=4)\n",
    "my_acc[: , :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(my_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(my_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.000295],\n",
       "       [0.000289],\n",
       "       [0.000273],\n",
       "       ...,\n",
       "       [0.000491],\n",
       "       [0.000482],\n",
       "       [0.000473]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_acc = my_acc.reshape(5000,1)\n",
    "my_acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5000"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(my_acc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25.0"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dt = np.arange(0.005, 25.005, 0.005).tolist()\n",
    "my_dt[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5000"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(my_dt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.figure(figsize = (14, 8))\n",
    "\n",
    "plt.plot(my_dt,my_acc)\n",
    "plt.title('Loma Prieta Accelaration Time History')\n",
    "plt.xlabel('Time(sec)')\n",
    "plt.ylabel('PGA(g)')\n",
    "plt.grid()\n",
    "plt.plot()\n",
    "plt.savefig('./CodeOutputs/LOMAP.png')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}