Day_4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 4\n",
    "\n",
    "## Practicing python from Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Dictionaries and Sets, Accessing Elements, Dictionary and Set Methods:\n",
    "\n",
    "1.  Create a dictionary representing a person with keys for \"name\", \"age\", and \"gender\". Print the person's age.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "age of person is ::  23\n"
     ]
    }
   ],
   "source": [
    "person = {'name':'nsk', 'age':23, 'gender':'M'}\n",
    "\n",
    "print(\"age of person is :: \",person['age'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.  Create a dictionary of student names and their corresponding grades. Print all the keys (student names) in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Names of all student :: \n",
      "nsk\n",
      "psk\n",
      "sad\n",
      "jay\n"
     ]
    }
   ],
   "source": [
    "student_grade = {'nsk':'A','psk':'A+','sad':'C','jay':'B'}\n",
    "\n",
    "print(\"Names of all student :: \")\n",
    "for name in student_grade:\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3.  Create a set containing the names of countries. Print the set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'India', 'Korea', 'China', 'Japan'}\n",
      "<class 'set'>\n",
      "\n",
      "{'India', 'Korea', 'China', 'Japan'}\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "countries = {'India','Japan','China','Korea'} # 1st method\n",
    "countries1 = set({'India','Japan','China','Korea'}) # 2nd method\n",
    "\n",
    "print(countries)\n",
    "print(type(countries))\n",
    "\n",
    "print() # For adding extra line\n",
    "\n",
    "print(countries1)\n",
    "print(type(countries1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4.  Add a new key-value pair to an existing dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dictionary before adding pair :: \n",
      "\n",
      " {'nsk': 'A', 'psk': 'A+', 'sad': 'C', 'jay': 'B'}\n",
      "Dictionary after adding pair :: \n",
      "\n",
      " {'nsk': 'A', 'psk': 'A+', 'sad': 'C', 'jay': 'B', 'jk': 'B'}\n"
     ]
    }
   ],
   "source": [
    "print(\"Dictionary before adding pair :: \\n\\n\",student_grade)\n",
    "\n",
    "# adding pair \n",
    "student_grade['jk'] = 'B'\n",
    "\n",
    "print(\"Dictionary after adding pair :: \\n\\n\",student_grade)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5.  Use the `keys()` method to print all the keys in a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All keys in dictionary person are :: \n",
      "\n",
      " dict_keys(['name', 'age', 'gender'])\n",
      "\n",
      "\n",
      "one by one keys :: \n",
      "\n",
      "name\n",
      "age\n",
      "gender\n"
     ]
    }
   ],
   "source": [
    "print(\"All keys in dictionary person are :: \\n\\n\",person.keys())\n",
    "\n",
    "\n",
    "print(\"\\n\\none by one keys :: \\n\")\n",
    "for key in person.keys():\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6.  Use the `values()` method to print all the values in a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All values from dictionary student_grade are :: \n",
      "\n",
      " dict_values(['A', 'A+', 'C', 'B', 'B'])\n"
     ]
    }
   ],
   "source": [
    "print(\"All values from dictionary student_grade are :: \\n\\n\",student_grade.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7.  Use the `update()` method to add elements from one dictionary to another."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "student_grade before update() :: \n",
      "\n",
      " {'nsk': 'A', 'psk': 'A+', 'sad': 'C', 'jay': 'B', 'jk': 'B'}\n",
      "\n",
      "student_grade after update() :: \n",
      "\n",
      "{'nsk': 'A', 'psk': 'A+', 'sad': 'C', 'jay': 'B', 'jk': 'B', 'dk': 'A', 'rk': 'B+'}\n"
     ]
    }
   ],
   "source": [
    "new_grades = {'dk':'A','rk':'B+'}\n",
    "\n",
    "# updating student_grade for new grades \n",
    "print(\"student_grade before update() :: \\n\\n\",student_grade)\n",
    "\n",
    "print(\"\\nstudent_grade after update() :: \\n\")\n",
    "\n",
    "student_grade.update(new_grades)\n",
    "print(student_grade)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.  Use the `discard()` method to remove an element from a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set before discard() :: \n",
      "\n",
      " {'India', 'Korea', 'China', 'Japan'}\n",
      "\n",
      "Set after discard() :: \n",
      "\n",
      " {'India', 'Korea', 'Japan'}\n"
     ]
    }
   ],
   "source": [
    "print(\"Set before discard() :: \\n\\n\",countries)\n",
    "\n",
    "countries.discard('China')\n",
    "\n",
    "print(\"\\nSet after discard() :: \\n\\n\",countries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9.  Use the `pop()` method to remove and return an element from a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dictionary ::  {'nsk': 'A', 'psk': 'A+', 'sad': 'C', 'jay': 'B', 'jk': 'B', 'dk': 'A', 'rk': 'B+'}\n",
      "Pop() used to remove one student ::  B\n",
      "Dictionary after pop() ::  {'nsk': 'A', 'psk': 'A+', 'sad': 'C', 'jay': 'B', 'dk': 'A', 'rk': 'B+'}\n"
     ]
    }
   ],
   "source": [
    "print(\"Dictionary :: \",student_grade)\n",
    "\n",
    "one_student = student_grade.pop('jk')\n",
    "\n",
    "print(\"Pop() used to remove one student :: \",one_student)\n",
    "\n",
    "print('Dictionary after pop() :: ',student_grade)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10.  Use set operations like union, intersection, and difference to manipulate sets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Union**\n",
    "\n",
    "     *The union() method returns a set that includes all items from both the original set and the supplied set(s).*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "union by method 1st ::  {'tablet', 'pc', 'smartphone', 'smartwatch', 'laptop'}\n",
      "union by method 2nd ::  {'tablet', 'pc', 'smartphone', 'smartwatch', 'laptop'}\n"
     ]
    }
   ],
   "source": [
    "### Union of two sets\n",
    "\n",
    "set1 = {'laptop','pc','tablet'}\n",
    "set2 = {'smartphone','tablet','smartwatch'}\n",
    "\n",
    "# method one\n",
    "uni1 = set1.union(set2)\n",
    "print('union by method 1st :: ',uni1)\n",
    "\n",
    "# method second\n",
    "uni2 = set1 | set2\n",
    "print('union by method 2nd :: ',uni2)\n",
    "\n",
    "\n",
    "### Set is a collection of unique elements so it will remove duplicate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "union by method 1st ::  {'earphone', 'tablet', 'pc', 'smartphone', 'smartwatch', 'charger', 'laptop', 'buds'}\n",
      "union by method 2nd ::  {'earphone', 'tablet', 'pc', 'smartphone', 'smartwatch', 'charger', 'laptop', 'buds'}\n"
     ]
    }
   ],
   "source": [
    "### union of three or multiple set method\n",
    "set1 = {'laptop','pc','tablet'}\n",
    "set2 = {'smartphone','tablet','smartwatch'}\n",
    "set3 = {'charger','earphone','buds'}\n",
    "\n",
    "# method one\n",
    "uni3_1 = set1.union(set2, set3)\n",
    "print(\"union by method 1st :: \",uni3_1)\n",
    "\n",
    "# method 2nd \n",
    "uni3_2 = set1 | set2 | set3\n",
    "print(\"union by method 2nd :: \",uni3_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Intersection**\n",
    "\n",
    "        The intersection() method returns a set containing the similarities of two or more sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intersection by method 1 ::  {'tablet'}\n",
      "Intersection by method 2nd ::  {'tablet'}\n"
     ]
    }
   ],
   "source": [
    "### Intersection of 2 sets\n",
    "\n",
    "set1 = {'laptop','pc','tablet'}\n",
    "set2 = {'smartphone','tablet','smartwatch'}\n",
    "\n",
    "# method 1\n",
    "intr1 = set1.intersection(set2)\n",
    "print(\"Intersection by method 1 :: \",intr1)\n",
    "\n",
    "# method 2\n",
    "intr2 = set1 & set2\n",
    "print(\"Intersection by method 2nd :: \",intr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intersection by method 1st ::  {'tablet'}\n",
      "Intersection by method 2nd ::  {'tablet'}\n"
     ]
    }
   ],
   "source": [
    "### intersection of 3 or multiple sets\n",
    "set1 = {'laptop','pc','tablet'}\n",
    "set2 = {'smartphone','tablet','smartwatch'}\n",
    "set3 = {'charger','earphone','buds','pc','tablet'}\n",
    "\n",
    "\n",
    "# method 1\n",
    "intr3_1 = set1.intersection(set2, set3)\n",
    "print(\"Intersection by method 1st :: \",intr3_1)\n",
    "\n",
    "# method 2\n",
    "intr3_2 = set1 & set2 & set3\n",
    "print(\"Intersection by method 2nd :: \",intr3_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Difference**\n",
    "\n",
    "        The difference() method returns a set containing the difference of two sets.\n",
    "        Meaning: The returned set includes items that appear only in the first set and not in both."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference by method 1 ::  {'pc', 'laptop'}\n",
      "Difference by method 2 ::  {'pc', 'laptop'}\n"
     ]
    }
   ],
   "source": [
    "### Difference in two sets\n",
    "\n",
    "set1 = {'laptop','pc','tablet'}\n",
    "set2 = {'smartphone','tablet','smartwatch'}\n",
    "\n",
    "# method 1\n",
    "diff1 = set1.difference(set2)\n",
    "print(\"Difference by method 1 :: \",diff1)\n",
    "\n",
    "# method 2\n",
    "diff2 = set1 - set2\n",
    "print(\"Difference by method 2 :: \",diff2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Difference by method 1 ::  {'laptop'}\n",
      "Difference by method 2nd ::  {'laptop'}\n"
     ]
    }
   ],
   "source": [
    "### Difference in two or multiple sets\n",
    "\n",
    "set1 = {'laptop','pc','tablet'}\n",
    "set2 = {'smartphone','tablet','smartwatch'}\n",
    "set3 = {'charger','earphone','buds','pc','tablet'}\n",
    "\n",
    "# method 1\n",
    "diff3_1 = set1.difference(set2, set3)\n",
    "print(\"Difference by method 1 :: \",diff3_1)\n",
    "\n",
    "# method 2\n",
    "diff3_2 = set1 - set2 - set3\n",
    "print(\"Difference by method 2nd :: \", diff3_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opening and Closing Files, Reading from and Writing to Files, Working with Different File Modes:\n",
    "\n",
    "1.  Open a text file in read mode, read its contents, and print them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Project Gutenberg eBook of Apology\n",
      "    \n",
      "This ebook is for the use of anyone anywhere in the United States and\n",
      "most other parts of the world at no cost and with almost no restrictions\n",
      "whatsoever. You may copy it, give it away or re-use it under the terms\n",
      "of the Project Gutenberg License included with this ebook or online\n",
      "at www.gutenberg.org. If you are not located in the United States,\n",
      "you will have to check the laws of the country where you are located\n",
      "before using this eBook.\n",
      "\n",
      "Title: Apology\n",
      "\n",
      "Author: Plato\n",
      "\n",
      "Translator: Benjamin Jowett\n",
      "\n",
      "Release date: February 1, 1999 [eBook #1656]\n",
      "      \n"
     ]
    }
   ],
   "source": [
    "f = open(file=\"data/book_apology_by_plato.txt\",mode='r') # opening file in read mode\n",
    "\n",
    "content = f.read() # reading the file content\n",
    "\n",
    "print(content[:600]) # printing the file content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.  Open a text file in write mode and write some text to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Content in file ::  This is the demo line to check writing in file.\n"
     ]
    }
   ],
   "source": [
    "file1 = open('data/write_file.txt','w') # opening/creating txt file with write mode\n",
    "\n",
    "file1.write(\"This is the demo line to check writing in file.\") # writing the sentence in file\n",
    "file1.close() # closing the file\n",
    "\n",
    "\n",
    "# reading the line we wrote in file\n",
    "file1 = open('data/write_file.txt','r') \n",
    "print(\"Content in file :: \",file1.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3.  Open a text file in append mode and add more text to it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Content after append ::\n",
      " This is the demo line to check writing in file.\n",
      "This is the line added in append mode\n"
     ]
    }
   ],
   "source": [
    "file2 = open(\"data/write_file.txt\",'a+') # opening file in apend mode\n",
    "\n",
    "file2.write(\"\\nThis is the line added in append mode\")\n",
    "\n",
    "file2.close()\n",
    "\n",
    "## reading the file after append\n",
    "file2 = open(\"data/write_file.txt\",\"r\")\n",
    "print(\"Content after append ::\\n\",file2.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4.  Use the `with` statement to automatically close a file after reading its contents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Project Gutenberg eBook of Apology\n",
      "    \n",
      "This ebook is for the use of anyone anywhere in the United States and\n",
      "most other parts of the world at no cost and with almost no restrictions\n",
      "whatsoever. You may copy it, give it away or re-use it under the terms\n",
      "of the Project Gutenberg License included with this ebook or online\n",
      "at www.gutenberg.org. If you are not located in the United States,\n",
      "you will have to check the laws of the country where you are located\n",
      "before using this eBook.\n",
      "\n",
      "Title: Apology\n",
      "\n",
      "Author: Plato\n",
      "\n",
      "Translator: Benjamin Jowett\n",
      "\n",
      "Release date: February 1, 1999 [eBook #1656]\n",
      "      \n"
     ]
    }
   ],
   "source": [
    "with open(\"data/book_apology_by_plato.txt\",encoding='utf8') as file :\n",
    "    print(file.read(600))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5.  Read a CSV file using the `csv` module and print its contents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of rows ::  101\n",
      "Index Customer Id First Name Last Name Company City Country Phone 1 Phone 2 Email Subscription Date Website\n",
      "1 DD37Cf93aecA6Dc Sheryl Baxter Rasmussen Group East Leonard Chile 229.077.5154 397.884.0519x718 zunigavanessa@smith.info 2020-08-24 http://www.stephenson.com/\n",
      "2 1Ef7b82A4CAAD10 Preston Lozano Vega-Gentry East Jimmychester Djibouti 5153435776 686-620-1820x944 vmata@colon.com 2021-04-23 http://www.hobbs.com/\n",
      "3 6F94879bDAfE5a6 Roy Berry Murillo-Perry Isabelborough Antigua and Barbuda +1-539-402-0259 (496)978-3969x58947 beckycarr@hogan.com 2020-03-25 http://www.lawrence.com/\n",
      "4 5Cef8BFA16c5e3c Linda Olsen Dominguez, Mcmillan and Donovan Bensonview Dominican Republic 001-808-617-6467x12895 +1-813-324-8756 stanleyblackwell@benson.org 2020-06-02 http://www.good-lyons.com/\n",
      "5 053d585Ab6b3159 Joanna Bender Martin, Lang and Andrade West Priscilla Slovakia (Slovak Republic) 001-234-203-0635x76146 001-199-446-3860x3486 colinalvarado@miles.net 2021-04-17 https://goodwin-ingram.com/\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    "\n",
    "filename = \"data/customers-100.csv\"\n",
    "fields = []\n",
    "rows = []\n",
    "\n",
    "# reading csv file\n",
    "with open(filename,'r') as csvfile:\n",
    "    # creating object for csv\n",
    "    csvread = csv.reader(csvfile)\n",
    "\n",
    "    # reading fields\n",
    "    fields = next(csvread)\n",
    "    \n",
    "    for row in csvread:\n",
    "        rows.append(row)\n",
    "\n",
    "    print(\"Total number of rows :: \",csvread.line_num)\n",
    "    \n",
    "print(\" \".join(fields))\n",
    "for row in rows[:5]:\n",
    "    print(\" \".join(row))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6.  Write data to a CSV file using the `csv` module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importing csv module\n",
    "import csv \n",
    "\n",
    "fields = ['name','age','gender']\n",
    "\n",
    "rows = [['nk',23,'m'],\n",
    "        ['rk',23,'f'],\n",
    "        ['jk',24,'m'],\n",
    "        ['dk',21,'m']]\n",
    "\n",
    "# creating file\n",
    "with open(\"data/persons.csv\",'w') as csv1:\n",
    "    # creating csv writer object\n",
    "    csvwriter = csv.writer(csv1)\n",
    "    \n",
    "    # writing fields \n",
    "    csvwriter.writerow(fields)\n",
    "    \n",
    "    #writing rows\n",
    "    csvwriter.writerows(rows)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7.  Open a binary file in write mode, write some binary data to it, and then read the data back."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'PK\\x03\\x04\\x14\\x00\\x00\\x00\\x08\\x00U\\xbd'\n"
     ]
    }
   ],
   "source": [
    "with open('data/diy.bin','wb') as df:\n",
    "    b_data = b'PK\\x03\\x04\\x14\\x00\\x00\\x00\\x08\\x00U\\xbd'\n",
    "    df.write(b_data)\n",
    "    \n",
    "\n",
    "df = open('data/diy.bin','rb')\n",
    "dt = df.read()\n",
    "print(dt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8.  Open a file in read mode and use the `readline()` method to read lines one by one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First 5 lines from file:: \n",
      "\n",
      "\n",
      "﻿The Project Gutenberg eBook of Apology\n",
      "\n",
      "    \n",
      "\n",
      "This ebook is for the use of anyone anywhere in the United States and\n",
      "\n",
      "most other parts of the world at no cost and with almost no restrictions\n",
      "\n",
      "whatsoever. You may copy it, give it away or re-use it under the terms\n",
      "\n"
     ]
    }
   ],
   "source": [
    "with open(file=\"data/book_apology_by_plato.txt\",mode='r',encoding='utf-8') as bkf:\n",
    "    print(\"First 5 lines from file:: \\n\\n\")\n",
    "    for i in range(5):\n",
    "        print(bkf.readline())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "9.  Open a file in read mode and use the `readlines()` method to read all lines at once and store them in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Project Gutenberg eBook of Apology\n",
      "\n",
      "    \n",
      "\n",
      "This ebook is for the use of anyone anywhere in the United States and\n",
      "\n",
      "most other parts of the world at no cost and with almost no restrictions\n",
      "\n",
      "whatsoever. You may copy it, give it away or re-use it under the terms\n",
      "\n",
      "of the Project Gutenberg License included with this ebook or online\n",
      "\n",
      "at www.gutenberg.org. If you are not located in the United States,\n",
      "\n",
      "you will have to check the laws of the country where you are located\n",
      "\n",
      "before using this eBook.\n",
      "\n",
      "\n",
      "\n",
      "Title: Apology\n",
      "\n"
     ]
    }
   ],
   "source": [
    "new_f = open(file=\"data/book_apology_by_plato.txt\",mode='r',encoding='utf-8')\n",
    "\n",
    "for line in new_f.readlines(500):\n",
    "    print(line)\n",
    "    \n",
    "new_f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "10.  Open a file in read mode, use a loop to iterate over its lines, and process each line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Project Gutenberg eBook of Apology\n",
      "\n",
      "This ebook is for the use of anyone anywhere in the United States and\n",
      "most other parts of the world at no cost and with almost no restrictions\n",
      "whatsoever. You may copy it, give it away or re-use it under the terms\n",
      "of the Project Gutenberg License included with this ebook or online\n",
      "at www.gutenberg.org. If you are not located in the United States,\n",
      "you will have to check the laws of the country where you are located\n",
      "before using this eBook.\n",
      "\n",
      "Title: Apology\n"
     ]
    }
   ],
   "source": [
    "file = open(file=\"data/book_apology_by_plato.txt\",mode='r',encoding='utf-8')\n",
    "\n",
    "for line in file.readlines(500):\n",
    "    p_line = line.strip() # using strip as process method for line\n",
    "    print(p_line)"
   ]
  }
 ],
 "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}