2. Cheat Sheet Antonio Dagnino.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Cheat Sheet Antonio Dagnino"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Functions\n",
    "    - Abstraction Mechanisms\n",
    "        - Eliminating Redundancy\n",
    "        - Systematic variations\n",
    "    - main function\n",
    "- Classes\n",
    "    - help\n",
    "    - __init__ method\n",
    "    - Objects\n",
    "    - Instance variable\n",
    "    - Atttributes\n",
    "    - Methods\n",
    "    - __dict__ method\n",
    "    - __str__ method\n",
    "    - Types of Methods\n",
    "    - Inheritance\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[200, 90] [25, 20]\n"
     ]
    }
   ],
   "source": [
    "def rectangleAP(length, width):\n",
    "#Returns the area and the perimeter using\n",
    "#the length and width of a rectangle\n",
    "    Area = length * width\n",
    "    Perimeter = (length + width) * 2\n",
    "    return [Area, Perimeter]\n",
    "\n",
    "\n",
    " \n",
    "resultRec1 = rectangleAP(40, 5)\n",
    "resultRec2 = rectangleAP(5, 5)\n",
    "print(resultRec1, resultRec2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Abstractions Mechanisms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----- Eliminating Redundancy -----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[200, 90] [30, 22] [42, 26]\n"
     ]
    }
   ],
   "source": [
    "#Eliminating Reundancy by calling the function to make the same calculation multiple times with different variables\n",
    "print(rectangleAP(40,5),rectangleAP(5,6),rectangleAP(6,7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----- Systematic Variations -----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[50, 30, 0.5]\n"
     ]
    }
   ],
   "source": [
    "def rectangleAP(length, width):\n",
    "    Area = length * width\n",
    "    Perimeter = (length + width) * 2\n",
    "    #--- systematic variations ---\n",
    "    ratio = length / width\n",
    "    return [Area, Perimeter,ratio]\n",
    "print(rectangleAP(5,10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----- main function -----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter length and width: 55\n",
      "The area is 25.0\n",
      "The perimeter is 20.0\n"
     ]
    }
   ],
   "source": [
    "def main():\n",
    "#The main function of the program\n",
    "    l,w = input(\"Enter length and width: \")\n",
    "    result = rectangleAP(float(l), float(w))\n",
    "    print(\"The area is\", result[0])\n",
    "    print(\"The perimeter is\", result[1])\n",
    "\n",
    "def rectangleAP(length, width):\n",
    "#Returns the area, perimeter\n",
    "#of a rectangle using the length and width\n",
    "    Area = length * width\n",
    "    Perimeter = (length + width) * 2\n",
    "    return [Area, Perimeter]\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "# execute only if run as a script\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----- help -----"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----- init method -----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Student in module __main__:\n",
      "\n",
      "class Student(builtins.object)\n",
      " |  Student(name, score)\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, name, score)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# init module is also called as the constructor and will basically link the attributes on the class with the instances.\n",
    "\n",
    "class Student:\n",
    "    def __init__(self,name,score):\n",
    "        self.name = name\n",
    "        self.score = score\n",
    "        \n",
    "help(Student)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----- Objects -----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Student object at 0x0000026F7F61A048>\n"
     ]
    }
   ],
   "source": [
    "#Object: A group of attributes assigned to a class.\n",
    "\n",
    "print(Student('Harry',80))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----- Class Instances or Instance variables -----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Student at 0x26f7f5ad0f0>"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# When you assign the object to avariable\n",
    "firstStudent = Student('Harry',80)\n",
    "secondStudent = Student('Sally',90)\n",
    "\n",
    "firstStudent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "-----  Attributes -----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Harry 80\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "The class will allow the user to acces to unique attributes that belong to specific instances. On this case, 'firstStudent'\n",
    "Notice the syntax used to call the attributes of the instances do not have parenthesis !!!! This is will\n",
    "be a way to recognize when an attribute is called in a class instead of a method.\n",
    "\"\"\"\n",
    "print(firstStudent.name, firstStudent.score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----- methods -----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Brown\n",
      "Brown 90\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<bound method Student.lastName of <__main__.Student object at 0x0000026F7F60D2E8>>"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "- Methods are functions inside classes. They could work either as accesors or mutators\n",
    "- 'self' expression: It refers to the class instance. In other words, the method is using 'self' to replace any instance that\n",
    "interacts with the class. As a result, the class does not need the specific name of the instance, but the attributes and the\n",
    "name of the class where those attributes belong to. For example, the 'lastName' method will accept any instance that belongs\n",
    "to Student class and at least has one attribute ('name').\n",
    "Notice the syntax to call methods: a Parenthesis is used at the end.\n",
    "\"\"\"\n",
    "class Student:\n",
    "    def __init__(self,name,score):\n",
    "        self.name = name\n",
    "        self.score = score\n",
    "    def lastName(self): #Accessor (method)\n",
    "        nameParts = self.name.split()\n",
    "        return nameParts[1]\n",
    "    def adjustedScore(self): #Mutator (method)\n",
    "        self.score = self.score + 10\n",
    "        return self.score\n",
    "\n",
    "firstStudent = Student('Harry Brown',80)\n",
    "\n",
    "print(Student.lastName(firstStudent)) #Option 1 to call methods. This method is redundant because you mention the class twice\n",
    "\n",
    "print(firstStudent.lastName(), firstStudent.adjustedScore()) # Option 2 to call methods\n",
    "\n",
    "\n",
    "# Syntax Review: Notice what happens when you dont use parenthesis on methods. The print will be the method description.\n",
    "firstStudent.lastName\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----- dict method -----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mappingproxy({'__module__': '__main__',\n",
       "              '__init__': <function __main__.Student.__init__(self, name, score)>,\n",
       "              'lastName': <function __main__.Student.lastName(self)>,\n",
       "              'adjustedScore': <function __main__.Student.adjustedScore(self)>,\n",
       "              '__dict__': <attribute '__dict__' of 'Student' objects>,\n",
       "              '__weakref__': <attribute '__weakref__' of 'Student' objects>,\n",
       "              '__doc__': None})"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#apply __dict__ on the class to see general information and class variables if there are any.\n",
    "#Remember class variables are shared on all instances. This means, all instances could recognize and use the class variable\n",
    "Student.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Harry Brown', 'score': 90}"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# apply __dict__ on the object to access all attributes\n",
    "firstStudent.__dict__ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----- str method -----"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: Harry Brown \n",
      "Score: 80\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self,name,score):\n",
    "        self.name = name\n",
    "        self.score = score\n",
    "    def __str__(self):\n",
    "        result = f'Name: {self.name} \\nScore: {self.score}'\n",
    "        return result\n",
    "\n",
    "\n",
    "firstStudent = Student('Harry Brown',80)\n",
    "print(firstStudent.__str__())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__----- Types of Methods -----__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Corey\n",
      "Corey Schafer\n",
      "1.04 \n",
      "\n",
      "1.05 \n",
      "\n",
      "john.Doe@company.com \n",
      "\n",
      "True \n",
      "\n",
      "{'__module__': '__main__', 'num_of_emps': 3, 'raise_amt': 1.05, '__init__': <function Employee.__init__ at 0x0000026F7FA902F0>, 'fullname': <function Employee.fullname at 0x0000026F7FA90378>, 'apply_raise': <function Employee.apply_raise at 0x0000026F7FA90400>, 'set_raise_amt': <classmethod object at 0x0000026F7FA8A5C0>, 'from_string': <classmethod object at 0x0000026F7FA8A198>, 'is_workday': <staticmethod object at 0x0000026F7FA8A828>, '__dict__': <attribute '__dict__' of 'Employee' objects>, '__weakref__': <attribute '__weakref__' of 'Employee' objects>, '__doc__': None}\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "There are three types of methods:\n",
    "- regular Method: The first argument is an instance\n",
    "- Class Method: The first argument is a class. This needs a decorator\n",
    "- Static method: does not have first argument. This needs a decorator\n",
    "\n",
    "\"\"\"\n",
    "\n",
    "class Employee:\n",
    "    num_of_emps = 0                                      # Class variables\n",
    "    raise_amt = 1.04\n",
    "    def __init__(self,first,last,pay):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        self.email = first + '.' + last + '@company.com'\n",
    "        self.pay = pay\n",
    "        \n",
    "        Employee.num_of_emps += 1\n",
    "    \n",
    "    def fullname(self):                                     #regular method: They take the instance as the first argument\n",
    "        return '{} {}'.format(self.first,self.last)\n",
    "    \n",
    "    def apply_raise(self):\n",
    "        self.pay = int(self.pay * self.raise_amt)\n",
    "        \n",
    "    @classmethod                                             # decorator: Alters the functionality of a regular method\n",
    "    def set_raise_amt(cls,amount):                           # class method: Receives the class as first argument ('cls')\n",
    "        cls.raise_amt = amount\n",
    "    \n",
    "    @classmethod                                            #class method with alternative constructors\n",
    "    def from_string(cls,emp_str):                           # this method is usually used for timestamps\n",
    "        first,last,pay = emp_str.split('-')\n",
    "        return cls(first,last,pay)\n",
    "    \n",
    "    @staticmethod                                        #static methods. This method does not take class or instances.\n",
    "    def is_workday(day):                                 # this behaves more like a regular function but inside the class\n",
    "        if day.weekday() == 5 or day.weekday()==6:\n",
    "            return True\n",
    "        return False\n",
    "        \n",
    "emp_1 = Employee('Corey','Schafer',50000)                     #Instance variables\n",
    "emp_2 = Employee('test','user',60000)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "print(emp_1.first)\n",
    "print(emp_1.fullname())\n",
    "print(emp_1.raise_amt,'\\n')\n",
    "\n",
    "\n",
    "Employee.set_raise_amt(1.05)                         # Working with the class instead of the instance\n",
    "print(Employee.raise_amt,'\\n')\n",
    "\n",
    "emp_str_3 = 'john-Doe-70000'                        #working with class methods\n",
    "emp_3 = Employee.from_string(emp_str_3)\n",
    "print(emp_3.email,'\\n')\n",
    "\n",
    "import datetime\n",
    "my_date = datetime.date(2016,12,25) #YY/MM/DD\n",
    "print(Employee.is_workday(my_date),'\\n')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "print(Employee.__dict__)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__----- Inheritance -----__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Antonio.Dagnino@company.com Python \n",
      "\n",
      "Help on class Developer in module __main__:\n",
      "\n",
      "class Developer(Employee)\n",
      " |  Developer(first, last, pay, prog_lang)\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Developer\n",
      " |      Employee\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, first, last, pay, prog_lang)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from Employee:\n",
      " |  \n",
      " |  apply_raise(self)\n",
      " |  \n",
      " |  fullname(self)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from Employee:\n",
      " |  \n",
      " |  from_string(emp_str) from builtins.type\n",
      " |  \n",
      " |  set_raise_amt(amount) from builtins.type\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from Employee:\n",
      " |  \n",
      " |  is_workday(day)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from Employee:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from Employee:\n",
      " |  \n",
      " |  num_of_emps = 7\n",
      " |  \n",
      " |  raise_amt = 1.05\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "Subclass: Also called child classes, they will have access to all methods and attributes from 'parent' or super class.\n",
    "Inheritance: The ability to have  access to attributes and methods from another class without having to write all code again\n",
    "\"\"\"\n",
    "class Developer(Employee):                                      #subclass. See syntax!\n",
    "    def __init__(self,first,last,pay,prog_lang): #Inside this body, you can make changes without affecting the parent class\n",
    "        super().__init__(first,last,pay)             # load attributes from parent class\n",
    "        self.prog_lang = prog_lang                   # but avoiding redundancy in the code.\n",
    "        \n",
    "dev_1 = Developer('Antonio','Dagnino',120000, 'Python')\n",
    "print(dev_1.email,dev_1.prog_lang,'\\n')\n",
    "\n",
    "help(Developer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__----- isinstance and  issubclass -----__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True \n",
      "\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(isinstance(dev_1,Developer),'\\n')\n",
    "print(issubclass(Developer,Employee))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}