P08.0_File_Handling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computer Programming with Python\n",
    "\n",
    "#### Instructor : Dr. Aydin Demir\n",
    "\n",
    "www.aydindemir.com | GitHub & Instagram: @craxLab | Web: www.craxLab.com\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### _The topics of the week !_\n",
    "\n",
    "- I/O Functions\n",
    "    - File Input / Output (I/O)\n",
    "    - Open / Close Files\n",
    "    - _File_ Object Attributes\n",
    "    - Reading and Writing Files\n",
    "    - Directories \n",
    "    \n",
    "We will learn about file opretions such as opening a file, reading from it, writing to it, closing it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python File Handling\n",
    "\n",
    "Till now, we were taking the input from the console and writing it back to the console to interact with the user.\n",
    "\n",
    "Sometimes, it is not enough to only display the data on the console. The data to be displayed may be very large, and only a limited amount of data can be displayed on the console since the memory is volatile, it is impossible to recover the programmatically generated data again and again.\n",
    "\n",
    "The file handling plays an important role when the data needs to be stored permanently into the file. A file is a named location on disk to store related information. We can access the stored information (non-volatile) after the program termination.\n",
    "\n",
    "In Python, files are treated in two modes as text or binary. The file may be in the text or binary format, and each line of a file is ended with the special character.\n",
    "\n",
    "A file is called **text file** if its content consists of an encoded sequence of Unicode code points.\n",
    "\n",
    "A **binary file** is a computer file that is not a text file such as database, spreadsheet and multimedia files. (Resim dosyaları, müzik dosyaları, video dosyaları, MS Office dosyaları, LibreOffice dosyaları, OpenOffice dosyaları, vb. ikili dosyalara örnektir)\n",
    "\n",
    "\n",
    "Hence, **a file operation can be done in the following order.**\n",
    "\n",
    "> Open a file\n",
    "\n",
    "> Read or write - Performing operation\n",
    "\n",
    "> Close the file\n",
    "\n",
    "Python has several functions for creating, reading, updating, and deleting files.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Open a File on the Server\n",
    "\n",
    "The key function for working with files in Python is the open() function.\n",
    "\n",
    "The open() function takes two parameters; ***filename***, and ***mode***.\n",
    "\n",
    "\n",
    "**There are four different methods (modes) for opening a file:**\n",
    "\n",
    "\"r\" - Read - Default value. Opens a file for reading, error if the file does not exist\n",
    "\n",
    "\"a\" - Append - Opens a file for appending, creates the file if it does not exist\n",
    "\n",
    "\"w\" - Write - Opens a file for writing, creates the file if it does not exist\n",
    "\n",
    "\"x\" - Create - Creates the specified file, returns an error if the file exists\n",
    "\n",
    "\n",
    "**In addition you can specify if the file should be handled as binary or text mode**\n",
    "\n",
    "\"t\" - Text - Default value. Text mode\n",
    "\n",
    "\"b\" - Binary - Binary mode (e.g. images)\n",
    "\n",
    "\n",
    "#### Syntax\n",
    "\n",
    "To open a file for reading it is enough to specify the name of the file:\n",
    "\n",
    "*file object = open(file-name, access-mode, buffering)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'demofile.txt'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_12484\\2695255491.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Make sure the file exists, or else you will get an error.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mf\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"demofile.txt\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'demofile.txt'"
     ]
    }
   ],
   "source": [
    "# Make sure the file exists, or else you will get an error.\n",
    "f = open(\"demofile.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The code below is the same as: f = open(\"Sakarya.txt\", \"rt\")\n",
    "\n",
    "Because \"r\" for read, and \"t\" for text are the default values, you do not need to specify them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(\"data/sakarya.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./Figures/ch10/sakaryatxt.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The open() function returns a file object, which has a read() method for reading the content of the file:\n",
    "\n",
    "*fileobj.read(count)* \n",
    "\n",
    "Here, the count is the number of bytes (character) to be read from the file starting from the beginning of the file. If the count is not specified, then it may read the content of the file until the end."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the file is located in a different location, you will have to specify the file path, like this:\n",
    "\n",
    "Example: Open a file on a different location: \n",
    "\n",
    "f = open(\"D:\\\\myfiles\\sakarya.txt\", \"r\")\n",
    "\n",
    "print(f.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakarya University\n",
      "Faculty of Engineering\n",
      "Department of Civil Engineering\n"
     ]
    }
   ],
   "source": [
    "f = open(\"data/sakarya.txt\", \"r\")\n",
    "print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default the read() method returns the whole text, but you can also specify how many characters you want to return:\n",
    "\n",
    "Example:\n",
    "\n",
    "Return the 5 first characters of the file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakar\n"
     ]
    }
   ],
   "source": [
    "f = open(\"data/sakarya.txt\", \"r\")\n",
    "print(f.read(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read Lines\n",
    "\n",
    "You can return one line by using the readline() method:\n",
    "\n",
    "Example\n",
    "Read one line of the file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakarya University\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f = open(\"data/sakarya.txt\", \"r\")\n",
    "print(f.readline())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**By calling readline() two times, you can read the two first lines:**\n",
    "\n",
    "Example:\n",
    "\n",
    "Read two lines of the file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakarya University\n",
      "\n",
      "Faculty of Engineering\n",
      "\n"
     ]
    }
   ],
   "source": [
    "f = open(\"data/sakarya.txt\", \"r\")\n",
    "print(f.readline())\n",
    "print(f.readline())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**By looping through the lines of the file, you can read the whole file, line by line:**\n",
    "\n",
    "Example: Loop through the file line by line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakarya University\n",
      "\n",
      "Faculty of Engineering\n",
      "\n",
      "Department of Civil Engineering\n"
     ]
    }
   ],
   "source": [
    "f = open(\"data/sakarya.txt\", \"r\")\n",
    "for line in f:\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Put the date into a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Sakarya University\\n', 'Faculty of Engineering\\n', 'Department of Civil Engineering']\n"
     ]
    }
   ],
   "source": [
    "f = open(\"data/sakarya.txt\", \"r\")\n",
    "data = []\n",
    "for line in f:\n",
    "    data.append(line)\n",
    "\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Python provides also the readlines() method which is used for the reading lines. It returns the list of the lines till the end of file (EOF) is reached.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Sakarya University\\n', 'Faculty of Engineering\\n', 'Department of Civil Engineering']\n"
     ]
    }
   ],
   "source": [
    "f = open(\"data/sakarya.txt\", \"r\")\n",
    "data = f.readlines()\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Close Files\n",
    "\n",
    "You should always close your files, in some cases, due to buffering, changes made to a file may not show until you close the file.\n",
    "\n",
    "Example: Close the file when you are finish with it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Sakarya University\\n', 'Faculty of Engineering\\n', 'Department of Civil Engineering']\n"
     ]
    }
   ],
   "source": [
    "f = open(\"data/sakarya.txt\", \"r\")\n",
    "data = f.readlines()\n",
    "print(data)\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write to an Existing File\n",
    "\n",
    "To write to an existing file, you must add a parameter to the open() function:\n",
    "\n",
    "\"a\" - Append - will append to the end of the file\n",
    "\n",
    "\"w\" - Write - will overwrite any existing content\n",
    "\n",
    "\n",
    "Example: Open the file \"sakarya1.txt\" and append content to the file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakarya University\n",
      "Faculty of Engineering\n",
      "Department of Civil Engineering\n"
     ]
    }
   ],
   "source": [
    "# open and read the existing file:\n",
    "f = open(\"data/sakarya1.txt\", \"r\")\n",
    "print(f.read())\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakarya University\n",
      "Faculty of Engineering\n",
      "Department of Civil EngineeringNow the file has more content!\n"
     ]
    }
   ],
   "source": [
    "# Append to the existing file\n",
    "f = open(\"data/sakarya1.txt\", \"a\")\n",
    "f.write(\"Now the file has more content!\")\n",
    "f.close()\n",
    "\n",
    "# open and read the file after the appending:\n",
    "f = open(\"data/sakarya1.txt\", \"r\")\n",
    "print(f.read())\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakarya University\n",
      "Faculty of Engineering\n",
      "Department of Civil EngineeringNow the file has more content!\n",
      "Now the file has more content!..\n",
      "Now the file has more content!..\n",
      "Now the file has more content!..\n"
     ]
    }
   ],
   "source": [
    "# use \"\\n\" at the end of the line to continue with next line\n",
    "\n",
    "f = open(\"data/sakarya1.txt\", \"a\")\n",
    "f.write(\"\\nNow the file has more content!..\")\n",
    "f.close()\n",
    "\n",
    "#open and read the file after the appending:\n",
    "f = open(\"data/sakarya1.txt\", \"r\")\n",
    "print(f.read())\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note: the \"w\" method will overwrite the entire file.**\n",
    "\n",
    "Example: Open the file \"sakarya2.txt\" and overwrite the content:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakarya University\n",
      "Faculty of Engineering\n",
      "Department of Civil Engineering\n"
     ]
    }
   ],
   "source": [
    "# open and read the existing file:\n",
    "f = open(\"data/sakarya2.txt\", \"r\")\n",
    "print(f.read())\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Woops! I have deleted the content!\n"
     ]
    }
   ],
   "source": [
    "# Overwrite to the existing file\n",
    "f = open(\"data/sakarya2.txt\", \"w\")\n",
    "f.write(\"Woops! I have deleted the content!\")\n",
    "f.close()\n",
    "\n",
    "# open and read the file after the overwriting:\n",
    "f = open(\"data/sakarya2.txt\", \"r\")\n",
    "print(f.read())\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a New File\n",
    "\n",
    "To create a new file in Python, use the open() method, with one of the following parameters:\n",
    "\n",
    "*will create a file and returns an error if the file exist:*\n",
    "- \"x\" - Create\n",
    "\n",
    "*will create a file if the specified file does not exist:*\n",
    "- \"a\" - Append (Appends to an existing file)\n",
    "\n",
    "- \"w\" - Write (Overwrites to an existing file)\n",
    "\n",
    "\n",
    "Example: Create a file called \"myfile.txt\":\n",
    "\n",
    "Result: a new empty file is created!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileExistsError",
     "evalue": "[Errno 17] File exists: 'data/myfile.txt'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileExistsError\u001b[0m                           Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_12484\\2758451962.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# \"x\" - Create - will create a file, returns an error if the file exist\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mf\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"data/myfile.txt\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"x\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mFileExistsError\u001b[0m: [Errno 17] File exists: 'data/myfile.txt'"
     ]
    }
   ],
   "source": [
    "# \"x\" - Create - will create a file, returns an error if the file exist\n",
    "f = open(\"data/myfile.txt\", \"x\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example: Create a new file if it does not exist:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(\"data/myfile.txt\", \"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(\"data/myfile.txt\", \"w\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python OS module\n",
    "\n",
    "### Renaming the file\n",
    "\n",
    "The Python **os** module enables interaction with the operating system. The os module provides the functions that are involved in file processing operations like renaming, deleting, etc. It provides us the rename() method to rename the specified file to a new name. The syntax to use the rename() method is given below.\n",
    "\n",
    "Syntax:\n",
    "\n",
    "*import os*\n",
    "\n",
    "*os.rename(current-name, new-name)*  \n",
    "\n",
    "The first argument is the current file name and the second argument is the modified name. We can change the file name bypassing these two arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.rename(\"data/sakarya2.txt\",\"data/sakarya21.txt\")  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Delete a File\n",
    "\n",
    "The os module provides the remove() method which is used to remove the specified file. \n",
    "\n",
    "The syntax to use the remove() method: *os.remove(file-name)*  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.remove(\"data/sakarya21.txt\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating the new directory (Folder)\n",
    "\n",
    "The mkdir() method is used to create the directories in the current working directory. The syntax to create the new directory is given below.\n",
    "\n",
    "Syntax: mkdir(directory name)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os    \n",
    "    \n",
    "#creating a new directory with the name new    \n",
    "os.mkdir(\"data/myfolder\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The getcwd() method\n",
    "\n",
    "This method returns the current working directory.\n",
    "\n",
    "The syntax to use the getcwd() method is given below.\n",
    "\n",
    "Syntax: *os.getcwd()* "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C:\\\\Users\\\\admin\\\\OneDrive - sakarya.edu.tr\\\\a_Courses_Undergrads\\\\0_Python_Programming\\\\Course_Notebooks'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os  \n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Changing the current working directory\n",
    "\n",
    "The chdir() method is used to change the current working directory to a specified directory.\n",
    "\n",
    "The syntax to use the chdir() method is given below.\n",
    "\n",
    "Syntax: *chdir(\"new-directory\")*    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C:\\\\Users\\\\admin\\\\OneDrive - sakarya.edu.tr\\\\a_Courses_Undergrads\\\\0_Python_Programming\\\\Course_Notebooks\\\\data\\\\myfolder'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os   \n",
    "# Changing current directory with the new directiory  \n",
    "os.chdir(\"C:\\\\Users\\\\admin\\\\OneDrive - sakarya.edu.tr\\\\a_Courses_Undergrads\\\\0_Python_Programming\\\\Course_Notebooks\\\\data\\\\myfolder\")\n",
    "\n",
    "#It will display the current working directory  \n",
    "os.getcwd()  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deleting directory\n",
    "\n",
    "The rmdir() method is used to delete the specified directory.\n",
    "\n",
    "The syntax to use the rmdir() method is given below.\n",
    "\n",
    "Syntax\n",
    "\n",
    "*os.rmdir(directory name)*    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os  \n",
    "# Changing current directory with the new directiory  \n",
    "os.chdir(\"C:\\\\Users\\\\admin\\\\OneDrive - sakarya.edu.tr\\\\a_Courses_Undergrads\\\\0_Python_Programming\\\\Course_Notebooks\")  \n",
    "\n",
    "#It will display the current working directory  \n",
    "os.getcwd()  \n",
    "\n",
    "#removing the new directory     \n",
    "os.rmdir(\"data\\myfolder\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "### The with statement\n",
    "\n",
    "The with statement was introduced in python 2.5. The with statement is useful in the case of manipulating the files. It is used in the scenario where a pair of statements is to be executed with a block of code in between.\n",
    "\n",
    "The syntax to open a file using with the statement is given below.\n",
    "\n",
    "*with open(file name, access mode) as file-pointer:*\n",
    "    \n",
    "    #statement suite \n",
    "    \n",
    "The advantage of using with statement is that it provides the guarantee to close the file regardless of how the nested block exits.\n",
    "\n",
    "It is always suggestible to use the with statement in the case of files because, if the break, return, or exception occurs in the nested block of code then it automatically closes the file, we don't need to write the close() function. It doesn't let the file to corrupt.\n",
    "\n",
    "Consider the following example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakarya University\n",
      "Faculty of Engineering\n",
      "Department of Civil Engineering\n"
     ]
    }
   ],
   "source": [
    "with open(\"data/sakarya.txt\",'r') as f:    \n",
    "    content = f.read()    \n",
    "    print(content)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading a Specific Line from a File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Faculty of Engineering\n",
      " written in line number 2\n"
     ]
    }
   ],
   "source": [
    "line_number = 2  # define a specific line number\n",
    "\n",
    "with open(\"data/sakarya.txt\", 'r') as file:\n",
    "    current_line = 1\n",
    "    for line in file:\n",
    "        if current_line == line_number:\n",
    "            print(line, \"written in line number\", line_number)\n",
    "            break\n",
    "        current_line += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Faculty of Engineering\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# using linecache module and getline() method to select a specific line \n",
    "\n",
    "import linecache\n",
    "\n",
    "line = linecache.getline(\"data/sakarya.txt\", 2) # filename and line number defined\n",
    "print (line)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### .mode and .name "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakarya University\n",
      "Faculty of Engineering\n",
      "Department of Civil Engineering\n"
     ]
    }
   ],
   "source": [
    "f = open(\"data/sakarya.txt\", \"r\")\n",
    "print(f.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'r'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the mode of file as write, read, append etc.\n",
    "f.mode      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'data/sakarya.txt'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# print the file name\n",
    "f.name     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### File Pointer positions\n",
    "\n",
    "Python provides the tell() method which is used to print the byte number at which the file pointer currently exists. Consider the following example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get the current file position\n",
    "f.tell      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The filepointer is at byte : 0\n",
      "After reading, the filepointer is at: 75\n"
     ]
    }
   ],
   "source": [
    "# open the file file2.txt in read mode    \n",
    "file = open(\"data/sakarya.txt\",\"r\")    \n",
    "  \n",
    "#initially the filepointer is at 0     \n",
    "print(\"The filepointer is at byte :\", file.tell())    \n",
    "    \n",
    "#reading the content of the file    \n",
    "content = file.read()    \n",
    "    \n",
    "#after the read operation file pointer modifies. tell() returns the location of the file.     \n",
    "print(\"After reading, the filepointer is at:\", file.tell())  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Modifying file pointer position\n",
    "\n",
    "In real-world applications, sometimes we need to change the file pointer location externally since we may need to read or write the content at various locations.\n",
    "\n",
    "For this purpose, the Python provides us the seek() method which enables us to modify the file pointer position externally.\n",
    "\n",
    "The syntax to use the seek() method is given below.\n",
    "\n",
    "*fileobj.seek(offset)*\n",
    "\n",
    "offset: It refers to the new position of the file pointer within the file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# bring file cursor to initial position\n",
    "file.seek(0) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The filepointer is at byte : 0\n",
      "After reading, the filepointer is at: 10\n"
     ]
    }
   ],
   "source": [
    "# open the file file2.txt in read mode    \n",
    "file = open(\"data/sakarya.txt\",\"r\")    \n",
    "    \n",
    "#initially the filepointer is at 0     \n",
    "print(\"The filepointer is at byte :\", file.tell())    \n",
    "    \n",
    "#changing the file pointer location to 10.    \n",
    "file.seek(10);    \n",
    "    \n",
    "#tell() returns the location of the file.     \n",
    "print(\"After reading, the filepointer is at:\", file.tell())    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open(\"data/sakarya.txt\",\"r+\")\n",
    "file.seek(10)\n",
    "file.write(\"yeni eklenen veri\")\n",
    "file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sakarya Unyeni eklenen veri of Engineering\n",
      "Department of Civil Engineeringyeni eklenen veri\n"
     ]
    }
   ],
   "source": [
    "f = open(\"data/sakarya.txt\", \"r\")\n",
    "print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./Figures/ch10/fileoperations.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### \"Excel with PANDAS \""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "# 1) Veriyi excel'e atmak\n",
    "Mat = np.arange(1,13).reshape(3,4)  # size(3,4)\n",
    "\n",
    "Matdf1 = pd.DataFrame (Mat) ## convert your array into a dataframe\n",
    "print(Mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save to xlsx file\n",
    "Matdf1.to_excel('data/Matdf.xlsx') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To remove row and column names\n",
    "Matdf1.to_excel('data/Matdf.xlsx', index=False, header=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   1   2   3   4\n",
      "0  5   6   7   8\n",
      "1  9  10  11  12\n"
     ]
    }
   ],
   "source": [
    "# 2) Veriyi excel'den okumak\n",
    "Matdf2 = pd.read_excel(\"data/Matdf.xlsx\")\n",
    "print(Matdf2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   0   1   2   3\n",
      "0  1   2   3   4\n",
      "1  5   6   7   8\n",
      "2  9  10  11  12\n"
     ]
    }
   ],
   "source": [
    "Matdf2 = pd.read_excel(\"data/Matdf.xlsx\", header=None)\n",
    "print(Matdf2)"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}