Object Oriented Programming and File IO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object Oriented Programming and File I/O"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Object Oriented Programming (OOP)__ is a programming paradigm that allows abstraction through the concept of interacting entities. This programming works contradictory to conventional model and is procedural, in which programs are organized as a sequence of commands or statements to perform.\n",
    "\n",
    "We can think an object as an entity that resides in memory, has a state and it's able to perform some actions. \n",
    " \n",
    "More formally objects are entities that represent **instances** of a general abstract concept called **class**. In `Python`, \"attributes\" are the variables defining an object state and the possible actions are called \"methods\".\n",
    "\n",
    "In Python, everything is an object also classes and functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 How to define classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Creating a class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we want to create a class, named Person, as a prototype, a sort of template for any number of 'Person' objects (instances)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following python syntax defines a class:\n",
    "\n",
    "    class ClassName(base_classes):\n",
    "        statements\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Class names should always be uppercase (it's a naming convention)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Say we need to model a Person as:\n",
    "\n",
    "* Name\n",
    "* Surname  \n",
    "* Age  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Person object at 0x7fc0fc759400>\n",
      "Alec Baldwin was born in 1958.\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    pass\n",
    "\n",
    "john_doe = Person()\n",
    "john_doe.name = \"Alec\"\n",
    "john_doe.surname = \"Baldwin\"\n",
    "john_doe.year_of_birth = 1958\n",
    "\n",
    "\n",
    "print(john_doe)\n",
    "print(\"%s %s was born in %d.\" %\n",
    "      (john_doe.name, john_doe.surname, john_doe.year_of_birth))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following example defines an empty class (i.e. the class doesn't have a state) called _Person_ then creates a _Person_ instance called _john_doe_ and adds three attributes to _john_doe_. We see that we can access objects attributes using the \"dot\" operator.\n",
    "\n",
    "This isn't a recommended style because classes should describe homogeneous entities. A way to do so is the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, surname, year_of_birth):\n",
    "        self.name1 = name\n",
    "        self.surname = surname\n",
    "        self.year_of_birth = year_of_birth"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    __init__(self, ...)\n",
    "Is a special _Python_ method that is automatically called after an object construction. Its purpose is to initialize every object state. The first argument (by convention) __self__ is automatically passed either and refers to the object itself.\n",
    "\n",
    "In the preceding example, `__init__` adds three attributes to every object that is instantiated. So the class is actually describing each object's state.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We cannot directly manipulate any class rather we need to create an instance of the class: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Person object at 0x109dab128>\n",
      "Alechgffh Baldwin was born in 1958.\n"
     ]
    }
   ],
   "source": [
    "alec = Person(\"Alechgffh\", \"Baldwin\", 1958)\n",
    "print(alec)\n",
    "print(\"%s %s was born in %d.\" % (alec.name1, alec.surname, alec.year_of_birth))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "We have just created an instance of the Person class, bound to the variable `alec`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alec Baldwin was born in 1958 .\n",
      "56\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(a, name, surname, year_of_birth):\n",
    "        a.name = name\n",
    "        a.surname = surname\n",
    "        a.year_of_birth = year_of_birth\n",
    "    \n",
    "    def age(a, current_year):\n",
    "        return current_year - a.year_of_birth\n",
    "    \n",
    "    def __str__(a):\n",
    "        return \"%s %s was born in %d .\" % (a.name, a.surname, a.year_of_birth)\n",
    "    \n",
    "alec = Person(\"Alec\", \"Baldwin\", 1958)\n",
    "print(alec)\n",
    "print(alec.age(2014))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We defined two more methods `age` and  `__str__`. The latter is once again a special method that is called by Python when the object has to be represented as a string (e.g. when has to be printed). If the `__str__` method isn't defined the **print** command shows the type of object and its address in memory. We can see that in order to call a method we use the same syntax for attributes (**instance_name.instance _method**)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 Bad practice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to create a class without the `__init__` method, but this is not a recommended style because classes should describe homogeneous entities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "  \n",
    "    def set_name(self, name):\n",
    "        self.name = name\n",
    "        \n",
    "    def set_surname(self, surname):\n",
    "        self.surname = surname\n",
    "        \n",
    "    def set_year_of_birth(self, year_of_birth):\n",
    "        self.year_of_birth = year_of_birth\n",
    "        \n",
    "    def age(self, current_year):\n",
    "        return current_year - self.year_of_birth\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"%s %s was born in %d .\" \\\n",
    "                % (self.name, self.surname, self.year_of_birth)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, an empty instance of the class Person is created, and no attributes have been initialized while instantiating:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "president = Person()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Person' object has no attribute 'name'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-004adac081fd>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# This code will raise an attribute error:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpresident\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Person' object has no attribute 'name'"
     ]
    }
   ],
   "source": [
    "# This code will raise an attribute error:\n",
    "print(president.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This raises an Attribute Error... We need to set the attributes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "president.set_name('John')\n",
    "president.set_surname('Doe')\n",
    "president.set_year_of_birth(1940)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mr John Doe is the president, and he is very old. He is 74\n"
     ]
    }
   ],
   "source": [
    "print('Mr', president.name, president.surname,\n",
    "      'is the president, and he is very old. He is',\n",
    "      president.age(2014))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4 Protect your abstraction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here the instance attributes shouldn't be accessible by the end user of an object as they are powerful mean of abstraction they should not reveal the internal implementation detail. In Python, there is no specific strict mechanism to protect object attributes but the official guidelines suggest that a variable that has an underscore prefix should be treated as 'Private'.\n",
    "\n",
    "Moreover prepending two underscores to a variable name makes the interpreter mangle a little the variable name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alec Baldwin and was born 1958.\n",
      "Baldwin\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, surname, year_of_birth):\n",
    "        self._name = name\n",
    "        self._surname = surname\n",
    "        self._year_of_birth = year_of_birth\n",
    "    \n",
    "    def age(self, current_year):\n",
    "        return current_year - self._year_of_birth\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"%s %s and was born %d.\" \\\n",
    "                % (self._name, self._surname, self._year_of_birth)\n",
    "    \n",
    "alec = Person(\"Alec\", \"Baldwin\", 1958)\n",
    "print(alec)\n",
    "print(alec._surname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alec\n"
     ]
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(a, name, surname, year_of_birth):\n",
    "        a.__name = name\n",
    "        self.__surname = surname\n",
    "        self.__year_of_birth = year_of_birth\n",
    "    \n",
    "    def age(self, current_year):\n",
    "        return current_year - self.__year_of_birth\n",
    "    \n",
    "    def __str__(self):\n",
    "        return \"%s %s and was born %d.\" \\\n",
    "                % (self.__name, self.__surname, self.__year_of_birth)\n",
    "    \n",
    "alec = Person(\"Alec\", \"Baldwin\", 1958)\n",
    "print(alec._Person__name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`__dict__` is a special attribute is a dictionary containing each attribute of an object. We can see that prepending two underscores every key has `_ClassName__` prepended."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once a class is defined it models a concept. It is useful to extend a class behavior to model a less general concept. Say we need to model a Student, but we know that every student is also a Person so we shouldn't model the Person again but inherit from it instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Charlie Brown was born in 2006 .\n",
      "<class '__main__.Student'>\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "class Student(Person):\n",
    "    def __init__(self, student_id, *args):\n",
    "        super(Student, self).__init__(*args)\n",
    "        self._student_id = student_id\n",
    "        \n",
    "charlie = Student(1, 'Charlie', 'Brown', 2006)\n",
    "print(charlie._student_id)\n",
    "print(type(charlie))\n",
    "print(isinstance(charlie, Person))\n",
    "print(isinstance(charlie, object))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Charlie now has the same behavior of a Person, but his state has also a student ID. A Person is one of the base classes of Student and Student is one of the sub classes of Person. Be aware that a subclass knows about its superclasses but the converse isn't true.\n",
    "\n",
    "A sub class doesn't only inherits from its base classes, but from its base classes too, forming an inheritance tree that starts from a object (every class base class).\n",
    "\n",
    "    super(Class, instance)\n",
    "    \n",
    "is a function that returns a proxy-object that delegates method calls to a parent or sibling class of type.\n",
    "So we used it to access Person's `__init__`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Overriding methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Inheritance allows to add new methods to a subclass but often is useful to change the behavior of a method defined in the superclass. To override a method just define it again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Charlie Brown was born in 2006 . And has ID: 1\n"
     ]
    }
   ],
   "source": [
    "class Student(Person):\n",
    "    def __init__(self, student_id, *args, **kwargs):\n",
    "        super(Student, self).__init__(*args, **kwargs)\n",
    "        self._student_id = student_id\n",
    "        \n",
    "    def __str__(self):\n",
    "        return super(Student, self).__str__() + \" And has ID: %d\" % self._student_id\n",
    "        \n",
    "charlie = Student(1, 'Charlie', 'Brown', 2006)\n",
    "print(charlie)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We defined `__str__` again overriding the one wrote in Person, but we wanted to extend it, so we used super to achieve our goal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Encapsulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Encapsulation is an another powerful way to extend a class which consists on wrapping an object with a second one.\n",
    "There are two main reasons to use encapsulation:\n",
    "* Composition\n",
    "* Dynamic Extension\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Composition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The abstraction process relies on creating a simplified model that remove useless details from a concept. In order to be simplified, a model should be described in terms of other simpler concepts.\n",
    "For example, we can say that a car is composed by:\n",
    "* Tyres\n",
    "* Engine\n",
    "* Body\n",
    "\n",
    "And break down each one of these elements in simpler parts until we reach primitive data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tyres: \n",
      " \tBranch: Pirelli\n",
      " \tBelted-bias: True\n",
      " \tOptimal pressure: 2.0\n",
      "Engine: \n",
      " \tFuel type: Diesel\n",
      " \tNoise level:3\n",
      "Body:\n",
      " \tSize: Medium\n"
     ]
    }
   ],
   "source": [
    "class Tyres:\n",
    "    def __init__(self, branch, belted_bias, opt_pressure):\n",
    "        self.branch = branch\n",
    "        self.belted_bias = belted_bias\n",
    "        self.opt_pressure = opt_pressure\n",
    "        \n",
    "    def __str__(self):\n",
    "        return (\"Tyres: \\n \\tBranch: \" + self.branch +\n",
    "               \"\\n \\tBelted-bias: \" + str(self.belted_bias) + \n",
    "               \"\\n \\tOptimal pressure: \" + str(self.opt_pressure))\n",
    "        \n",
    "class Engine:\n",
    "    def __init__(self, fuel_type, noise_level):\n",
    "        self.fuel_type = fuel_type\n",
    "        self.noise_level = noise_level\n",
    "        \n",
    "    def __str__(self):\n",
    "        return (\"Engine: \\n \\tFuel type: \" + self.fuel_type +\n",
    "                \"\\n \\tNoise level:\" + str(self.noise_level))\n",
    "        \n",
    "class Body:\n",
    "    def __init__(self, size):\n",
    "        self.size = size\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"Body:\\n \\tSize: \" + self.size\n",
    "        \n",
    "class Car:\n",
    "    def __init__(self, tyres, engine, body):\n",
    "        self.tyres = tyres\n",
    "        self.engine = engine\n",
    "        self.body = body\n",
    "        \n",
    "    def __str__(self):\n",
    "        return str(self.tyres) + \"\\n\" + str(self.engine) + \"\\n\" + str(self.body)\n",
    "\n",
    "        \n",
    "t = Tyres('Pirelli', True, 2.0)\n",
    "e = Engine('Diesel', 3)\n",
    "b = Body('Medium')\n",
    "c = Car(t, e, b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Dynamic Extension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes it's necessary to model a concept that may be a subclass of another one, but it isn't possible to know which class should be its superclass until runtime."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3.2.1 Example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we want to model a simple dog school that trains instructors too. It will be nice to re-use Person and Student but students can be dogs or peoples. So we can remodel it this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kudrjavka is a Laika born in 1954.\n"
     ]
    }
   ],
   "source": [
    "class Dog:\n",
    "    def __init__(self, name, year_of_birth, breed):\n",
    "        self._name = name\n",
    "        self._year_of_birth = year_of_birth\n",
    "        self._breed = breed\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"%s is a %s born in %d.\" % (self._name, self._breed, self._year_of_birth)\n",
    "\n",
    "kudrjavka = Dog(\"Kudrjavka\", 1954, \"Laika\")\n",
    "print(kudrjavka)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dsfs Student ID: 1\n",
      "Kudrjavka is a Laika born in 1954. Student ID: 2\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, anagraphic, student_id):\n",
    "        self._anagraphic = anagraphic\n",
    "        self._student_id = student_id\n",
    "    def __str__(self):\n",
    "        return str(self._anagraphic) + \" Student ID: %d\" % self._student_id\n",
    "\n",
    "\n",
    "alec_student = Student(\"dsfs\",1)\n",
    "kudrjavka_student = Student(kudrjavka, 2)\n",
    "\n",
    "print(alec_student)\n",
    "print(kudrjavka_student)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Polymorphism and DuckTyping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Python` uses dynamic typing which is also called as duck typing. If an object implements a method you can use it, irrespective of the type. This is different from statically typed languages, where the type of a construct need to be explicitly declared. Polymorphism is the ability to use the same syntax for objects of different types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "['a', 'b', 'c', 'd', 'e']\n",
      "abracadabra\n"
     ]
    }
   ],
   "source": [
    "def summer(a, b):\n",
    "    return a + b\n",
    "\n",
    "print(summer(1, 1))\n",
    "print(summer([\"a\", \"b\", \"c\"], [\"d\", \"e\"]))\n",
    "print(summer(\"abra\", \"cadabra\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 How long does a class should be?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is an Object Oriented Programming (OOP) principle called Single Responsibility Principle (SRP) and it states: \"A class should have one single responsibility\" or \"A class should have only one reason to change\". \n",
    "\n",
    "If you come across a class which doesn't follow the SRP principle, you should spilt it. You will be grateful to SRP during your software maintenance. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Files\n",
    "\n",
    "Python uses file objects to interact with the external files on your computer. These file objects cab be of any file format on your computer i.e. can be an audio file, a text file, emails, Excel documents, etc. Note that You will probably need to install certain libraries or modules to interact with those various file types, but they are easily available. (We will cover downloading modules later on in the course).\n",
    "\n",
    "Python has a built-in open function that allows us to open and play with basic file types. First we will need a file though. We're going to use some iPython magic to create a text file!\n",
    "\n",
    "## iPython Writing a File"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting test.txt\n"
     ]
    }
   ],
   "source": [
    "%%writefile test.txt\n",
    "Hello, this is a quick test file hjgtyudfyffhgghghhfch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/sudhanshukumar/Downloads/acad material/ACD_MDS_Offline_V2_Session_2_Code (5)'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pwd()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Opening a file\n",
    "\n",
    "We can open a file with the open() function. This function also takes in arguments (also called parameters). Let's see how this is used:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open the text.txt we made earlier\n",
    "my_file = open('test.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, this is a quick test file hjgtyudfyffhgghghhfch\\n'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can now read the file\n",
    "my_file.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# But what happens if we try to read it again?\n",
    "my_file.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This happens because you can imagine the reading \"cursor\" is at the end of the file after having read it. So there is nothing left to read. We can reset the \"cursor\" like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Seek to the start of file (index 0)\n",
    "my_file.seek(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ck test file hjgtyudfyffhgghghhfch\\n'"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now read again\n",
    "my_file.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to not have to reset every time, we can also use the readlines method. Use caution with large files, since everything will be held in memory. We will learn how to iterate over large files later in the course."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Seek to the start of file (index 0)\n",
    "my_file.seek(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hello, this is a quick test file']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Readlines returns a list of the lines in the file.\n",
    "my_file.readlines()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Writing to a File\n",
    "\n",
    "By default, using the open() function will only allow us to read the file, we need to pass the argument 'w' to write over the file. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add the second argument to the function, 'w' which stands for write\n",
    "my_file = open('test.txt','w+')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Write to the file\n",
    "my_file.write('This is a new line')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Seek to the start of file (index 0)\n",
    "my_file.seek(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a new line'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Read the file\n",
    "my_file.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterating through a File\n",
    "\n",
    "Let's get a quick preview of a for loop by iterating over a text file. First, let's make a new text file with some iPython Magic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting test.txt\n"
     ]
    }
   ],
   "source": [
    "%%writefile test.txt\n",
    "First Line\n",
    "Second Line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'First Line\\nSecond Line\\n'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_file = open('test.txt')\n",
    "my_file.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can use a little bit of flow to tell the program to for through every line of the file and do something:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Line\n",
      "\n",
      "Second Line\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for line in open('test.txt'):\n",
    "    print(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First Line\n",
      "\n",
      "Second Line\n"
     ]
    }
   ],
   "source": [
    "# Pertaining to the first point above\n",
    "for asdf in open('test.txt'):\n",
    "    print(asdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# StringIO \n",
    "\n",
    "The StringIO module implements an in-memory filelike object. This object can then be used as input or output to most functions that would expect a standard file object.\n",
    "\n",
    "The best way to show this is by example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "from io import StringIO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Arbitrary String\n",
    "message = 'This is just a normal string.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use StringIO method to set as file object\n",
    "f = StringIO(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we have an object *f* that we will be able to treat just like a file. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is just a normal string.'"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also write to it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.write(' Second line written to file like object')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reset cursor just like you would a file\n",
    "f.seek(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'is just a normal string. Second line written to file like object'"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Read again\n",
    "f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}