Lesson_08.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Course Information\n",
    "* Introduction to Programming (INFO-233)\n",
    "* Ramapo College of New Jersey\n",
    "* Professor Samuel Jacobs\n",
    "* Notes Licensed Under [CC BY-SA](https://creativecommons.org/licenses/by-sa/4.0/)\n",
    "\n",
    "# Lesson 08 Topics\n",
    "* Object-Oriented Programming\n",
    "* (More) Common Libraries\n",
    "\n",
    "# Object-Oriented Programming\n",
    "## Geometry Example\n",
    "Object-Oriented Programming (OOP) is best described with an example. Suppose we wish to create a geometric model of a rectangle. Recall that a rectangle is fully defined by the edges of its two orthogonal lengths, ```height``` and ```width``` ('a' and 'b', respectively).\n",
    "\n",
    "![](https://upload.wikimedia.org/wikipedia/commons/thumb/7/79/Illustration_for_the_area_of_a_rectangle.svg/1920px-Illustration_for_the_area_of_a_rectangle.svg.png)\n",
    "\n",
    "## Procedural Programming Approach\n",
    "Now, with the knowledge that our model corresponds specifically to a rectangle, no other shape, we should be able to ascertain additional information directly from ```height``` and ```width```; for example, perimeter and area of a rectangle are common attributes that are fully defined from those two values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "height = 5\n",
    "width = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "area = height*width"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "perimeter = 2*(height+width)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The previous code was the procedural programming approach, which requires separate, unassociated variables for ```area``` and ```perimeter```.\n",
    "\n",
    "## Object-Oriented Structure\n",
    "Using an OOP approach, since both attributes are inherent to a rectangle, they should therefore be inherent to a data structure which models a rectangle. We achieve this by building a ```Class``` called ```Rectangle```. A class contains all of the data necessary to fully-describe an object and methods to act on that object. A sample class, ```Rectangle```, has been written below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, height, width):\n",
    "        self.height = height\n",
    "        self.width = width\n",
    "    \n",
    "    def area(self):\n",
    "        return self.height*self.width\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 2*(self.height+self.width)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example class, we initialize an object by providing the necessary arguments to fully define it (height and width), and its attributes (area and perimeter) become immediately available. Before exploring the class in detail, we create an object of ```Rectangle```, or an instance of a class, using the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "rect1 = Rectangle(10, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, ```rect1``` is an entirely new data structure that we have created; it is not limited to the functionality of a string, list, or any other previously defined data structure. We can directly access the geometric attributes of this instance of ```Rectangle``` by calling its methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rect1.area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rect1.perimeter()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Any number of additional instances may be generated throughout a program, and each instance stores its own data and provides access to its unique attribute values separately.\n",
    "\n",
    "![](https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fadultedresource.coabe.org%2Fwp-content%2Fuploads%2F2018%2F01%2FRectangles-300x300.jpg&f=1&nofb=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "rect2 = Rectangle(2, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rect2.area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rect2.perimeter()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instances of ```Rectangle``` may even be combined with other data structures. For example, we can create a list of rectangles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "rectangles = []\n",
    "rectangles.append(Rectangle(10, 5))\n",
    "rectangles.append(Rectangle(2, 2))\n",
    "rectangles.append(Rectangle(3, 5))\n",
    "rectangles.append(Rectangle(10, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50 30\n",
      "4 8\n",
      "15 16\n",
      "100 40\n"
     ]
    }
   ],
   "source": [
    "for instance in rectangles:\n",
    "    print(instance.area(), instance.perimeter())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Referring back to the ```Rectangle``` class creation, similar to how functions are created using the ```def``` keyword, classes are created using the ```class``` keyword. The ```self``` keyword is also scattered throughout the class. Unlike functions which require passing every required piece of data as an argument, class methods can make use of the ```self.*``` notation. For example, since we know each instance of ```Rectangle``` must be defined by a ```height``` and ```width```, those two values can be uniquely embedded in each instance of ```Rectangle``` and accessed by its methods.\n",
    "\n",
    "When computing the method ```area()```,\n",
    "\n",
    "    def area(self):\n",
    "        return self.height*self.width\n",
    "\n",
    "Python accesses whatever the height and width are for the current instance, as defined by its _constructor_. A _constructor_ by defining the ```__init__()``` method. The ```__init__()``` method name is common to all classes with a constructor, and it uses the specific double-underscore ```__``` to ensure a naming conflict does not occur with any other method.\n",
    "\n",
    "Additional information on classes may be found [here](https://www.w3schools.com/python/python_classes.asp).\n",
    "\n",
    "# (More) Common Libraries\n",
    "## File Reading\n",
    "Python can read text files using the ```open()``` function. Values may be read using the ```read()``` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a test.\\nNo really, this is a test.\\nOkay.\\nCool!\\n'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "file = open('sample.txt', 'r')\n",
    "file.read()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CSV Reading\n",
    "The CSV module is useful for reading comma separated values (CSV) from files. CSV files may be thought as structured text files. Their contents may easily be read into one- and two-dimensional data structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "file = open('sample.csv', 'r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yankees, New York City\n",
      "Red Sox, Boston\n",
      "Orioles, Baltimore\n",
      "Rays, Tampa Bay\n",
      "Blue Jays, Toronto\n"
     ]
    }
   ],
   "source": [
    "with open('sample.csv', 'r', newline='\\n') as csvfile:\n",
    "    lines = csv.reader(csvfile, delimiter=',', quotechar='|')\n",
    "    for line in lines:\n",
    "        print(', '.join(line))"
   ]
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}