P-E-files in python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b3c0145c",
   "metadata": {},
   "source": [
    "# Python: Everything\n",
    "- 30) **Handling files** \n",
    "    - Opening files with **open()** for writing some strings\n",
    "    - Reading the content of the file with read, readlines, and readline\n",
    "    - Writing to a file using write and writelines\n",
    "    - Encoding and decoding\n",
    "    - Checking if a file exists\n",
    "    - Creating and writing and then reading a binary file\n",
    "\n",
    "<br>----------------------------------------------\n",
    "<br> https://www.pinterest.com/HamedShahHosseini/programming-languages/\n",
    "<br>https://github.com/ostad-ai/Python-Everything"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aa91cce",
   "metadata": {},
   "source": [
    "**Opening files** is done with function \n",
    " - open(*filepath*,*mode*,*encoding*=None)\n",
    "\n",
    "The filepath is composed of three parts:\n",
    "- **Folder path:** the folder in which the file is located\n",
    "- **File name:** the actual name of file\n",
    "- **Extension:** the end of file path ,which begins with period to indicate the type of file \n",
    "\n",
    "The mode in opening a file specifies two things: \n",
    "- Opening modes for reading writing, appending, or creating: \n",
    "    - mode '**r**' opens a file for reading, and returns error if file does not exist\n",
    "    - mode '**w**' opens a file for writing. It creates the file if it does not exist\n",
    "    - mode '**a**' opens a file for appending. It creates the file if it does not exist\n",
    "    - mode '**x**' creates the file and returns error it the file exists\n",
    "- Opening file as **text** or **binary**:\n",
    "    - mode '**t**' handles the file as *text* mode (the default mode)\n",
    "    - mode '**b**' handles the file as *binary* mode\n",
    "\n",
    "By default, the file is opened in *text mode* meaning that the data is read or written in strings. To do this, an encoding is employed. The recommended encoding is: **encoding='utf-8'**. \n",
    "<br> After opening a file and then working with it, we must **close** the file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "553e933d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# creates a file, and writes some text in it, and then closes it\n",
    "filepath='./p_e_file_text.txt'\n",
    "data=['Hello World\\n','This file was created by Python\\n','See you\\n']\n",
    "# creates a text file for writing\n",
    "file=open(filepath,'w',encoding='utf-8')\n",
    "file.writelines(data) # writes a sequence of strings\n",
    "file.close()  #closes the file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "782488e4",
   "metadata": {},
   "source": [
    "Now, we open the file that we created above, and read its contents.\n",
    "<br>**Hint:** Instead of using **file.close()**, after each open(), we can wrap the open() inside keyword **with**, as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "13a04c88",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "This file was created by Python\n",
      "See you\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open(filepath,'r') as file:\n",
    "    lines=file.read()\n",
    "print(lines)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fcd06b4",
   "metadata": {},
   "source": [
    "We can append to an existing file as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d75192e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "This file was created by Python\n",
      "See you\n",
      "This line is added with append mode\n",
      "\n",
      "------------lines is a string:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Hello World\\nThis file was created by Python\\nSee you\\nThis line is added with append mode\\n'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open(filepath,'a') as file:\n",
    "    file.write('This line is added with append mode\\n')\n",
    "with open(filepath,'r') as file:\n",
    "    lines=file.read() # lines is a long string holding the whole file\n",
    "print(lines)\n",
    "print('------------lines is a string:')\n",
    "lines"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ed88013",
   "metadata": {},
   "source": [
    "Some methods of file objects: read,readline,and readlines\n",
    "- **read** reads the entire file into an string\n",
    "- **readline** reads a line from the file\n",
    "- **readlines** reads the lines from the file and sends them as a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "162048e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello World\\n', 'This file was created by Python\\n', 'See you\\n', 'This line is added with append mode\\n']\n"
     ]
    }
   ],
   "source": [
    "# reading the file in a list of strings\n",
    "with open(filepath,'r') as file:\n",
    "    lines_list=file.readlines()\n",
    "print(lines_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c2bfcf0",
   "metadata": {},
   "source": [
    "Using **readline** instead of readlines is shown in the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "568f3eb5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "This file was created by Python\n",
      "See you\n",
      "This line is added with append mode\n"
     ]
    }
   ],
   "source": [
    "with open(filepath,'r') as file:\n",
    "    while True:\n",
    "        line=file.readline()\n",
    "        if line=='': # end of file is reached\n",
    "            break\n",
    "        print(line,end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71f2fb65",
   "metadata": {},
   "source": [
    "We can read the file content directly form the file object in a for-loop:\n",
    " - This method is simple, **memory efficient** and fast. So it is suitable for large files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "aaeab2a8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "This file was created by Python\n",
      "See you\n",
      "This line is added with append mode\n"
     ]
    }
   ],
   "source": [
    "with open(filepath,'r') as file:\n",
    "    for line in file:\n",
    "        print(line,end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07bfc59d",
   "metadata": {},
   "source": [
    "We became familiar with write command to write a string into the file. Lets review the commands:\n",
    "- **write** writes a string into file\n",
    "- **writelines** writes a sequence of string into file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "4f0a27f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n",
      "This file was created by Python\n",
      "See you\n",
      "This line is added with append mode\n",
      "How is the weather\n",
      "And tell me about the situation\n",
      "Bye\n",
      "\n"
     ]
    }
   ],
   "source": [
    "lines=['How is the weather\\n','And tell me about the situation\\n','Bye\\n']\n",
    "with open(filepath,'a') as file:\n",
    "    file.writelines(lines)\n",
    "with open(filepath,'r') as file:\n",
    "    print(file.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46919829",
   "metadata": {},
   "source": [
    "**Encoding** and **decoding:** We have seen a **character string**, or string, which is a sequence of characters. In contrast, a **byte string** is a sequence of bytes (8-bit unsigned values). \n",
    "<br>A character string cannot be directly stored in a computer. So it has to be encoded first to become a byte string. Thus, the mapping from character string to byte string is called **encoding**. **Decoding** is the inverse mapping of encoding. \n",
    "For example, we get a charatcer string and encode it into byte string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "804dd324",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The character string: Hello World, bye\n",
      "The byte string: b'Hello World, bye'\n",
      "The byte string in hex:48:65:6c:6c:6f:20:57:6f:72:6c:64:2c:20:62:79:65\n",
      "The character string from byte string: Hello World, bye\n"
     ]
    }
   ],
   "source": [
    "cs='Hello World, bye' #character string\n",
    "bs=cs.encode('utf-8') #byte string\n",
    "print(f'The character string: {cs}')\n",
    "print(f'The byte string: {bs}')\n",
    "print(f'The byte string in hex:{bs.hex(\":\")}')\n",
    "print(f'The character string from byte string: {bs.decode(\"utf-8\")}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1648ae5",
   "metadata": {},
   "source": [
    "How about:\n",
    " - Checking if a file exists\n",
    " - Removing a file that exists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1004dd57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File p_e_file_text.txt exists:)\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "folder,filename=os.path.split(filepath)\n",
    "if os.path.exists(filepath):\n",
    "    print(f'File {filename} exists:)')\n",
    "    #os.remove(filepath)  #uncomment to remove the file if exists\n",
    "else:\n",
    "    print(f'File {filename} does not exist:(')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4963a61",
   "metadata": {},
   "source": [
    "Let's create a simple **binary** file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0d09c85d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original numbers: [5, 12, 28, 8]\n",
      "Bytes to write into the file: bytearray(b'\\x05\\x0c\\x1c\\x08')\n",
      "Bytes read from the file: b'\\x05\\x0c\\x1c\\x08'\n",
      "The numbers read from the file: [5, 12, 28, 8]\n"
     ]
    }
   ],
   "source": [
    "filepath_bin='./p_e_file_binary.bin'\n",
    "numbers=[5,12,28,8]\n",
    "barray=bytearray(numbers)\n",
    "with open(filepath_bin,'wb') as file_bin:\n",
    "    file_bin.write(barray)\n",
    "with open(filepath_bin,'rb') as file_bin:\n",
    "    barray_read=file_bin.read()\n",
    "    print(f'The original numbers: {numbers}')\n",
    "print(f'Bytes to write into the file: {barray}')\n",
    "print(f'Bytes read from the file: {barray_read}')\n",
    "print(f'The numbers read from the file: {list(barray_read)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc7afe9c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}