Chapter 7 - Classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 7 - Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Classes are another way to **encapsulate** code. Classes can be a powerful tool that can make code general. This means being able to migrate code to new projects. To create a class, use the class keyword followed by the name of the class (class names are capitalized). Contained within a class can be attributes (initizialed with the **__init__()** method), functions (called methods), and static attributes (will go into detail later). To **instantiate** a class, simply assign a variable the class name and variables needed for __init__. To call a method, just use the class name dot method name (plus variables the method might require) call method.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    \"\"\" A dog class \"\"\"\n",
    "    \n",
    "    def __init__(self, name, age, breed, allergies):\n",
    "        \"\"\" inited with name, age, breed, and allergies of dog \"\"\"\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.breed = breed\n",
    "        self.allergies = allergies\n",
    "        \n",
    "    def grawl(self):\n",
    "        \"\"\" dog growls \"\"\"\n",
    "        print(self.name, \"is growling\")\n",
    "        \n",
    "    def peekBreed(self):\n",
    "        \"\"\" gets the dog breed \"\"\"\n",
    "        print(f\"{self.name} is a {self.breed}\")\n",
    "        return self.breed\n",
    "    \n",
    "    def found_allergies(self, allergy):\n",
    "        self.allergies.append(allergy)\n",
    "\n",
    "    def print_allergies(self):\n",
    "        print(f\"{self.name}'s allergies include the following:\")\n",
    "        for allergy in self.allergies:\n",
    "            print(allergy)\n",
    "    \n",
    "    def pet(self, number = 1):\n",
    "        \"\"\" pets the dog for the number of times passed in, defaults to 1 pet \"\"\"\n",
    "        for i in range(number):\n",
    "            print(f\"You have pet {self.name}\")\n",
    "\n",
    "# inits dog\n",
    "my_dog = Dog(\"Alan\", 11, \"Labrador Retriever\", [\"dust mites\"])\n",
    "\n",
    "# dog grawls\n",
    "my_dog.grawl()\n",
    "\n",
    "# gets the breed of the dog by looking\n",
    "breed = my_dog.peekBreed()\n",
    "\n",
    "# pets dog 4 times\n",
    "my_dog.pet(4)\n",
    "        \n",
    "my_dog.print_allergies()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, classes can get quite large depending on how many methods you put into it. You may have also noticed the keyword **self**. **self** simply refers to the class itself and must be included with each method. \n",
    "\n",
    "Also, notice that every method and the class itself has a doc-string explaining what it does, want variables it requires and what it returns. This is important in terms of documentation and can be print if you use the .__doc__ call on it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(my_dog.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another very important concept is setter and getter methods. In the example above, **peekBreed** is a getter method and **found_allergies** is a setter. This is because peekBreed returns the breed to the caller and found_allergies sets the allergies. These are here because you cannot directly modify the attributes of the class. If you want to directly change variables belonging to the class outside of the class, you must use **properties**. To do this, just declare a variable in the class but not within a method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cat:\n",
    "    age = 0\n",
    "    \n",
    "some_cat = Cat()\n",
    "\n",
    "some_cat.age = 5\n",
    "\n",
    "print(some_cat.age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python classes, you may have noticed the **__init__()** method is very weird because of the two underscores on either side. This is because it is a Python method class and has special qualities. There are other methods that look like this and is unquie like;\n",
    "\n",
    "* __repr__ - prints the representation of the class\n",
    "* __str__ - returns a friendly string version of the class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The __repr__ will be used if you print the class with the **print()** function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tangentially related is the use of **__** (double underscore). In Python and many other languages, this means a private variable that should not be called on by the user unless this absolutely know what they are doing "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercise 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make a class of a cat with the attributes of name, weight, age, and height. Make methods to change any of the 2 attributes to the cat and methods to get any of the 2 attributes changed. Also make a random method of your choice (have fun with this)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code below\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 6 Answer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get input\n",
    "number = input(\"Enter a number: \").strip()\n",
    "\n",
    "try:\n",
    "    # tries to get the integer of number\n",
    "    number = int(number)\n",
    "except Exception:\n",
    "    # if it fails, try to get the number as a float\n",
    "    try:\n",
    "        number = float(number)\n",
    "    except Exception:\n",
    "        # if that fails, the input is neither int or float, therefore, not a number\n",
    "        print(\"The input is not a number, try again\")"
   ]
  }
 ],
 "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.2"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}