03-Files-and-databases-handling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EdrARivWEEqD"
   },
   "source": [
    "# How to handle databases in python?\n",
    "\n",
    "Python DB-API is independent of any database engine, which enables you to write Python scripts to access any database engine. The Python DB API implementation for MySQL is MySQLdb. For PostgreSQL, it supports psycopg, PyGresQL and pyPgSQL modules. DB-API implementations for Oracle are dc_oracle2 and cx_oracle. Pydb2 is the DB-API implementation for DB2. Python’s DB-API consists of connection objects, cursor objects, standard exceptions and some other module content."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pAQPvLnM835u"
   },
   "source": [
    "For SQlite we will use sqlite3 module, You do not need to install this module separately because it is shipped by default along with Python version 2.5.x onwards."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nf8f_8Z9AHjP"
   },
   "source": [
    "To use sqlite3 module, you must first create a connection object that represents the database and then optionally you can create a cursor object, which will help you in executing all the SQL statements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "dOe_Xbjl8-DO",
    "outputId": "2755b588-d722-4a3a-ddc9-f76b43fdb712"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opened database successfully\n"
     ]
    }
   ],
   "source": [
    "import sqlite3\n",
    "\n",
    "conn = sqlite3.connect('test.db')\n",
    "\n",
    "print(\"Opened database successfully\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7IWG1a4NFDWp"
   },
   "source": [
    "What if I want to use Mysql dbms?\n",
    "No worries, create connection object like so."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "id": "oaDiWeEdFOpM"
   },
   "outputs": [],
   "source": [
    "# import MySQLdb\n",
    "# conn = MySQLdb.connect('hostname', user='maria', password='python')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2dmacyuYF3Dx"
   },
   "source": [
    "But I will continue with SQlite"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lffh2XRPDx8B"
   },
   "source": [
    "# Create"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "9Nch_rKVAOIu",
    "outputId": "f5514899-e0f6-41dd-ac99-5be68c36e5f1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Table created successfully\n"
     ]
    }
   ],
   "source": [
    "conn.execute('''CREATE TABLE COMPANY\n",
    "         (ID INT PRIMARY KEY     NOT NULL,\n",
    "         NAME           TEXT    NOT NULL,\n",
    "         AGE            INT     NOT NULL,\n",
    "         ADDRESS        CHAR(50),\n",
    "         SALARY         REAL);''')\n",
    "print(\"Table created successfully\")\n",
    "conn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "cuvN_cNJDu0J"
   },
   "source": [
    "# Insert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "vOzimKYkAp4e",
    "outputId": "de863c6d-4c5e-4fee-8baa-08594df81973"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opened database successfully\n",
      "Records created successfully\n"
     ]
    }
   ],
   "source": [
    "conn = sqlite3.connect('test.db')\n",
    "print(\"Opened database successfully\")\n",
    "\n",
    "conn.execute(\"INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \\\n",
    "      VALUES (1, 'Paul', 32, 'California', 20000.00 )\")\n",
    "\n",
    "conn.execute(\"INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \\\n",
    "      VALUES (2, 'Allen', 25, 'Texas', 15000.00 )\")\n",
    "\n",
    "conn.execute(\"INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \\\n",
    "      VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )\")\n",
    "\n",
    "conn.execute(\"INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \\\n",
    "      VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 )\")\n",
    "\n",
    "conn.commit()\n",
    "print(\"Records created successfully\")\n",
    "conn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5IlaRmFdDlDO"
   },
   "source": [
    "# Select"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nN0YMrmuBQQ-",
    "outputId": "14179802-7f5a-480d-fce4-28a6a12dbb40"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Opened database successfully\n",
      "ID =  1\n",
      "NAME =  Paul\n",
      "ADDRESS =  California\n",
      "SALARY =  20000.0 \n",
      "\n",
      "ID =  2\n",
      "NAME =  Allen\n",
      "ADDRESS =  Texas\n",
      "SALARY =  15000.0 \n",
      "\n",
      "ID =  3\n",
      "NAME =  Teddy\n",
      "ADDRESS =  Norway\n",
      "SALARY =  20000.0 \n",
      "\n",
      "ID =  4\n",
      "NAME =  Mark\n",
      "ADDRESS =  Rich-Mond \n",
      "SALARY =  65000.0 \n",
      "\n",
      "Operation done successfully\n"
     ]
    }
   ],
   "source": [
    "conn = sqlite3.connect('test.db')\n",
    "print(\"Opened database successfully\")\n",
    "\n",
    "cursor = conn.execute(\"SELECT id, name, address, salary from COMPANY\")\n",
    "\n",
    "# for row in cursor:\n",
    "#    print(row ,type(row))\n",
    "\n",
    "for row in cursor:\n",
    "   print( \"ID = \", row[0])\n",
    "   print(\"NAME = \", row[1])\n",
    "   print(\"ADDRESS = \", row[2])\n",
    "   print(\"SALARY = \", row[3], \"\\n\")\n",
    "\n",
    "print(\"Operation done successfully\")\n",
    "conn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Jqibq_JBDb8Z"
   },
   "source": [
    "# Update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "G0N-Qv9BBxq_",
    "outputId": "7e04513f-a4cc-47dd-fcc3-ea4674fe8d79"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of rows updated : 1\n",
      "ID =  1\n",
      "NAME =  Paul\n",
      "ADDRESS =  California\n",
      "SALARY =  25000.0 \n",
      "\n",
      "ID =  2\n",
      "NAME =  Allen\n",
      "ADDRESS =  Texas\n",
      "SALARY =  15000.0 \n",
      "\n",
      "ID =  3\n",
      "NAME =  Teddy\n",
      "ADDRESS =  Norway\n",
      "SALARY =  20000.0 \n",
      "\n",
      "ID =  4\n",
      "NAME =  Mark\n",
      "ADDRESS =  Rich-Mond \n",
      "SALARY =  65000.0 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "conn = sqlite3.connect('test.db')\n",
    "\n",
    "conn.execute(\"UPDATE COMPANY set SALARY = 25000.00 where ID = 1\")\n",
    "\n",
    "conn.commit()\n",
    "\n",
    "print(\"Total number of rows updated :\", conn.total_changes)\n",
    "\n",
    "cursor = conn.execute(\"SELECT id, name, address, salary from COMPANY\")\n",
    "for row in cursor:\n",
    "   print( \"ID = \", row[0])\n",
    "   print(\"NAME = \", row[1])\n",
    "   print(\"ADDRESS = \", row[2])\n",
    "   print(\"SALARY = \", row[3], \"\\n\")\n",
    "\n",
    "conn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VUKFj2z0DYfU"
   },
   "source": [
    "# DELETE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ijNNflbZC3Hy",
    "outputId": "d12ccfe3-d9b3-4f61-c16a-09057886172a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of rows deleted : 1\n",
      "ID =  1\n",
      "NAME =  Paul\n",
      "ADDRESS =  California\n",
      "SALARY =  25000.0 \n",
      "\n",
      "ID =  3\n",
      "NAME =  Teddy\n",
      "ADDRESS =  Norway\n",
      "SALARY =  20000.0 \n",
      "\n",
      "ID =  4\n",
      "NAME =  Mark\n",
      "ADDRESS =  Rich-Mond \n",
      "SALARY =  65000.0 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "conn = sqlite3.connect('test.db')\n",
    "\n",
    "conn.execute(\"DELETE from COMPANY where ID = 2;\")\n",
    "conn.commit()\n",
    "print(\"Total number of rows deleted :\", conn.total_changes)\n",
    "\n",
    "cursor = conn.execute(\"SELECT id, name, address, salary from COMPANY\")\n",
    "for row in cursor:\n",
    "   print( \"ID = \", row[0])\n",
    "   print(\"NAME = \", row[1])\n",
    "   print(\"ADDRESS = \", row[2])\n",
    "   print(\"SALARY = \", row[3], \"\\n\")\n",
    "\n",
    "conn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "gn6kTggTGfAS"
   },
   "source": [
    "### Read more @https://www.opensourceforu.com/2019/04/database-programming-python/\n",
    "\n",
    "### Recommended management tool https://sqlitebrowser.org/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-m9M6qeqHt7p"
   },
   "source": [
    "# Files Handling In Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "h61NasyqJdiD"
   },
   "source": [
    "Read data from standard input\n",
    "\n",
    "Two built-in functions to read data from standard input, which by default comes\n",
    "from the keyboard. These functions are input() and raw_input()\n",
    "\n",
    "In Python 3, raw_input() function is deprecated. Moreover, input() functions read data from\n",
    "keyboard as string, irrespective of whether it is enclosed with quotes ('' or \"\" ) or not.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "F_Q4NbE5J2Zn",
    "outputId": "b8194acd-a3d7-4768-fc04-821093b40c9a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your name?Muhammad\n"
     ]
    }
   ],
   "source": [
    "user_name = input('What is your name?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "hJJuaTPnDJhC",
    "outputId": "b5ecf642-5d45-4a46-e114-0894757659d5"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'Muhammad'"
      ]
     },
     "execution_count": 22,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "user_name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sBIhrg-gKxrH"
   },
   "source": [
    "So, What about files?\n",
    "to open a file use  open(file_name [, access_mode][, buffering])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4IG7BcgSKaHs",
    "outputId": "6bd80cb0-583c-488d-b2c7-797155f5fd92"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Open file and return a stream.  Raise OSError upon failure.\n",
      "\n",
      "file is either a text or byte string giving the name (and the path\n",
      "if the file isn't in the current working directory) of the file to\n",
      "be opened or an integer file descriptor of the file to be\n",
      "wrapped. (If a file descriptor is given, it is closed when the\n",
      "returned I/O object is closed, unless closefd is set to False.)\n",
      "\n",
      "mode is an optional string that specifies the mode in which the file\n",
      "is opened. It defaults to 'r' which means open for reading in text\n",
      "mode.  Other common values are 'w' for writing (truncating the file if\n",
      "it already exists), 'x' for creating and writing to a new file, and\n",
      "'a' for appending (which on some Unix systems, means that all writes\n",
      "append to the end of the file regardless of the current seek position).\n",
      "In text mode, if encoding is not specified the encoding used is platform\n",
      "dependent: locale.getpreferredencoding(False) is called to get the\n",
      "current locale encoding. (For reading and writing raw bytes use binary\n",
      "mode and leave encoding unspecified.) The available modes are:\n",
      "\n",
      "========= ===============================================================\n",
      "Character Meaning\n",
      "--------- ---------------------------------------------------------------\n",
      "'r'       open for reading (default)\n",
      "'w'       open for writing, truncating the file first\n",
      "'x'       create a new file and open it for writing\n",
      "'a'       open for writing, appending to the end of the file if it exists\n",
      "'b'       binary mode\n",
      "'t'       text mode (default)\n",
      "'+'       open a disk file for updating (reading and writing)\n",
      "'U'       universal newline mode (deprecated)\n",
      "========= ===============================================================\n",
      "\n",
      "The default mode is 'rt' (open for reading text). For binary random\n",
      "access, the mode 'w+b' opens and truncates the file to 0 bytes, while\n",
      "'r+b' opens the file without truncation. The 'x' mode implies 'w' and\n",
      "raises an `FileExistsError` if the file already exists.\n",
      "\n",
      "Python distinguishes between files opened in binary and text modes,\n",
      "even when the underlying operating system doesn't. Files opened in\n",
      "binary mode (appending 'b' to the mode argument) return contents as\n",
      "bytes objects without any decoding. In text mode (the default, or when\n",
      "'t' is appended to the mode argument), the contents of the file are\n",
      "returned as strings, the bytes having been first decoded using a\n",
      "platform-dependent encoding or using the specified encoding if given.\n",
      "\n",
      "'U' mode is deprecated and will raise an exception in future versions\n",
      "of Python.  It has no effect in Python 3.  Use newline to control\n",
      "universal newlines mode.\n",
      "\n",
      "buffering is an optional integer used to set the buffering policy.\n",
      "Pass 0 to switch buffering off (only allowed in binary mode), 1 to select\n",
      "line buffering (only usable in text mode), and an integer > 1 to indicate\n",
      "the size of a fixed-size chunk buffer.  When no buffering argument is\n",
      "given, the default buffering policy works as follows:\n",
      "\n",
      "* Binary files are buffered in fixed-size chunks; the size of the buffer\n",
      "  is chosen using a heuristic trying to determine the underlying device's\n",
      "  \"block size\" and falling back on `io.DEFAULT_BUFFER_SIZE`.\n",
      "  On many systems, the buffer will typically be 4096 or 8192 bytes long.\n",
      "\n",
      "* \"Interactive\" text files (files for which isatty() returns True)\n",
      "  use line buffering.  Other text files use the policy described above\n",
      "  for binary files.\n",
      "\n",
      "encoding is the name of the encoding used to decode or encode the\n",
      "file. This should only be used in text mode. The default encoding is\n",
      "platform dependent, but any encoding supported by Python can be\n",
      "passed.  See the codecs module for the list of supported encodings.\n",
      "\n",
      "errors is an optional string that specifies how encoding errors are to\n",
      "be handled---this argument should not be used in binary mode. Pass\n",
      "'strict' to raise a ValueError exception if there is an encoding error\n",
      "(the default of None has the same effect), or pass 'ignore' to ignore\n",
      "errors. (Note that ignoring encoding errors can lead to data loss.)\n",
      "See the documentation for codecs.register or run 'help(codecs.Codec)'\n",
      "for a list of the permitted encoding error strings.\n",
      "\n",
      "newline controls how universal newlines works (it only applies to text\n",
      "mode). It can be None, '', '\\n', '\\r', and '\\r\\n'.  It works as\n",
      "follows:\n",
      "\n",
      "* On input, if newline is None, universal newlines mode is\n",
      "  enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and\n",
      "  these are translated into '\\n' before being returned to the\n",
      "  caller. If it is '', universal newline mode is enabled, but line\n",
      "  endings are returned to the caller untranslated. If it has any of\n",
      "  the other legal values, input lines are only terminated by the given\n",
      "  string, and the line ending is returned to the caller untranslated.\n",
      "\n",
      "* On output, if newline is None, any '\\n' characters written are\n",
      "  translated to the system default line separator, os.linesep. If\n",
      "  newline is '' or '\\n', no translation takes place. If newline is any\n",
      "  of the other legal values, any '\\n' characters written are translated\n",
      "  to the given string.\n",
      "\n",
      "If closefd is False, the underlying file descriptor will be kept open\n",
      "when the file is closed. This does not work when a file name is given\n",
      "and must be True in that case.\n",
      "\n",
      "A custom opener can be used by passing a callable as *opener*. The\n",
      "underlying file descriptor for the file object is then obtained by\n",
      "calling *opener* with (*file*, *flags*). *opener* must return an open\n",
      "file descriptor (passing os.open as *opener* results in functionality\n",
      "similar to passing None).\n",
      "\n",
      "open() returns a file object whose type depends on the mode, and\n",
      "through which the standard file operations such as reading and writing\n",
      "are performed. When open() is used to open a file in a text mode ('w',\n",
      "'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open\n",
      "a file in a binary mode, the returned class varies: in read binary\n",
      "mode, it returns a BufferedReader; in write binary and append binary\n",
      "modes, it returns a BufferedWriter, and in read/write mode, it returns\n",
      "a BufferedRandom.\n",
      "\n",
      "It is also possible to use a string or bytearray as a file for both\n",
      "reading and writing. For strings StringIO can be used like a file\n",
      "opened in a text mode, and for bytes a BytesIO can be used like a file\n",
      "opened in a binary mode.\n"
     ]
    }
   ],
   "source": [
    "print(open.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 163
    },
    "id": "0KlkB9osLFRl",
    "outputId": "5c335ac9-23ed-4913-d12a-b8bef444e8df"
   },
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "ignored",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-27-c518c8bbca8b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmyfile\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'test.txt'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'test.txt'"
     ]
    }
   ],
   "source": [
    "myfile = open('test.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "id": "pPyWvfKALqNM"
   },
   "outputs": [],
   "source": [
    "myfile = open('test.txt','w')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "flfF8wweL-Ev",
    "outputId": "eeb1ae93-77ce-4423-dd10-7a6ef6254dc0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 29,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfile.closed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "fts5AFUrMP7m",
    "outputId": "4aedc941-732b-470a-d5a8-f0ccca8cde96"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'test.txt'"
      ]
     },
     "execution_count": 30,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfile.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "WI-eYPeiMT-_",
    "outputId": "32c7966d-9263-4dae-c06e-9b8c008f20f8"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'w'"
      ]
     },
     "execution_count": 31,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfile.mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ODqFYY4XMp0H"
   },
   "source": [
    "The close() method of a file object flushes any unwritten information and closes the file object,\n",
    "after which no more writing can be done.\n",
    "\n",
    "\n",
    "Python automatically closes a file when the reference object of a file is reassigned to another\n",
    "file. It is a good practice to use the close() method to close a file.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "2Va1XyfMMc74"
   },
   "outputs": [],
   "source": [
    "myfile.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oNMhGTM5M0qJ",
    "outputId": "1a00c603-e556-41c7-f80f-34f1d7160fa7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 34,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfile.closed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BPx380j9NFub"
   },
   "source": [
    "# Reading and Writing Files "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "b6ZNXYzvNQHI"
   },
   "source": [
    "fileObject.write(string)\n",
    "\n",
    "fileObject.read([count]) \n",
    "    **count** : the number of bytes to be read from the opened file. This method\n",
    "starts reading from the beginning of the file and if count is missing, then it tries to read as much\n",
    "as possible, maybe until the end of file.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "iJGTd591M2pJ"
   },
   "outputs": [],
   "source": [
    "# Open a file\n",
    "fo = open(\"test2.txt\", \"w\")\n",
    "fo .write(\"Python is a great language.\\nYeah its great!!\\n\")\n",
    "# Close opend file\n",
    "fo .close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gHoWZsekN1hU",
    "outputId": "b6f7e727-2b97-4b97-fdf4-70d1067730af"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read String is :  Python is \n"
     ]
    }
   ],
   "source": [
    "# Open a file\n",
    "fo = open(\"test2.txt\", \"r+\")\n",
    "str = fo.read(10)\n",
    "print (\"Read String is : \", str)\n",
    "# Close opened file\n",
    "fo .close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Xf9c_AFcOymL"
   },
   "source": [
    "# File Positions\n",
    "\n",
    "The **tell()** method tells you the current position within the file; in other words, the next read or\n",
    "write will occur at that many bytes from the beginning of the file.\n",
    "\n",
    "The **seek(offset[, from])** method changes the current file position. The **offset** argument indicates\n",
    "the number of bytes to be moved. The **from** argument specifies the reference position from\n",
    "where the bytes are to be moved.\n",
    "If from is set to 0, the beginning of the file is used as the reference position. If it is set to 1, the\n",
    "current position is used as the reference position. If it is set to 2 then the end of the file would be\n",
    "taken as the reference position.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4JDbCyGMOEo6",
    "outputId": "95439219-4b30-4af4-bb2b-1a8c1b5765fc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read String is :  Python is \n",
      "Current file position :  10\n",
      "Again read String is :  Python is \n",
      "Without seeking read String is :  a great la\n"
     ]
    }
   ],
   "source": [
    "# Open a file\n",
    "fo = open(\"test2.txt\", \"r\")\n",
    "str = fo.read(10)\n",
    "print (\"Read String is : \", str)\n",
    "# Check current position\n",
    "position = fo.tell()\n",
    "print (\"Current file position : \", position)\n",
    "# Reposition pointer at the beginning once again\n",
    "position = fo.seek(0, 0)\n",
    "str = fo.read(10)\n",
    "print (\"Again read String is : \", str)\n",
    "str = fo.read(10)\n",
    "print (\"Without seeking read String is : \", str)\n",
    "# Close opened file\n",
    "fo .close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r2tQgId2QcFV"
   },
   "source": [
    "#writelines()\n",
    "The writelines() method writes the items of a list to the file.\n",
    "\n",
    "Where the texts will be inserted depends on the file mode and stream position.\n",
    "\n",
    "\"a\":  The texts will be inserted at the current file stream position, default at the end of the file.\n",
    "\n",
    "\"w\": The file will be emptied before the texts will be inserted at the current file stream position, default 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3zVydgQkPe76",
    "outputId": "a164ef99-d6c0-4c8b-a41f-f6c134cf01f2"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "See you soon!\n",
      "Over and out.\n"
     ]
    }
   ],
   "source": [
    "f = open(\"test.txt\", \"a\")\n",
    "f.writelines([\"\\nSee you soon!\", \"\\nOver and out.\"])\n",
    "f.close()\n",
    "\n",
    "#open and read the file after the appending:\n",
    "f = open(\"test.txt\", \"r\")\n",
    "print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w5nL5CWiRDUL"
   },
   "source": [
    "# file.readlines([hint])\n",
    "The readlines() method returns a list containing each line in the file as a list item.\n",
    "\n",
    "Use the hint parameter to limit the number of lines returned. If the total number of bytes returned exceeds the specified number, no more lines are returned.\n",
    "\n",
    "\n",
    "hint is optional. Default value is  -1, which means all lines will be returned.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "DAMlzeL-QzVN",
    "outputId": "3aa24cd7-b0e4-477c-d2bf-e56bcfbc42a9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['\\n', 'See you soon!\\n', 'Over and out.']\n",
      "\n",
      "with hint : \n",
      " ['\\n', 'See you soon!\\n']\n"
     ]
    }
   ],
   "source": [
    "f = open(\"test.txt\", \"r\")\n",
    "print(f.readlines())\n",
    "# print('\\nwith hint : \\n',f.readlines(1)) # what will happen if we uncomment this line?!\n",
    "f.close()\n",
    "f = open(\"test.txt\", \"r\")\n",
    "print('\\nwith hint : \\n',f.readlines(2))\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AoABNTNrS1Bq"
   },
   "source": [
    "# With statement\n",
    "The with statement simplifies exception handling by encapsulating common preparation and cleanup tasks.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "A0Ic0bo9RxuT",
    "outputId": "898c6066-9752-4086-ea2d-d620e68dda1a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "See you soon!\n",
      "Over and out.\n"
     ]
    }
   ],
   "source": [
    "with open(\"test.txt\") as file: # Use file to refer to the file object\n",
    "\n",
    "  print(file.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "zaPyY8vYTK-M",
    "outputId": "3bb43753-b01b-4e19-e482-13a81ea51df9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi there!\n"
     ]
    }
   ],
   "source": [
    "with open('test.txt', 'w') as file:  # Use file to refer to the file object\n",
    "\n",
    "    file.write('Hi there!')\n",
    "\n",
    "with open(\"test.txt\") as file: # Use file to refer to the file object\n",
    "\n",
    "  print(file.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ke1lBw5YTozi"
   },
   "source": [
    "### Notice, that we didn’t have to write “file.close()”. That will automatically be called."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bxYQ_oA1TjWX",
    "outputId": "2167c32e-085b-4f8a-d362-6b5ed4e41037"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "See you soon!\n",
      " \n",
      "\n",
      "Over and out.\n",
      " \n",
      "\n",
      "knock knock, who is there?\n",
      " \n",
      "\n",
      "blablablabla \n",
      "\n"
     ]
    }
   ],
   "source": [
    "f = open(\"test.txt\", \"w\")\n",
    "f.writelines([\"See you soon!\", \"\\nOver and out.\",'\\nknock knock, who is there?','\\nblablablabla'])\n",
    "f.close()\n",
    "\n",
    "\n",
    "f = open(\"test.txt\", \"r\")\n",
    "for line in f:  \n",
    "  print(line,'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nGl54yiDUCzr",
    "outputId": "784d715b-2ef6-4f57-9f90-0975b11aae7f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "See you soon!\n",
      "\n",
      "Over and out.\n",
      "\n",
      "knock knock, who is there?\n",
      "\n",
      "blablablabla\n"
     ]
    }
   ],
   "source": [
    "with open(\"test.txt\", \"r\") as a_file:\n",
    "  for line in a_file:\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oSctaALRVIcX"
   },
   "source": [
    "# Renaming and Deleting Files\n",
    "Python **os module** provides methods that help you perform file-processing operations, such as renaming and deleting files.\n",
    "\n",
    "To use this module, you need to import it first and then you can call any related functions.\n",
    "\n",
    "os.rename(current_file_name, new_file_name)\n",
    "\n",
    "os.remove(file_name)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "id": "QkzFDCa6U-UE"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "# Rename a file from test2.txt to test1.txt\n",
    "os.rename( \"test2.txt\", \"test1.txt\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "id": "CLsQG69VVrCl"
   },
   "outputs": [],
   "source": [
    "# Delete file test1.txt\n",
    "os.remove(\"test1.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "UXWF-bXlWH3b"
   },
   "source": [
    "You can use the mkdir() method of the os module to create directories in the current directory.\n",
    "\n",
    "You need to supply an argument to this method, which contains the name of the directory to be created.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "id": "oDuwU8g4VyaL"
   },
   "outputs": [],
   "source": [
    "os.mkdir('new_folder')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "EtdFrQbGWSKP",
    "outputId": "fc1878ed-99fc-4881-fa1e-ef1d9ffd19c8"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'/content'"
      ]
     },
     "execution_count": 70,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "id": "lTG8sCE2WjXf"
   },
   "outputs": [],
   "source": [
    "os.chdir(\"new_folder\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "5ton79VzWvk-",
    "outputId": "269ff8ca-125a-4d6e-9f89-5d91eaa76cc3"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'/content/new_folder'"
      ]
     },
     "execution_count": 73,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "id": "bC3FL6DzXDTb"
   },
   "outputs": [],
   "source": [
    "os.chdir('../')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "id": "qsE1_DmYXLJM",
    "outputId": "83a855dd-e1a6-48d2-df88-f22a0e40c2ae"
   },
   "outputs": [
    {
     "data": {
      "application/vnd.google.colaboratory.intrinsic+json": {
       "type": "string"
      },
      "text/plain": [
       "'/content'"
      ]
     },
     "execution_count": 77,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "id": "Phyuf42LWys4"
   },
   "outputs": [],
   "source": [
    "os.rmdir('new_folder')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tMX60a4zW__g",
    "outputId": "24732016-eee7-468b-9916-72869e7b2432"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['.config', 'test.txt', '.ipynb_checkpoints', 'test.db', 'sample_data']"
      ]
     },
     "execution_count": 79,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.listdir()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "id": "FYr2iEFwXb6v"
   },
   "outputs": [],
   "source": [
    "# os.listdir() will get you everything that's in a directory - files and directories.\n",
    "\n",
    "# If you want just files, you could filter this down using os.path:\n",
    "\n",
    "from os import listdir\n",
    "from os.path import isfile, join\n",
    "mypath = os.getcwd()\n",
    "onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oK3eU6QSX7QY",
    "outputId": "93a5e99c-96dc-44d2-9bc5-ef2df46864e0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['test.txt', 'test.db']"
      ]
     },
     "execution_count": 81,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "onlyfiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qgyrODyVX8fc"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "03-Files and databases.ipynb",
   "provenance": []
  },
  "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": 1
}