oop_intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# OOP I: Introduction to Object Oriented Programming"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contents\n",
    "\n",
    "- [OOP I: Introduction to Object Oriented Programming](#OOP-I:-Introduction-to-Object-Oriented-Programming)  \n",
    "  - [Overview](#Overview)  \n",
    "  - [Objects](#Objects)  \n",
    "  - [Summary](#Summary)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview\n",
    "\n",
    "[OOP](https://en.wikipedia.org/wiki/Object-oriented_programming) is one of the major paradigms in programming\n",
    "\n",
    "The traditional programming paradigm (think Fortran, C, MATLAB, etc.) is called *procedural*\n",
    "\n",
    "It works as follows\n",
    "\n",
    "- The program has a state corresponding to the values of its variables  \n",
    "- Functions are called to act on these data  \n",
    "- Data are passed back and forth via function calls  \n",
    "\n",
    "\n",
    "In contrast, in the OOP paradigm\n",
    "\n",
    "- data and functions are “bundled together” into “objects”  \n",
    "\n",
    "\n",
    "(Functions in this context are referred to as **methods**)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python and OOP\n",
    "\n",
    "Python is pragmatic language that blends object oriented and procedural styles, rather than taking a purist approach\n",
    "\n",
    "However, at a foundational level, Python *is* object oriented\n",
    "\n",
    "In particular, in Python, *everything is an object*\n",
    "\n",
    "In this lecture we explain what that statement means and why it matters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objects\n",
    "\n",
    "\n",
    "<a id='index-0'></a>\n",
    "In Python, an *object* is a collection of data and instructions held in computer memory that consists of\n",
    "\n",
    "1. a type  \n",
    "1. a unique identity  \n",
    "1. data (i.e., content)  \n",
    "1. methods  \n",
    "\n",
    "\n",
    "These concepts are defined and discussed sequentially below\n",
    "\n",
    "\n",
    "<a id='type'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type\n",
    "\n",
    "\n",
    "<a id='index-1'></a>\n",
    "Python provides for different types of objects, to accommodate different categories of data\n",
    "\n",
    "For example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = 'This is a string'\n",
    "type(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 42   # Now let's create an integer\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The type of an object matters for many expressions\n",
    "\n",
    "For example, the addition operator between two strings means concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'300cc'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'300' + 'cc'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On the other hand, between two numbers it means ordinary addition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "700"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "300 + 400"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consider the following expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-263a89d2d982>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m'300'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m400\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "'300' + 400"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we are mixing types, and it’s unclear to Python whether the user wants to\n",
    "\n",
    "- convert `'300'` to an integer and then add it to `400`, or  \n",
    "- convert `400` to string and then concatenate it with `'300'`  \n",
    "\n",
    "\n",
    "Some languages might try to guess but Python is *strongly typed*\n",
    "\n",
    "- Type is important, and implicit type conversion is rare  \n",
    "- Python will respond instead by raising a `TypeError`  \n",
    "\n",
    "\n",
    "To avoid the error, you need to clarify by changing the relevant type\n",
    "\n",
    "For example,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "700"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int('300') + 400   # To add as numbers, change the string to an integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<a id='identity'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Identity\n",
    "\n",
    "\n",
    "<a id='index-2'></a>\n",
    "In Python, each object has a unique identifier, which helps Python (and us) keep track of the object\n",
    "\n",
    "The identity of an object can be obtained via the `id()` function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140471801474600"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 2.5\n",
    "z = 2.5\n",
    "id(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140471801474552"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, `y` and `z` happen to have the same value (i.e., `2.5`), but they are not the same object\n",
    "\n",
    "The identity of an object is in fact just the address of the object in memory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Object Content: Data and Attributes\n",
    "\n",
    "\n",
    "<a id='index-3'></a>\n",
    "If we set `x = 42` then we create an object of type `int` that contains\n",
    "the data `42`\n",
    "\n",
    "In fact it contains more, as the following example shows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 42\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.imag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.__class__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When Python creates this integer object, it stores with it various auxiliary information, such as the imaginary part, and the type\n",
    "\n",
    "Any name following a dot is called an *attribute* of the object to the left of the dot\n",
    "\n",
    "- e.g.,``imag`` and `__class__` are attributes of `x`  \n",
    "\n",
    "\n",
    "We see from this example that objects have attributes that contain auxillary information\n",
    "\n",
    "They also have attributes that act like functions, called *methods*\n",
    "\n",
    "These attributes are important, so let’s discuss them in depth\n",
    "\n",
    "\n",
    "<a id='methods'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Methods\n",
    "\n",
    "\n",
    "<a id='index-4'></a>\n",
    "Methods are *functions that are bundled with objects*\n",
    "\n",
    "Formally, methods are attributes of objects that are callable (i.e., can be called as functions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = ['foo', 'bar']\n",
    "callable(x.append)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "callable(x.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Methods typically act on the data contained in the object they belong to, or combine that data with other data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THIS IS A STRING'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = ['a', 'b']\n",
    "x.append('c')\n",
    "s = 'This is a string'\n",
    "s.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'this is a string'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'That is a string'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.replace('This', 'That')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A great deal of Python functionality is organized around method calls\n",
    "\n",
    "For example, consider the following piece of code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['aa', 'b']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = ['a', 'b']\n",
    "x[0] = 'aa'  # Item assignment using square bracket notation\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It doesn’t look like there are any methods used here, but in fact the square bracket assignment notation is just a convenient interface to a method call\n",
    "\n",
    "What actually happens is that Python calls the `__setitem__` method, as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['aa', 'b']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = ['a', 'b']\n",
    "x.__setitem__(0, 'aa')  # Equivalent to x[0] = 'aa'\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(If you wanted to you could modify the `__setitem__` method, so that square bracket assignment does something totally different)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "In Python, *everything in memory is treated as an object*\n",
    "\n",
    "This includes not just lists, strings, etc., but also less obvious things, such as\n",
    "\n",
    "- functions (once they have been read into memory)  \n",
    "- modules  (ditto)  \n",
    "- files opened for reading or writing  \n",
    "- integers, etc.  \n",
    "\n",
    "\n",
    "Consider, for example, functions\n",
    "\n",
    "When Python reads a function definition, it creates a **function object** and stores it in memory\n",
    "\n",
    "The following code illustrates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.f(x)>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x): return x**2\n",
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140471739256344"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'f'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that `f` has type, identity, attributes and so on—just like any other object\n",
    "\n",
    "It also has methods\n",
    "\n",
    "One example is the `__call__` method, which just evaluates the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.__call__(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another is the `__dir__` method, which returns a list of attributes\n",
    "\n",
    "Modules loaded into memory are also treated as objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140471921010312"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "id(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This uniform treatment of data in Python (everything is an object) helps keep the language simple and consistent"
   ]
  }
 ],
 "metadata": {
  "filename": "oop_intro.rst",
  "kernelspec": {
   "display_name": "Python",
   "language": "python3",
   "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.0"
  },
  "title": "OOP I: Introduction to Object Oriented Programming"
 },
 "nbformat": 4,
 "nbformat_minor": 2
}