{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>12. Defining Classes And More...</h1>\n",
    "<h2>10/27/2023</h2>\n",
    "\n",
    "<h2>12.0 Last Time...</h2>\n",
    "<ul>\n",
    "    <li><b>Objects</b> have attributes and methods associated with them that can be listed using <b>dir()</b>.</li>\n",
    "    <li>Methods for strings include <b>upper()</b>, <b>isupper()</b>, <b>count()</b>, <b>title()</b>, etc.</li>\n",
    "    <li>Methods for arrays include <b>reshape()</b>, <b>ravel()</b>, <b>round()</b>, etc.</li>\n",
    "</ul>\n",
    "\n",
    "<h2>12.1 Defining A Class: The Theory</h2>\n",
    "\n",
    "We talked about how all objects are instances of a class. Using <b>dir()</b> in the previous lecture, we saw the list of attributes and methods for the <b>string</b> and <b>array</b> classes. But just as you sometimes want to create your own functions depending on your application, sometimes you want to create your own classes!\n",
    "\n",
    "This is going to get a little abstract, so bear with me while we go through this in text form - we'll soon be looking and writing plenty of our own examples! This is complex and a little hard to think about because we're actually messing with the way Python works at a more fundamental level rather than just applying it.\n",
    "\n",
    "Similar to the <b>def</b> statement for functions, creating a new class involves a <b>class</b> statement. The indented block after this class statement constitutes the definition of the class.\n",
    "\n",
    "Inside your definition, to make life easier, you just refer to the instance of the class as <b>self</b>. For example, if you want an attribute called <b>data</b>, within the class definition it will be called <b>self.data</b>.\n",
    "\n",
    "Methods are defined the same way we've been talking about functions: with a <b>def</b> statement. Each method will have a set of arguments, just the way functions normally do. The first argument in a method when defining a new class is generally going to just be the word <b>self</b>, which essentially means \"take everything we have thus far and make use of it in what follows\". This is an argument you won't have to type in when you're actually <i>using</i> the method; it's just for behind-the-scenes work.\n",
    "\n",
    "Typically, your first method will be called <b>\\_\\_init\\_\\_</b> (remember, the double-underscores indicate a fundamental method in a given class!). Every time you create an instance of your new class (for example, every time you create a string as an instance of the string class), this \\_\\_init\\_\\_ method will be called. \"Init\" stands for \"initialization\"; this is where you put any important information you'll need when creating a new instance of a class. \n",
    "\n",
    "Okay, this has been a lot. Let's see it in action!\n",
    "\n",
    "<h2>12.2 Defining A Class: The Code</h2>\n",
    "\n",
    "Let's define a class that's called simply <b>Book</b>.\n",
    "\n",
    "If we have a bunch of information associated with a book (its author, publisher, title, etc.), we can store it as an instance of the class Book. Rather than having it be a string or a list or a dictionary, it will just be called a Book. We can then come up with some helpful methods that will define what we can do to Books.\n",
    "\n",
    "Let's start our class definition. We use the word <b>class</b>, followed by the name of our class (by convention, they're typically capitalized). We then put the word <b>object</b> in parentheses; this argument is a special object that just identifies this as a class that doesn't depend on other classes. For the purposes of this course, just remember: a class definition should have the argument <b>object</b>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Book(object):\n",
    "        \n",
    "    # We'll start by defining the method __init__.\n",
    "    # Its arguments are self, the Author's last and first names, the\n",
    "    # title, the place, the publisher, and the year.\n",
    "    def __init__(self, authlast, authfirst, title, place, publisher, year):\n",
    "            \n",
    "        \n",
    "        # We then set the convention for the rest of our class definition:\n",
    "        # the name of the object, followed by a dot, followed by\n",
    "        # the names of our various arguments.\n",
    "        self.authlast = authlast\n",
    "        self.authfirst = authfirst\n",
    "        self.title = title\n",
    "        self.place = place\n",
    "        self.publisher = publisher\n",
    "        self.year = year\n",
    "        \n",
    "    # Let's create a second method that will write a bibliography entry.\n",
    "    def write_bib_entry(self):\n",
    "            \n",
    "    # We won't need any additional arguments here, since it's all handled above.\n",
    "        return self.authlast + ',' + self.authfirst + ',' + self.title + ',' + self.place + ',' + self.publisher + ',' + self.year  \n",
    "\n",
    "\n",
    "        # We could create intermediate steps here, but let's just return the final answer.\n",
    "    # def make_authoryear(self):\n",
    "        # return self.authoryear + ' (' + self.year + ')'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have created our new class (<b>Book</b>), we can try creating some instances of the class!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Book object at 0x10dd78110>\n",
      "the evidential power of booty\n"
     ]
    }
   ],
   "source": [
    "booty = Book(\"Dubious\", \"Thomas\", \"the evidential power of booty\", \"sanfran\", \"lava press\", \"1999\")\n",
    "print(booty)\n",
    "print(booty.title)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2003\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getstate__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'authfirst',\n",
       " 'authlast',\n",
       " 'place',\n",
       " 'publisher',\n",
       " 'title',\n",
       " 'write_bib_entry',\n",
       " 'year']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "butt = Book(\"martelli\",\"alex\",\"py in nutshell\",\"place in CA\", \"autoparts\",\"2003\")\n",
    "print(butt.year)\n",
    "dir(butt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's pretty useful! Let's do a few exercises...\n",
    "\n",
    "<h2>12.3 Book Class Exercises</h2>\n",
    "\n",
    "After running the code above, answer the following questions:\n",
    "\n",
    "<b>1. How would you print out the authorfirst attribute of the pynut instance?</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Thomas\n"
     ]
    }
   ],
   "source": [
    "print(booty.authfirst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>2. How would you print the full bibliography entry for the beauty instance?</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dubious,Thomas,the evidential power of booty,sanfran,lava press,1999\n"
     ]
    }
   ],
   "source": [
    "print(booty.write_bib_entry())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>3. How would you change the publication year for the beauty instance to \"2010\"?</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2010\n"
     ]
    }
   ],
   "source": [
    "booty.year = \"2010\"\n",
    "print(booty.year)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>12.4 Further Class Exercises</h2>\n",
    "\n",
    "<b>1. Create another instance of the Book class using a book of your choosing (or get creative and make something up!). Check to make sure it looks okay using the write_bib_entry() method.</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "butt,booty,balls,leftcheek,rightcheek,9090\n"
     ]
    }
   ],
   "source": [
    "ass = Book(\"butt\", \"booty\", \"balls\", \"leftcheek\", \"rightcheek\", \"9090\")\n",
    "print(ass.write_bib_entry())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>2. Add a method called make_authoryear to the class definition. This method will create an attribute called authoryear and will set it to a string composed of the author's name followed by the year of publication in parentheses: </b>Dubay (1999)<b>, for instance. This method should not have a return statement, but should instead use a line starting with </b>self.authoryear = <b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>12.5 Take-Home Points</h2>\n",
    "<ul>\n",
    "    <li>A class can be created using a <b>class</b> statement followed by the name of the class.</li>\n",
    "    <li>Methods within a class definition are created using a <b>def</b> statement.</li>\n",
    "    <li><b>__init__</b> is typically the first method defined and is used to initialize the core features of the class.</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}