Python/Python-INTER/01 - Python Classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Classes\n",
    "\n",
    "You can find the most recent 3.x version documentation [here](https://docs.python.org/3/tutorial/classes.html)\n",
    "\n",
    "## Intro to Object Oriented Programming (OOP)\n",
    "\n",
    "There are 2 types of [programming paradigms](http://en.wikipedia.org/wiki/Programming_paradigm) (or methods) for structuring your code.\n",
    "\n",
    "1. The first is object-oriented programming - or OOP. It is a way to structure a program by creating an **object** - a grouping of related properties & behaviors. An object could represent a car with **properties** like make, model, and color. It could address **behaviors** such as driving forward, reverse, and use wipers.\n",
    "\n",
    "    _Object-oriented programming is an approach for modeling real world items and their interations._\n",
    "\n",
    "2. The 2nd is **procedural programming** where program structures are a set of steps, functions, and code blocks that are completed sequentially to complete a task."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Intro to Classes\n",
    "\n",
    "Classes are like blueprints for **objects** - also known as **instances** of a class (which contains real data - not just the shell). They are user (programmer) defined data structures.\n",
    "\n",
    "Classes are what allow you to create new data types - which means new _instances_ of that type can be made. These data types can have things like:\n",
    "- attributes for maintaining the object's state (e.g.:  eye color, name, etc)\n",
    "- methods (functions that can be run against the instance) for modifying it's state\n",
    "\n",
    "But these are just the main key components. Python classes provide all the same standard features of Object Oriented Programming:\n",
    "- [class inheritance](https://docs.python.org/3/tutorial/classes.html#inheritance)\n",
    "- arbitrary amounts & kinds of data\n",
    "- created at runtime\n",
    "- can be modified after creation\n",
    "\n",
    "Built-in types (classes already built into python) can be used as base classes for extension by a user or developer.\n",
    "\n",
    "Special syntax (_e.g.:  arithmetic operators_) can also be redefined for class instances.\n",
    "\n",
    "Before we get started, you may not be aware that there is something called [PEP 3107 - function annotation](https://www.python.org/dev/peps/pep-3107/). This can come in very handy later on down the line & it is highly suggested you use this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scopes & Namespaces\n",
    "\n",
    "### namespaces\n",
    "\n",
    "When you hear the term _**namespace**_ it refers to a mapping from names to objects. Most are currently implemented as Python dictionaries but may change in the future.\n",
    "\n",
    "Things to note for **_namespaces_**:\n",
    "- there is no relation between names in different namespaces\n",
    "- when using dot notation, items after the `.` are generally referred to as attributes:  `class_obj.attr1`\n",
    "- they are created at different moments & have different lifetimes (_e.g.:  namespace for builtin names when interpreter starts up; global namespace when module is used; function namespace is created when called and lasts until function ends_)\n",
    "\n",
    "Class definitions (creations of new classe instances) essentially creates additional namespaces in the local scope."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### scopes\n",
    "\n",
    "This is how your program accesses variables, objects, and other pieces of your program. It's the region where a namespace is directly accessible. Here it refers to the idea that if you were to try to acess something the \"local\" namespace hasn't heard of, you will run into an error.\n",
    "\n",
    "When trying to access something, the scope with which the program looks starts from the inside out:\n",
    "1. innermost scope:  _what is in my local (immediate) namespace?_\n",
    "2. enclosed functions scope:  _what is surrounding the local namespace, starting with the nearest enclosing scope? **--- contains non-local and non-global names**_\n",
    "3. current module's global names\n",
    "4. namespace with built-in names\n",
    "\n",
    "If a name (label) is declared global, then all references (pointers) and assignments (changing of data) have their namespace starting in that 3rd layer - the layer containing a module's global names.\n",
    "\n",
    "In order to access variables outside the local (level 1) scope, you need to indicate so with the `nonlocal` statement in front of the variable name. If you do not utilize either this [nonlocal](https://docs.python.org/3/reference/simple_stmts.html#nonlocal) or [global](https://docs.python.org/3/reference/simple_stmts.html#global) statement, the original variables become **read-only** and an attempt to overwrite the original data will simply create a _new_ local variable in the innermost scope leaving original unchanged.\n",
    "\n",
    "What's the difference between **global** and **nonlocal**?\n",
    "_**nonlocal** tells the interpreter to look at the enclosing scope, whereas **global** indicates the global scope._\n",
    "\n",
    "As a reminder, when you delete an object with `del var` (for example) you are removing the binding of the text from the namespace referened by the local scope."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is an example of python code that demonstrates these scope & namespace concepts from official documentation:\n",
    "```python\n",
    "def scope_test():\n",
    "    # this is the main function that is originally called\n",
    "    \n",
    "    def do_local():\n",
    "        # this represents local namespace & scope (nothing changed to original spam)\n",
    "        spam = \"local spam\"\n",
    "\n",
    "    def do_nonlocal():\n",
    "        nonlocal spam\n",
    "        spam = \"nonlocal spam\"\n",
    "\n",
    "    def do_global():\n",
    "        global spam\n",
    "        spam = \"global spam\"\n",
    "\n",
    "    spam = \"test spam\"\n",
    "    do_local()\n",
    "    print(\"After local assignment:\", spam)\n",
    "    do_nonlocal()\n",
    "    print(\"After nonlocal assignment:\", spam)\n",
    "    do_global()\n",
    "    print(\"After global assignment:\", spam)\n",
    "\n",
    "scope_test()\n",
    "print(\"In global scope:\", spam)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see how the **nonlocal** and **global** options affect variable binding - and how it could potentially introduce bugs when accidentally changing data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The New Language Of Classes\n",
    "\n",
    "If you've taken my [python basics bootcamp](https://prosperousheart.com/python-bootcamp) or have reviewed my free educational material on GitHub, you have the basics for programming in Python. But classes are an extension to create a wider realm of possibility."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Syntax\n",
    "\n",
    "There is a specific structure in how python interpreter expects to see classes written. In it's simplest pseudocode, a class definition looks like this:\n",
    "\n",
    "```python\n",
    "class ClassName:\n",
    "    <statement-0>\n",
    "    .\n",
    "    .\n",
    "    .\n",
    "    <statement-N>\n",
    "```\n",
    "\n",
    "Similar to functions there is a declarative statement (**class**) that is required for execution to have effect. And although not required, the [class naming convention](https://www.python.org/dev/peps/pep-0008/#class-names) is camel casing or CapWords.\n",
    "\n",
    "Within a new class, there are likely functions but other statements are allowed - sometimes even useful! These functions normally have a specific argument list.\n",
    "\n",
    "When a new object is instantiated from these classes, a new namespace is created and then used as a local scope for that object. This _class object_ essentially acts as a wrapper around this namespace, and changes can be made upon that object that do not necessarily affect that instance of it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Class Objects](https://docs.python.org/3/tutorial/classes.html#class-objects)\n",
    "\n",
    "When it comes to classes, there are 2 supported operations:\n",
    "1. attribute references (accessing and/or manipulating data)\n",
    "2. instantiation (creation of new class objects)\n",
    "\n",
    "**NOTE:**  you may see two terms throughout this training:\n",
    "1. `instance variable`\n",
    "2. `class variable`\n",
    "\n",
    "    **Instance variables** are the unique data related to a specific instance (creation) of a class.\n",
    "    \n",
    "    **Class variables** are attributes and methods shared by all instances (creations) of a class.\n",
    "\n",
    "```python\n",
    "class Dog:\n",
    "    \n",
    "    # class variable shared by all instances\n",
    "    kind = 'canine'\n",
    "\n",
    "    def __init__(self, name, eye_c, breed):\n",
    "        # instance variables unique to each instance\n",
    "        self.name = name\n",
    "        self.eye_color = eye_c\n",
    "        self.breed = breed\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attribute References\n",
    "\n",
    "Every time you create a class object, you create an _instance_ of that object ... Meaning a piece of code with:\n",
    "- **class attributes** where all instances of that class type have the same value (e.g.:  dog species)\n",
    "- **instance attributes** where the attribute values are specific to the instance, not the class (e.g.:  eye color)\n",
    "\n",
    "And each instance points to a different location for the data.\n",
    "\n",
    "One of the biggest advantages of using classes to organize data is that instances are guaranteed to have the attributes you expect.\n",
    "\n",
    "#### Class Attributes\n",
    "\n",
    "**Class attributes** are defined directly beneath the class name and indented by 4 spaces with some initial value.\n",
    "\n",
    "These should be used to define properties that should have the same value for every class instance.\n",
    "\n",
    "#### Instance Attributes\n",
    "\n",
    "So when thinking of creating classes, think of all the base attributes. For example ...\n",
    "\n",
    "If you were to create a class for a cat, what attributes would it have?\n",
    "- number of legs\n",
    "- color of fur\n",
    "- sex\n",
    "- age\n",
    "- eye color\n",
    "\n",
    "And the list could go on. Each of these attributes, you would have the ability to update a particular instance vs all cats.\n",
    "\n",
    "You access each attribute by using __dot notation__ like so:<br>\n",
    "`new_cup.staves = 10`\n",
    "\n",
    "This is the standard syntax for all attribute references (class or instance), whether built-in or user-defined:  `obj.name`\n",
    "\n",
    "Valid attribute names are the ones in a class's namespace when the object was created and are either:\n",
    "- data attributes:  do not need to be declared because they are created upon instantiation (creation)\n",
    "- methods (function that belongs to an object)\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "    \n",
    "```python\n",
    "class MyClass:\n",
    "    \"\"\"A simple example class\"\"\"\n",
    "    i = 12345\n",
    "\n",
    "    def f(self):\n",
    "        return 'hello world'\n",
    "```\n",
    "</div>\n",
    "\n",
    "In the above example from official documentation, attributes of the **MyClass** class are as follows:\n",
    "- `MyClass.i` returns an integer\n",
    "- `MyClass.f` returns a function or **method object** (meaning until you call the method, it simply stores the method object)\n",
    "\n",
    "    ```python\n",
    "    x = MyClass()\n",
    "    xf = x.f  # stores the function, but it's not called yet\n",
    "    xf()  # will call the actual function - would be the same as x.f()\n",
    "    ```\n",
    "\n",
    "You can also update an attribute with an assignment operation such as:  `MyClass.i = 42`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Warning For Mutable Attributes\n",
    "\n",
    "What do you think would happen if you ran the below code?\n",
    "\n",
    "```python\n",
    "class Dog:\n",
    "\n",
    "    tricks = []             # mistaken use of a class variable\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def add_trick(self, trick):\n",
    "        self.tricks.append(trick)\n",
    "\n",
    "d = Dog('Fido')\n",
    "e = Dog('Buddy')\n",
    "d.add_trick('roll over')\n",
    "e.add_trick('play dead')\n",
    "d.tricks\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Is it what you would expect of 2 dogs if you only taught one trick per dog?\n",
    "\n",
    "_How would you fix the above code?_ Move the **tricks** class attribute into the `__init__` function so each \"new dog\" has it's own set of tricks.\n",
    "\n",
    "Should you have an attribute name in a class and it's instance, the lookup prioritizes the instance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Object Instantiation\n",
    "\n",
    "When creating a new object from a class, you are **instantiating** an object. You are creating an instance of a class object, which means each new instantiation has it's own memory address. And if you tried to compare 2 instances of a class object, it would return False.\n",
    "\n",
    "In order to create a new instance, you would type the name of the class followed by opening and closing parentheses:  `ClassName()`\n",
    "\n",
    "If there are no required input parameters that do not already have a default value, then you would see something like `varName = MyClass()` to create a new instance of the **MyClass** variable and assigns it to the **local** variable `temp`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you [use proper docstrings](https://www.python.org/dev/peps/pep-0257/) you can always run the function (or call the function attribute on an object) `.__doc__` to learn more about the object - data, function, module, etc.\n",
    "\n",
    "<div class=\"alert alert-warning\">\n",
    "What would be returned if you ran:\n",
    "    \n",
    "```python\n",
    "class MyClass:\n",
    "    \"\"\"A simple example class\"\"\"\n",
    "    i = 12345\n",
    "\n",
    "    def f(self):\n",
    "        return 'hello world'\n",
    "        \n",
    "temp = MyClass()\n",
    "temp.__doc__\n",
    "```\n",
    "</div>\n",
    "\n",
    "This is called a **dunder method** - aka a \"magic method\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class Methods & Functions\n",
    "\n",
    "Often, the first argument of a method (even if not in a class) starts with `self` & is nothing more than convention. However, depending on other automated pieces in your environment it may cause an issue if you do not use it.\n",
    "\n",
    "Methods can call other methods by using method attributes of the `self` argument, such as:\n",
    "\n",
    "```python\n",
    "class Bag:\n",
    "    def __init__(self):\n",
    "        self.data = []\n",
    "\n",
    "    def add(self, x):\n",
    "        self.data.append(x)\n",
    "\n",
    "    def addtwice(self, x):\n",
    "        self.add(x)\n",
    "        self.add(x)\n",
    "```\n",
    "\n",
    "There are 3 different types of methods, which are explained [here](https://realpython.com/instance-class-and-static-methods-demystified)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Types Of Class Methods\n",
    "\n",
    "Below is an [example from RealPython](https://realpython.com/instance-class-and-static-methods-demystified/#instance-class-and-static-methods-an-overview) on what the three methods might look like in a python program.\n",
    "\n",
    "```python\n",
    "class MyClass:\n",
    "    def method(self):\n",
    "        return 'instance method called', self\n",
    "\n",
    "    @classmethod\n",
    "    def classmethod(cls):\n",
    "        return 'class method called', cls\n",
    "\n",
    "    @staticmethod\n",
    "    def staticmethod():\n",
    "        return 'static method called'\n",
    "```\n",
    "\n",
    "All three methods can take in and number of other parameters not mentioned here.\n",
    "\n",
    "### Instance Methods\n",
    "\n",
    "This is a basic method type most commonly used. It takes (at minimum) one parameter (always first input):  `self`\n",
    "\n",
    "This single parameter points to an **instance** of a class - a particular instantiation or creation of the class. It is through this parameter that instances can freely access attributes & other methods on the same object.\n",
    "\n",
    "Instance methods also access the class itself through the `self.__class__` attribute. Which means it can modify the class state.\n",
    "\n",
    "Additional information can also be found [here](https://realpython.com/python3-object-oriented-programming/#instance-methods).\n",
    "\n",
    "### Class Methods\n",
    "\n",
    "Instead of the `self` parameter, it takes the `cls` parameter (always first input). This points to the class as a whole. It can't modify the object itself, but it can modify the class state across all instances of the class.\n",
    "\n",
    "This means you do not need an instance of the class to call these class methods.\n",
    "\n",
    "A really great way to see this in action is with [this Pizza factory example](https://realpython.com/instance-class-and-static-methods-demystified/#delicious-pizza-factories-with-classmethod). It's a wonderful example of the [don't repeat yourself](https://en.wikipedia.org/wiki/Don't_repeat_yourself) principle.\n",
    "\n",
    "### Static Methods\n",
    "\n",
    "There are no required parameters for these.\n",
    "\n",
    "These methods neither modify the obejct nor class states. They are restricted in what data they can access & are primarily a way to [namespace](https://realpython.com/python-namespaces-scope/) your methods.\n",
    "\n",
    "These methods work like regular functions but belong to the class (and each instance's) namespace.\n",
    "\n",
    "You can learn more about when to use statis methods [here](https://realpython.com/instance-class-and-static-methods-demystified/#when-to-use-static-methods)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Magic Methods (Dunders)\n",
    "\n",
    "This is a term you will hear among many programmer groups. These **magic methods** are special methods with double underscores at the beginning and end of their names. (*Also known as __dunder methods__!*)\n",
    "\n",
    "These methods allow you to create functionality that can't be represented in a normal method.\n",
    "\n",
    "There are a lot of methods available (such as those listed in [this article on GitHub](https://rszalski.github.io/magicmethods)) but the one you'll see most? Is the one that allows you to create an instance (or instantiate) an object of said class type.\n",
    "\n",
    "Instantiating a class object (or \"calling\") create a base object - sometimes referred to as empty. But in reality, it's just the defaults assigned to it. You can change the initial \"empty\" state with the special **dunder method** `__init__`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `__init__`\n",
    "\n",
    "The `__init__` dunder or magic method is the most important method within a class. This is the function of the class object that is called when an instance of the object is instantiated or created. It is also known as \"the instance initiliazer\" in Python - or the method (function) that sets the initial **state** of an object.\n",
    "\n",
    "All `__init__` methods __must__ start with __*self*__ as the first parameter. This is what is automatically invoked when a new class object is created.\n",
    "\n",
    "_NOTE:  This parameter indicates to Python that when calling __self__ you are referring to the INSTANCE that is calling the method, vs making a change to all instances._\n",
    "\n",
    "<hr>\n",
    "\n",
    "```python\n",
    "class Wood_Cup:\n",
    "    \"\"\"\n",
    "    This class is to create a wooden cup object.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, wood_type_obj = None, size = None, art_class_obj = None, handle_loc = \"R\", staves = 0):\n",
    "        \"\"\"\n",
    "        This is the __init__ method which allows someone to create an instance of the Wood_Cup class.\n",
    "        \n",
    "        This function determines what attributes each instance of the class will have.\n",
    "        \n",
    "        \"\"\"\n",
    "        \n",
    "        self.staves = staves\n",
    "        self.wood_type = wood_type_obj\n",
    "        self.art_class_obj = art_class_obj\n",
    "        self.staves = staves\n",
    "        self.size = size\n",
    "```\n",
    "\n",
    "<hr>\n",
    "\n",
    "When creating or instantiating a new instance of a class, you do not need to add *__self__* as an input parameter.\n",
    "\n",
    "Such as:  `new_cup = Wood_Cup(\"birch\", \"B\", None, \"L\", 8)`\n",
    "\n",
    "There are lots of built-in methods for classes that can really help to clean up your code as well as make it more pliable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example from official documentation:\n",
    "\n",
    "```python\n",
    "class Complex:\n",
    "    def __init__(self, realpart, imagpart):\n",
    "        self.r = realpart\n",
    "        self.i = imagpart\n",
    "\n",
    "x = Complex(3.0, -4.5)\n",
    "x.r, x.i\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "How would you create a class object (instantiate a new object from the above MyClass) and then:<br>\n",
    "    1. call <b>i</b><br>\n",
    "    2. change <b>i</b><br>\n",
    "    3. call <b>i</b>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There may even be times where you want to test for ambiguous input, such as a string or [DateTime](https://docs.python.org/3/library/datetime.html) object when expecting a date. Check out [this](https://realpython.com/python-multiple-constructors/) for how you can do that. Or if you're interested in checking out a new option with python 3.10, check out [structural pattern matching](https://realpython.com/python310-new-features/#structural-pattern-matching)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Class Inheritance](https://docs.python.org/3/tutorial/classes.html#inheritance)\n",
    "\n",
    "When we refer to inheritance, it is the ability to utilize another calss's structure as a \"base\" for a new class - the process where one class takes on the attributes & methods of another. The syntax is as follows:\n",
    "\n",
    "```python\n",
    "class DerivedClassName(BaseClassName):\n",
    "    <statement-0>\n",
    "    .\n",
    "    .\n",
    "    .\n",
    "    <statement-N>\n",
    "```\n",
    "\n",
    "`BaseClassName` must be defined in a scope that contained the creation (definition) of `DerivedClassName`. If a base class is defined in another module, the syntax might look like this:\n",
    "\n",
    "```python\n",
    "class DerivedClassName(modname.BaseClassName):\n",
    "    <statement-0>\n",
    "    .\n",
    "    .\n",
    "    .\n",
    "    <statement-N>\n",
    "```\n",
    "\n",
    "Even if you don't see all of the attributes in your `DerivedClassName`, if you attempt to utilize an attribute or function your base class has the itnerpreter will look to your base class(es) for this information.\n",
    "\n",
    "Additional insight can be found [here](https://realpython.com/python3-object-oriented-programming/#inherit-from-other-classes-in-python)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Caution With Overriding Base Attributes\n",
    "\n",
    "It is possible to have a method in your `DerivedClassName` that replaces a base class method or attribute ... But you can also write your code so that the new class instead extends functionality.\n",
    "\n",
    "## Built-In Inheritance Functions\n",
    "\n",
    "1. [`isinstance(obj, sysinfo)`](https://docs.python.org/3/library/functions.html#isinstance)\n",
    "    - returns True (or 1) if the `object` argument is an instance (or subclass) of the `classinfo` object -- otherwise False (or 0)\n",
    "    - (as of ver 3.10) if `classinfo` is a tuple of objects (or recursive tuples) OR a [Union type](https://docs.python.org/3/library/stdtypes.html#types-union) of multiple items, this returns True (or 1) when `object` is an instance of ANY entry --- otherwise a [TypeError](https://docs.python.org/3/library/exceptions.html#TypeError) subclass of [exception](https://github.com/ProsperousHeart/Basics-Boot-Camp/blob/main/Week_3/Python_Basics_18_-_Exceptions_%26_Assertions.ipynb) is raised.\n",
    "\n",
    "\n",
    "2. [`issubclass(class, classinfo)`](https://docs.python.org/3/library/functions.html#issubclass)\n",
    "    - a class is considered a subclass of itself\n",
    "    - returns True (or 1) if a `class` is a subclass (direct, indirect, or [virtual](https://docs.python.org/3/glossary.html#term-abstract-base-class)) of `classinfo`\n",
    "    - (as of ver 3.10) if `classinfo` is a tuple of objects OR a [Union type](https://docs.python.org/3/library/stdtypes.html#types-union), this returns True (or 1) when `object` is a subclass of ANY of the types --- otherwise a [TypeError](https://docs.python.org/3/library/exceptions.html#TypeError) subclass of [exception](https://github.com/ProsperousHeart/Basics-Boot-Camp/blob/main/Week_3/Python_Basics_18_-_Exceptions_%26_Assertions.ipynb) is raised."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Multiple Inheritance](https://docs.python.org/3/tutorial/classes.html#multiple-inheritance)\n",
    "\n",
    "When a new class type is created, you can pull from multiple base classes. This class definition might look something like this:\n",
    "\n",
    "```python\n",
    "class DerivedClassName(Base0, ..., BaseX):\n",
    "    <statement-0>\n",
    "    .\n",
    "    .\n",
    "    .\n",
    "    <statement-N>\n",
    "```\n",
    "\n",
    "**_How does the interpreter know where to look?_**\n",
    "\n",
    "1. looks internaly to itself (the class) - _does that attribute/method reside in `DerivedClassName`?_\n",
    "2. looks at first base class in the input parameter of class definition\n",
    "    - in this example, looks in Base0\n",
    "    - if not found there, looks in it's parent classes recursively\n",
    "3. if not found in 1st base class, it will recursively check all of the rest\n",
    "\n",
    "It's a bit more complex than the above. If yowant to get mroe into inheritance, be sure to check out the documentation for [`super()`](https://docs.python.org/3/library/functions.html#super) as well as [this guide to using `super()`](https://rhettinger.wordpress.com/2011/05/26/super-considered-super/). You can also use [this method resolution order](https://www.python.org/download/releases/2.3/mro/) doc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Iterators In Your Classes](https://docs.python.org/3/tutorial/classes.html#iterators)\n",
    "\n",
    "You have the ability to make a class be an iterable! Meaning you can put an instance of a class inside the [`iter(obj)`](https://docs.python.org/3/library/functions.html#iter) built-in function.\n",
    "\n",
    "They use the dunder method [`__next__()`](https://docs.python.org/3/library/stdtypes.html#iterator.__next__) so you can use the [`next()`](https://docs.python.org/3/library/functions.html#next) function.\n",
    "\n",
    "Here is a (tweaked) example from official documentation for reading in a string of charactrs backwards:\n",
    "\n",
    "```python\n",
    "class Reverse:\n",
    "    \"\"\"Iterator for looping over a sequence backwards.\"\"\"\n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "        self.index = len(data)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "\n",
    "    def __next__(self):\n",
    "        if self.index == 0:\n",
    "            raise StopIteration\n",
    "        self.index = self.index - 1\n",
    "        return self.data[self.index]\n",
    "\n",
    "rev = Reverse(input(\"What phrase would you like repeated backwards?\\t\"))\n",
    "iter(rev)\n",
    "for char in rev:\n",
    "    print(char)\n",
    "```\n",
    "\n",
    "Try it out for yourself!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Generators In Your Classes](https://docs.python.org/3/tutorial/classes.html#generators)\n",
    "\n",
    "While we have already discussed [iterators & generators](https://github.com/ProsperousHeart/Basics-Boot-Camp/blob/main/Week_2/Python_Basics_13_-_Iterators_And_Generators.ipynb), you may find additional insight with official documentation. (This section's title links to it.)\n",
    "\n",
    "Long story short, generators are like Pez dispensers. Once a piece of data is yielded, the next piece is ready to be called by [`yield.()`](https://docs.python.org/3/reference/simple_stmts.html#yield)\n",
    "\n",
    "You have the ability to make a class be a generator!\n",
    "\n",
    "While I tried to provide an example of what the official documentation outlines, it wouldn't work for me. It's also never come up, so not sure how often you would need the info.\n",
    "\n",
    "It's also possible to have [generator expressions](https://docs.python.org/3/tutorial/classes.html#generator-expressions)  - similar to [list comprehensions](https://www.python.org/dev/peps/pep-0202/). Generally sued when a generator is immediately used by an enclosing function. These tend to be more user friendly than equivalent list comprehensions.\n",
    "\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Special Class Notes\n",
    "\n",
    "If you were to run `type()` command on a class object, you will see that it is of the `object.__class__` type.\n",
    "\n",
    "_**What about \"private\" variables?**_ More on that [here](https://docs.python.org/3/tutorial/classes.html#private-variables).\n",
    "\n",
    "There is also [this Odds & Ends section](https://docs.python.org/3/tutorial/classes.html#odds-and-ends) that may be of interest, but leaves your code open to ambiguity."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class [Decorators](https://realpython.com/primer-on-python-decorators/)\n",
    "\n",
    "More on this to come, but definitely check out the link for this until then!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Additional Sites\n",
    "1. PEP Style Guides:\n",
    "    - [318:  Decorators For Functions & Methods](https://www.python.org/dev/peps/pep-0318/)\n",
    "    - [352: Exceptions as New-Style Classes](https://docs.python.org/3/whatsnew/2.5.html#pep-352-exceptions-as-new-style-classes)\n",
    "    - [487:  Simpler customization of class creation](https://docs.python.org/3/whatsnew/3.6.html#pep-487-simpler-customization-of-class-creation)\n",
    "    - [520: Preserving Class Attribute Definition Order](https://docs.python.org/3/whatsnew/3.6.html#pep-520-preserving-class-attribute-definition-order)\n",
    "    - [3119: Abstract Base Classes](https://docs.python.org/3/whatsnew/2.6.html#pep-3119-abstract-base-classes)\n",
    "    - [3129: Class Decorators](https://docs.python.org/3/whatsnew/2.6.html#pep-3129-class-decorators)\n",
    "    - [3155: Qualified name for classes and functions](https://docs.python.org/3/whatsnew/3.3.html#pep-3155-qualified-name-for-classes-and-functions)\n",
    "\n",
    "\n",
    "2. Official Python Documentation\n",
    "    - [Base Exception classes](https://docs.python.org/3/library/exceptions.html#base-classes)\n",
    "    - [Collections](https://docs.python.org/3/library/collections.abc.html) - abstract base classes for containers\n",
    "\n",
    "\n",
    "3. RealPyton:\n",
    "    - [Object Oriented Programming (OOP)](https://realpython.com/python3-object-oriented-programming/)\n",
    "    - [Primer on Python Decorators](https://realpython.com/primer-on-python-decorators/)\n",
    "    - [Instance, Class, & Static Methods](https://realpython.com/instance-class-and-static-methods-demystified/)\n",
    "    - [Multiple Contructors](https://realpython.com/python-multiple-constructors/)\n",
    "    \n",
    "    \n",
    "4. On decorators:\n",
    "    - [Primer On Function Decoratrs](https://realpython.com/primer-on-python-decorators/)\n",
    "    - [Python decorators](https://www.geeksforgeeks.org/decorators-in-python/)"
   ]
  },
  {
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}