DS109-Python/DS109-L6-Classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "50e6ddbb-52d3-4a02-9b69-100a4181e3b0",
   "metadata": {},
   "source": [
    "# DS109 Python : Lesson Six Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1bd4bfc-9b15-4b80-87b4-b8b60eb56371",
   "metadata": {},
   "source": [
    "### Table of Contents <a class=\"anchor\" id=\"DS109L6_toc\"></a>\n",
    "\n",
    "* [Table of Contents](#DS109L6_toc)\n",
    "    * [Page 1 - Overview and Setup](#DS109L6_page_1)\n",
    "    * [Page 2 - Classes](#DS109L6_page_2)\n",
    "    * [Page 3 - Creating an Instance of a Class](#DS109L6_page_3)\n",
    "    * [Page 4 - Creating and Accessing Class Properties and Methods of a Class](#DS109L6_page_4)\n",
    "    * [Page 5 - Another Class Example](#DS109L6_page_5)\n",
    "    * [Page 6 - Key Terms](#DS109L6_page_6)\n",
    "    * [Page 7 - Classes Activity Part 1](#DS109L6_page_7)\n",
    "    * [Page 8 - Classes Activity Part 2](#DS109L6_page_8)\n",
    "    * [Page 9 - Lesson 6 Hands-On ](#DS109L6_page_9)\n",
    "   \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef5a8c65-ed48-4354-a257-e01b0fd733d4",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 1 - Overview and Setup<a class=\"anchor\" id=\"DS109L6_page_1\"></a>\n",
    "\n",
    "[Back to Top](#DS109L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0b6b7be4-7f8e-447b-aa2f-2b8484932d0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"720\"\n",
       "            height=\"480\"\n",
       "            src=\"https://player.vimeo.com/video/238447665\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.VimeoVideo at 0x7fc1a06316a0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import VimeoVideo\n",
    "# Tutorial Video Name: Object Oriented Programming\n",
    "VimeoVideo('238447665', width=720, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b6ad526-95fa-43c4-bc43-1fe807708ed3",
   "metadata": {},
   "source": [
    "Now that you understand variables, functions, and scope, you're ready to proceed and learn about object-oriented programming, or OOP. This type of programming involves the use of _classes_, which are definitions of objects that make up your system, like users, game levels, and other entities. Classes have properties and operations, which are implemented using variables and functions. In this lesson, you will learn how to create and use classes in your Python applications.\n",
    "\n",
    "Below you will find the keywords related to classes that are relevant to this lesson. You will learn more about each as you progress through this lesson.\n",
    "\n",
    "---\n",
    "\n",
    "## Setup\n",
    "\n",
    "1. First, open up your command prompt/terminal\n",
    "2. Now that you are in your command prompt/terminal, run the following command:\n",
    "    ```text\n",
    "    cd desktop\n",
    "    ```\n",
    "3. Next, move your command prompt/terminal's location to the new `python_course` you just created by running the following:\n",
    "    ```text\n",
    "    cd python_course\n",
    "    ```\n",
    "4. Create a _new_ directory within the `python_course` directory. This new folder is the project you will be working in for this lesson. Run the following:\n",
    "    ```text\n",
    "    mkdir lesson_six\n",
    "    ```\n",
    "5. Open up a new window in VSCode.\n",
    "6. The first thing you should see a Welcome page. You can close this window.\n",
    "7. Now, its time to open the `lesson_six` directory. Click on the \"Explorer\" button on the left-hand side of the VSCode window.\n",
    "8. You will now see a button that says `Open Folder`, as shown below. Click this button.\n",
    "9. A new window will open that will allow you to search for files and folders. Locate the `python_course` folder you just created on your Desktop. Click on that folder and then locate the `lesson_six` folder. Select the `lesson_six` directory and click the `Open` button.\n",
    "10. Create a new file named `main.py` by one of the following three ways:\n",
    "    - To the right of __LESSON_SIX__ in the EXPLORER is a button that looks like a piece of paper with a plus symbol in its top-left corner. If you hover your mouse over this button for a moment, a popup will appear indicating that this button will create a new file.\n",
    "    - Choose `File > New File` from the app's menu.\n",
    "    - Press `Control + N` in Windows or `Command + N` on a Mac (the plus means \"and at the same time\").\n",
    "\n",
    "Once the `main.py` file is created, you are ready to go! As you work through this lesson, add the code examples into your project so you can see the output yourself. Remember, to see the output within the VSCode terminal, right-click within your file and choose \"Run Python File in Terminal\".\n",
    "\n",
    "The creation of this new project is for you to practice your new skills. It is highly recommended that you add the code from this lesson into your `lesson_six` project as you learn it. As you are going through this lesson and adding code to your project, you may find it helpful to include `comments` with a brief sentence explaining what is going on in the code. That way, you will have an easy reference to the topics explained in this lesson. Happy coding!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7990ac7a-5a2f-4744-af14-1b7e385ea484",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 2 - Classes<a class=\"anchor\" id=\"DS109L6_page_2\"></a>\n",
    "\n",
    "[Back to Top](#DS109L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "612429df-e4ef-4d85-8460-5bc8914079c3",
   "metadata": {},
   "source": [
    "# Classes\n",
    "\n",
    "A `class` can be described as a blueprint; it describes how to make something and what it does. Classes bundle data and functionality that are related to objects of that type. For instance, a _Person_ class may have properties for age and name and methods for saving or contacting. When you create an object defined by a class, you are essentially creating an entirely new data type.\n",
    "\n",
    "Below you will see the general syntax used when creating a class. Each piece has a numbered comment that is discussed below.\n",
    "\n",
    "```python\n",
    "# 1. `class` keyword followed by the name of the class and a colon\n",
    "class ClassName:\n",
    "    # 2. Classes have a docstring just like functions\n",
    "    \"\"\"DocString\"\"\"\n",
    "    # 3. Classes have properties and methods\n",
    "```\n",
    "\n",
    "1. To define a class, you first start with the `class` keyword, followed by the name you wish to give to your class, and finally a colon `:`.\n",
    "\n",
    "2. Just like functions, a class also has a __docstring__ that expresses the purpose of the class. As before, docstrings are preceded and terminated with triple quotes.\n",
    "\n",
    "3. At this point, you begin defining the properties (variables) and methods (functions) of the class.\n",
    "\n",
    "Now that you've seen the general syntax for a class, take a look at the concrete example below, which implements a class named `Dog`. The example code has numbered comments that will be discussed below.\n",
    "\n",
    "```python\n",
    "# 1. Define the class `Dog`\n",
    "class Dog:\n",
    "    # 2. The docstring for the `Dog` class\n",
    "    \"\"\"The summary docstring for the Dog class. This class represents a Dog.\"\"\"\n",
    "\n",
    "    # 3. The initializer of the class, where the class properties are initialized\n",
    "    def __init__(self, name, age):\n",
    "        # 4. Class methods, including the initializer, should have a docstring\n",
    "        \"\"\"Initialize attributes to describe a Dog.\"\"\"\n",
    "\n",
    "        # 5. Below are the properties of the `Dog` class, each with it's own docstring\n",
    "        self.name = name    #: The `name` property represents the dog's name\n",
    "        self.age = age      #: The `age` property represents the dog's age\n",
    "\n",
    "    # 6. Two methods, `stay` and `sit`, are defined for the `Dog` class\n",
    "    def sit(self):\n",
    "        \"\"\"Simulates a dog sitting on command.\"\"\"\n",
    "        print(self.name.title() + \" is sitting.\")\n",
    "\n",
    "    def stay(self):\n",
    "        \"\"\"Simulates a dog that will stay on command.\"\"\"\n",
    "        print(self.name.title() + \" was told to stay.\")\n",
    "```\n",
    "\n",
    "You'll find a discussion on each numbered comment below. First, though, take note of the indentation of the class. The docstring and all methods are indented, and the contents of each method are indented another level.\n",
    "\n",
    "1. Just like you saw with the generic class example, the `Dog` class is defined using the `class` keyword, the name of the class (`Dog`), and a colon `:`. Class names should be capitalized.\n",
    "\n",
    "2. The first part of a class is its docstring, which summarizes the purpose of the class.\n",
    "\n",
    "3. The `__init__` method (function) of a class is used to set its initial state for its properties. In this case, there are two properties: `name` and `age`. This `__init__` method will be discussed in more detail later.\n",
    "\n",
    "4. All methods of a class should have a docstring, indicating their purpose. You will find a docstring for the `__init__`, `stay`, and `sit` methods.\n",
    "\n",
    "5. The instance variables of this class are initialized, using the parameters of the `__init__` method. The property variables that are used for this class should all be initialized within this method. There is no formal definition of the properties elsewhere. As you can see in the example, properties can, and should, also have associated docstrings.\n",
    "\n",
    "6. The `Dog` class has two methods: `sit` and `stay`. Methods are functions and can have zero or more parameters like standalone functions. All methods should have a docstring.\n",
    "\n",
    "---\n",
    "\n",
    "## __init__()\n",
    "\n",
    "The `__init__()` method is a special initialization method Python will run automatically whenever you create a new instance based on the class. Notice that this method has two leading and two trailing underscores `__`; this prevents Python's default method names from conflicting with your method names.\n",
    "\n",
    "Inside of the `__init__` method is where you need to initialize the property variables for instances of the class. In the above example, `name` and `age` are the two properties of the `Dog` class, and both are initialized to the values passed into the `__init__` method (you'll see how this works shortly). However, not all properties of a class require that they be initialized from a parameter of the initializer; they can be initialized to zero (0) for example, which would not require a parameter.\n",
    "\n",
    "As you can see in the above example, the parameters to the `__init__` method have the same name as the class properties: `name` and `age`. So, how does the interpreter know which is which? By use of the `self` keyword, which is the very first parameter of the method.\n",
    "\n",
    "---\n",
    "\n",
    "## self\n",
    "\n",
    "The first parameter of _every_ method of a class should be `self`; it must precede all other parameters. `self` refers to the instance of the class and is used to access the property variables and methods of a class internally. When you create an instance of a class or call a method on it, you do __not__ pass in the value for _self_ as an argument; Python does this for you behind the scenes.\n",
    "\n",
    "`self` is used to access the instance's member variables and methods from within the code of the class. You will not find the use of `self` _outside_ of the class. In the example above, within the `__init__` method, you see that the class's instance variables are initialized to the values of the same-named parameter variables. The distinction lies in the `self.` prefix before the class variables.\n",
    "\n",
    "```python\n",
    "self.name = name    #: The `name` property represents the dog's name\n",
    "self.age = age      #: The `age` property represents the dog's age\n",
    "```\n",
    "\n",
    "Above, the interpreter knows that you mean the class properties `name` and `age` when you prefix them with `self`. This is why the function parameters can have the same name as the property variables.\n",
    "\n",
    "If you look at the implementations of the `sit` and `stay` methods, you'll see that both print to the console the name of the dog along with some other text. The name of the dog &mdash; an instance variable of the class &mdash; are accessed using `self` again. In order to access any instance property/variable of a class, you must prefix it with `self` and a dot `.`.\n",
    "\n",
    "You've learned quite a bit in a short amount of time, so don't fret if you don't understand it all or feel you'll forget. You will continue to see more examples as you progress through this lesson in order to help you grasp classes and their use. In the next section, you'll learn how to create an instance of a class.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "832358fd-55fa-420a-8aa2-46fbf2097986",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 3 - Creating an Instance of a Class<a class=\"anchor\" id=\"DS109L6_page_3\"></a>\n",
    "\n",
    "[Back to Top](#DS109L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f564e3e7-3a7f-4936-b3a3-2e0a9ab78512",
   "metadata": {},
   "source": [
    "# Creating an Instance of a Class\n",
    "\n",
    "Now that you know that a _class_ is used as a blueprint and how to define one, it's time to actually create an object that is an instance of the class. When you create an instance of a class, the format is as follows:\n",
    "\n",
    "```python\n",
    "my_variable = MyClass(param1, param2)\n",
    "```\n",
    "\n",
    "The above assumes the `MyClass` class has an `__init__` method with two parameters 'param1' and 'param2'. There could be more; there could be fewer. And, as you can see above, nothing was passed in for the required `self` parameter.\n",
    "\n",
    "Now, using the `Dog` example class, the following code will create an instance of `Dog` (the definition of the `Dog` class has been included for your convenience):\n",
    "\n",
    "```python\n",
    "class Dog:\n",
    "    \"\"\"The summary docstring for the Dog class. This class represents a Dog.\"\"\"\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        \"\"\"Initialize attributes to describe a Dog.\"\"\"\n",
    "        self.name = name    #: The `name` property represents the dog's name\n",
    "        self.age = age      #: The `age` property represents the dog's age\n",
    "\n",
    "    def sit(self):\n",
    "        \"\"\"Simulates a dog sitting on command.\"\"\"\n",
    "        print(self.name.title() + \" is sitting.\")\n",
    "\n",
    "    def stay(self):\n",
    "        \"\"\"Simulates a dog that will stay on command.\"\"\"\n",
    "        print(self.name.title() + \" was told to stay.\")\n",
    "\n",
    "# create two separate instances of `Dog`\n",
    "fido = Dog('Fido', 5)\n",
    "spot = Dog('Spot', 7)\n",
    "```\n",
    "\n",
    "Above, two separate instances of the `Dog` class are created:\n",
    "\n",
    "```python\n",
    "fido = Dog('Fido', 5)\n",
    "spot = Dog('Spot', 7)\n",
    "```\n",
    "\n",
    "Above, `fido` and `spot` are objects; they are instances of the `Dog` class. They are not the same object. `fido` was created with a name of 'Fido' and an age of 5, while `spot` was created with a name of `Spot` and an age of 7. If you were to change the values of one instance, it would not affect the other. Only class variables are shared between instances (you'll see this later).\n",
    "\n",
    "Ultimately, when you create an instance of a class, you are calling the `__init__` method of the class. However, you use the name of the class in lieu of the of the method name.\n",
    "\n",
    "---\n",
    "\n",
    "## Accessing Properties of a Class Instance\n",
    "\n",
    "In order to access properties of a class from _within_ the class (methods of the class), you need to prefix them with `self`. However, when accessing them from outside of the definition of the class, you precede them with the instance variable. Take a look at the code below:\n",
    "\n",
    "```python\n",
    "# `Dog` class defined here\n",
    "# ...\n",
    "\n",
    "# create two instances of `Dog`\n",
    "fido = Dog('Fido', 5)\n",
    "spot = Dog('Spot', 7)\n",
    "\n",
    "# print the name and age of each instance\n",
    "print(\"The name of the dog is\", fido.name, \"and the age is\", fido.age)\n",
    "print(\"The name of the dog is\", spot.name, \"and the age is\", spot.age)\n",
    "\n",
    "# change fido's age and print both again\n",
    "fido.age = 9\n",
    "\n",
    "print(\"The name of the dog is\", fido.name, \"and the age is\", fido.age)\n",
    "print(\"The name of the dog is\", spot.name, \"and the age is\", spot.age)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "The name of the dog is Fido and the age is 5\n",
    "The name of the dog is Spot and the age is 7\n",
    "The name of the dog is Fido and the age is 9\n",
    "The name of the dog is Spot and the age is 7\n",
    "```\n",
    "\n",
    "Look closely at the code above. In the first block, two instances of the `Dog` class are created like you saw earlier. In the next block, information is printed to the console showing the `name` and `age` of each instance. If you look at one of them, you'll see how the properties of the instance are accessed:\n",
    "\n",
    "```python\n",
    "print(\"The name of the dog is\", fido.name, \"and the age is\", fido.age)\n",
    "```\n",
    "\n",
    "As you can see, the properties of the `fido` instance of `Dog` are accessed by prefixing the property name with the name of the instance variable: `fido`.\n",
    "\n",
    "```python\n",
    "fido.name\n",
    "fido.age\n",
    "```\n",
    "\n",
    "In the third block of code, the `age` property of the `fido` instance is changed to `9`. When both instances are printed to the console again, you'll see that _fido's_ age was successfully changed, but the age of _spot_ remained the same! This is because they are two separate and distinct objects.\n",
    "\n",
    "---\n",
    "\n",
    "## Accessing Methods of a Class Instance\n",
    "\n",
    "Just like accessing properties of an instance, you only need to prefix the method's name with that of the instance. Take a look at the code below, which extends the previous example by calling the `sit` and `stay` methods of the `Dog` class on each instance.\n",
    "\n",
    "```python\n",
    "# `Dog` class defined here\n",
    "# ...\n",
    "\n",
    "# create two instances of `Dog`\n",
    "fido = Dog('Fido', 5)\n",
    "spot = Dog('Spot', 7)\n",
    "\n",
    "# tell both to sit and stay\n",
    "fido.sit()\n",
    "fido.stay()\n",
    "spot.sit()\n",
    "spot.stay()\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "Fido is sitting.\n",
    "Fido was told to stay.\n",
    "Spot is sitting.\n",
    "Spot was told to stay.\n",
    "```\n",
    "\n",
    "As you can see above, the two function `sit` and `stay` of the `Dog` class (called _methods of the class_), both print out to the console the dog's name and the action that was performed. Even though the definition of each class method has the `self` parameter, neither are provided when calling the function on the instance; Python does this for you.\n",
    "\n",
    "Great! Now you know how to create instances of a class and access its properties and methods. You also know that you need to use `self` within the definition of the class to access the instance properties; and to access them from outside of the code, you use the instance variable name instead.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb1aade2-59af-4cbc-b5ed-da31e39f266d",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 4 - Creating and Accessing Class Properties and Methods of a Class<a class=\"anchor\" id=\"DS109L6_page_4\"></a>\n",
    "\n",
    "[Back to Top](#DS109L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eba2ed6e-98dd-43f7-8761-6ecc9a13af08",
   "metadata": {},
   "source": [
    "# Creating and Accessing Class Properties and Methods of a Class\n",
    "\n",
    "Sometimes, you will need to define properties and methods of a class that apply to _all_ instances of the class. These are called _class properties_ and _class methods_. Sometimes, you'll hear people refer to them as _static_ properties and methods, as they don't change from instance to instance.\n",
    "\n",
    "---\n",
    "\n",
    "## Class Properties\n",
    "\n",
    "Take a look at the example below; the numbered comments will be discussed.\n",
    "\n",
    "```python\n",
    "class Cat:\n",
    "    \"\"\"This class represents a cat.\"\"\"\n",
    "\n",
    "    # 1. This is a class variable that is shared by ALL instances of the class\n",
    "    sound_made = 'Meow'\n",
    "\n",
    "    # 2. The class initialization method\n",
    "    def __init__(self, name):\n",
    "        \"\"\"Initializer of Cat class\"\"\"\n",
    "        self.name = name    #: The name of the Cat instance\n",
    "\n",
    "    # 3. this method prints out the class variable `sound_made`\n",
    "    def say_something(self):\n",
    "        \"\"\"Speak!\"\"\"\n",
    "        print(self.name, \"says\", Cat.sound_made)\n",
    "\n",
    "# 4. create two Cat instances\n",
    "mittens = Cat('Mittens')\n",
    "feather = Cat('Feather')\n",
    "\n",
    "# 5. call `say_something` method on each\n",
    "mittens.say_something()\n",
    "feather.say_something()\n",
    "\n",
    "# 6. change the value of the class variable\n",
    "Cat.sound_made = 'Woof'\n",
    "\n",
    "# 7. call `say_something` again for each instance after the change\n",
    "mittens.say_something()\n",
    "feather.say_something()\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "Mittens says Meow\n",
    "Feather says Meow\n",
    "Mittens says Woof\n",
    "Feather says Woof\n",
    "```\n",
    "\n",
    "In the example above, the `Cat` class was defined:\n",
    "\n",
    "1. The `sound_made` property variable is __shared__ between all instances of the `Cat` class. _Class properties_ are declared _outside_ of the methods. Instance variables are declared _inside_ the initializer.\n",
    "\n",
    "2. The initializer for the `Cat` class has only one property (remember, `self` is required for _all_ methods and the value for it is provided for you). When creating an instance of the `Cat` class, only the `name` property is specified.\n",
    "\n",
    "3. In the `say_something` method, a message is printed to the console using the instance's `name` and the class property `sound_made`. Do you see how the class variable is accessed here? Instead of using `self`, like you do with instance variables, class variables are prefixed with the name of the class: `Cat.sound_made`. This is because the value is not associated with a specific instance; it is associated with _all_ instances.\n",
    "\n",
    "4. Two instances of the `Cat` class are created, both providing the name of the cat.\n",
    "\n",
    "5. The `say_something` method of each instance is called. If you look in the output, you'll see that both instances say \"Meow\", because each instance shares the class variable `sound_made`.\n",
    "\n",
    "6. This code changes the class variable's value to \"Woof\". This will affect _all_ instances, unlike changing an instance variable which will only impact that instance.\n",
    "\n",
    "7. Again, the `say_something` method of each instance is called. This time, however, you will see in the output that both instances now say \"Woof\" instead of \"Meow\".\n",
    "\n",
    "To help you distinguish between an instance and class property (or variable), take a look at the block of code below. Some of the details are omitted (e.g. docstrings), because it's meant to highlight the differences:\n",
    "\n",
    "```python\n",
    "class Cat:\n",
    "    class_var = \"I am a class variable\"\n",
    "\n",
    "    def __init__(self, instance_var):\n",
    "        self.instance_var = instance_var\n",
    "\n",
    "    def print_properties(self):\n",
    "        print(\"My class property value is\", Cat.class_var)\n",
    "        print(\"My instance property value is\", self.instance_var)\n",
    "\n",
    "my_cat = Cat('Whiskers')\n",
    "my_cat.print_properties()\n",
    "\n",
    "print(Cat.class_var)\n",
    "print(my_cat.instance_var)\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "My class property value is I am a class variable\n",
    "My instance property value is Whiskers\n",
    "I am a class variable\n",
    "Whiskers\n",
    "```\n",
    "\n",
    "Here are the distinctions:\n",
    "\n",
    "- __Class variables__ are declared _outside_ of the methods of the class, whereas __instance variables__ are defined _within_ the `__init__` method of the class.\n",
    "\n",
    "- __Class variables__ are shared between _all_ instances of the class, whereas __instance variables__ are unique to each instance of the class.\n",
    "\n",
    "- __Class variables__ are accessed by preceding them with the name of the class both inside of the methods of the class and outside of the class. __Instance variables__ are accessed using the `self` keyword within the methods of the class and the name of the instance outside of the class.\n",
    "\n",
    "Great! Now you know about class variables/properties in addition to instance properties. Next, you'll see how methods can also be class methods instead of instance methods.\n",
    "\n",
    "---\n",
    "## Class Methods\n",
    "\n",
    "Like class variables, class methods are not specific to an instance of a class; they are static. They are generally used in a scenario where a method is required to perform some operation, but doesn't require a specific instance to perform its tasks.\n",
    "\n",
    "When creating class methods, you create them identically to any other method, except that you prefix the method's definition with `@staticmethod`.\n",
    "\n",
    "Like with class variables, accessing a class (or static) method of a class involves prefixing it with the name of the class.\n",
    "\n",
    "Take a look at the example below, where a new class `Duck` is created with two methods: one instance method and one class method. The relevant pieces have numbered comments that will be discussed.\n",
    "\n",
    "```python\n",
    "class Duck:\n",
    "    \"\"\"This class represents a duck.\"\"\"\n",
    "\n",
    "    # 1. Class variable available to all instances\n",
    "    sound_made = \"quack\"\n",
    "\n",
    "    def __init__(self, name):\n",
    "        \"\"\"Duck initializer\"\"\"\n",
    "        self.name = name\n",
    "\n",
    "    # 2. Instance method for saying something ('what')\n",
    "    def say(self, what):\n",
    "        \"\"\"The instance says 'what'\"\"\"\n",
    "        print(self.name, \"says\", what)\n",
    "\n",
    "    # 3. Class method for speaking the sound all ducks make\n",
    "    @staticmethod\n",
    "    def speak():\n",
    "        \"\"\"The class says sound_made\"\"\"\n",
    "        print(\"Ducks say\", Duck.sound_made)\n",
    "\n",
    "# 4. Calling the class method\n",
    "Duck.speak()\n",
    "\n",
    "# 5. Creating an instance and calling the instance method\n",
    "daffy = Duck('Daffy')\n",
    "daffy.say('Hello')\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "Ducks say quack\n",
    "Daffy says Hello\n",
    "```\n",
    "\n",
    "Taking a look at the numbered comments above:\n",
    "\n",
    "1. You've already seen class variables. This is the same class variable that was used in the previous example, representing the sounds that all ducks made. This variable is shared by all instances of the `Duck` class.\n",
    "\n",
    "2. The `say` method, in addition to the required `self` parameter, has a single parameter named `what` that is used to print to the console along with the `name` of the instance. This method can only be called on an instance of the class and requires `self` if accessed within other methods of the class.\n",
    "\n",
    "3. The `speak` method is a _class method_; it is prefixed with the `@staticmethod` adornment/qualifier. This method is __not__ accessed from an instance; instead, it is accessed at the class level (as seen in #4). Did you notice that there is __not__ a `self` as part of the parameters? This is because it would make no sense, since _self_ represents an instance, and class methods are instance-independent.\n",
    "\n",
    "4. Instances are not used to access a class/static method of a class. Class methods, like class variables, are accessed using the name of the class as the prefix.\n",
    "\n",
    "5. Here, an instance of the `Duck` class is created, and the instance method `say` is called.\n",
    "\n",
    "There you have it! Now you know how to:\n",
    "\n",
    "- Define a class, along with its properties, methods, and required docstrings.\n",
    "- Create instances of a class\n",
    "- Create and access instance and class properties\n",
    "- Create and access instance and class methods\n",
    "\n",
    "Classes and object-oriented programming in Python is a very important subject to learn. You learned about the building blocks first: variables and functions. You learned that classes are essentially named objects that contain variables and functions. Hopefully, you were able to follow along and understand, but to help, the next section will have a more robust example with a discussion.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ead4ad3c-2fe6-457e-8924-1410e951bebd",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 5 - Another Class Example<a class=\"anchor\" id=\"DS109L6_page_5\"></a>\n",
    "\n",
    "[Back to Top](#DS109L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbbc06a2-e702-47a1-942f-cbcbe31221a7",
   "metadata": {},
   "source": [
    "Another Class Example\n",
    "\n",
    "Below is another example of using a class. It contains both class and instance properties and methods. You will find a discussion highlighting the code following the example.\n",
    "\n",
    "```python\n",
    "# 1. Define the `Student` class\n",
    "class Student:\n",
    "    \"\"\"This models a student\"\"\"\n",
    "\n",
    "    # 2. Class variable - array of Student instances\n",
    "    students = []   #: Class var to hold all students\n",
    "\n",
    "    # 3. Initializer for two instance properties: name and grade\n",
    "    def __init__(self, name, grade):\n",
    "        \"\"\"Initializer of class\"\"\"\n",
    "        self.name = name    #: Instance var for student name\n",
    "        self.grade = grade  #: Instance var for student grade\n",
    "\n",
    "    # 4. Instance method to display information about a student\n",
    "    def display(self):\n",
    "        \"\"\"Instance method to display student info\"\"\"\n",
    "        print(\"Name:\", self.name, \", Grade:\", self.grade)\n",
    "\n",
    "    # 5. Class method to add a student instance to class array `students`\n",
    "    @staticmethod\n",
    "    def add_student(student):\n",
    "        \"\"\"Class method for adding a student to the class var\"\"\"\n",
    "        Student.students.append(student)\n",
    "\n",
    "    # 6. Class method to call the `display` method for all students\n",
    "    @staticmethod\n",
    "    def display_students():\n",
    "        \"\"\"Class method for printing all students\"\"\"\n",
    "        for student in Student.students:\n",
    "            student.display()\n",
    "\n",
    "# 7. create an instance of `Student` and print info\n",
    "bill = Student('Bill', 'Freshman')\n",
    "bill.display()\n",
    "\n",
    "# 8. create another instance of `Student` and print info\n",
    "sally = Student('Sally', 'Junior')\n",
    "sally.display()\n",
    "\n",
    "# 9. add both students to student array which is a class var\n",
    "#    using the class method `add_student`\n",
    "Student.add_student(bill)\n",
    "Student.add_student(sally)\n",
    "\n",
    "# 10. call class method `display_students` to print info\n",
    "#     for all added students\n",
    "print('--------')\n",
    "Student.display_students()\n",
    "```\n",
    "\n",
    "**OUTPUT**:\n",
    "\n",
    "```\n",
    "Name: Bill , Grade: Freshman\n",
    "Name: Sally , Grade: Junior\n",
    "--------\n",
    "Name: Bill , Grade: Freshman\n",
    "Name: Sally , Grade: Junior\n",
    "```\n",
    "\n",
    "The above code is broken down into numbered comments:\n",
    "\n",
    "1. A class named `Student` is defined along with its docstring. Don't forget the colon!\n",
    "\n",
    "    ```python\n",
    "    class Student:\n",
    "        \"\"\"This models a student\"\"\"\n",
    "    ```\n",
    "\n",
    "2. A class variable named `students` is defined. It is an array that is meant to contain instances of the `Student` class. Class/static variables are defined __outside__ of the methods. This variable is initialized to an empty array (`= []`).\n",
    "\n",
    "    ```python\n",
    "    students = []   #: Class var to hold all students\n",
    "    ```\n",
    "\n",
    "3. Class initializers all take the same format: `__init__(param1, param2, ...):`. It is a method, and like all methods it should have a docstring describing its purpose. This initializer, in addition to the required `self` parameter, has two parameters for the student's name and grade. In the implementation of the initializer, the instance variables `name` and `grade` are set to the values of the parameters. Accessing instance variables within the code of the class requires the use of the `self` keyword. E.g. `self.name = name`.\n",
    "\n",
    "    ```python\n",
    "    def __init__(self, name, grade):\n",
    "        \"\"\"Initializer of class\"\"\"\n",
    "        self.name = name    #: Instance var for student name\n",
    "        self.grade = grade  #: Instance var for student grade\n",
    "    ```\n",
    "\n",
    "4. The `display` method is an instance method. It can only be called on an instance of the `Student` class. Like _all_ instance methods, this method requires the `self` parameter as the first parameter. This particular instance method does not have any other parameters. As you can see in its implementation, this method prints the properties of the instance, using `self` to access them.\n",
    "\n",
    "    ```python\n",
    "    def display(self):\n",
    "        \"\"\"Instance method to display student info\"\"\"\n",
    "        print(\"Name:\", self.name, \", Grade:\", self.grade)\n",
    "    ```\n",
    "\n",
    "5. The `add_student` method is a class, or static, method. It can only be called from the class, __not__ an instance. Class methods require the `@staticmethod` qualifier before the method's definition. Unlike instance methods, class methods do __not__ have the `self` parameter, because they do not operate on an instance. The sole parameter to this method &mdash; `student` &mdash; represents is meant to be an instance of a `Student` and stores it in the class property `students` (# 2). As you can see, the `students` array is accessed using the class's name instead of `self`. You should remember the `append` operation of a list from a previous lesson.\n",
    "\n",
    "    ```python\n",
    "    @staticmethod\n",
    "    def add_student(student):\n",
    "        \"\"\"Class method for adding a student to the class var\"\"\"\n",
    "        Student.students.append(student)\n",
    "    ```\n",
    "\n",
    "6. The `display_students` method is another class method. Like the `add_student` class method, it has the `@staticmethod` qualifier and does not contain `self` in its definition. When called, this method loops through the class variable `students` array and calls the `display` method of each instance, which then prints out each student's information.\n",
    "\n",
    "    ```python\n",
    "    @staticmethod\n",
    "    def display_students():\n",
    "        \"\"\"Class method for printing all students\"\"\"\n",
    "        for student in Student.students:\n",
    "            student.display()\n",
    "    ```\n",
    "\n",
    "7. This begins the block of code _after_ the class has been fully defined. In this block, an instance of the `Student` class is created, passing in `Bill` and `Freshman` as arguments to the initializer. These values are then assigned to the instance's properties `name` and `grade`. Once the instance has been created, the `display` instance method is then called to print out that student's information.\n",
    "\n",
    "    ```python\n",
    "    bill = Student('Bill', 'Freshman')\n",
    "    bill.display()\n",
    "    ```\n",
    "\n",
    "8. The above is repeated for another instance, this time for student `Sally`.\n",
    "\n",
    "    ```python\n",
    "    sally = Student('Sally', 'Junior')\n",
    "    sally.display()\n",
    "    ```\n",
    "\n",
    "9. In this block of code, the `add_student` class method is called twice. The newly instantiated `Student` objects `bill` and `sally` are passed in as a parameter to the method. As you can see, since `add_student` is a class method and not an instance method, it is access using the class name `Student` instead of the instance variable `bill` or `sally`. Calling this method will add both `bill` and `sally` to the class variable `students` array.\n",
    "\n",
    "    ```python\n",
    "    Student.add_student(bill)\n",
    "    Student.add_student(sally)\n",
    "    ```\n",
    "\n",
    "10. Finally, after a separator is printed to the console (to help with seeing the separation in the console), the `display_students` class method is called. As described in # 6, this method will loop through all `Student` instances stored in the `students` class variable, printing each out by calling the `display` instance method on each. Like in #9, the class method is called using the class name, not an instance variable.\n",
    "\n",
    "    ```python\n",
    "    print('--------')\n",
    "    Student.display_students()\n",
    "    ```\n",
    "\n",
    "Now you should have an understanding of what makes up classes and how to use them.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6f49d473-fdbc-40e5-9ddf-c16d0632221f",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    from DS_Students import MultipleChoice  \n",
    "except:\n",
    "    !pip install DS_Students\n",
    "    from DS_Students import MultipleChoice\n",
    "from ipynb.fs.full.DS109Questions import *"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18832592-62b8-439c-bfd8-a10c1f3e4278",
   "metadata": {},
   "source": [
    "```python\n",
    "Class dog:\n",
    "\n",
    "    \"\"\"Models a dog.\"\"\"\n",
    "\n",
    "\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "\n",
    "        \"\"\"Initialize attributes.\"\"\"\n",
    "\n",
    "        self.name = name\n",
    "\n",
    "        self.age = age\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c43f66ce-c646-43e7-9abf-dfd7907c9d86",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d66046c63b73438db26bd08c2389cb34",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '1. The syntax for creating a class is as shown abov…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6790cdb72a3444c4bb5006f2b51831a8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '2. You can create as many instances of a class as y…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "139014df50a8406f986fc501c9c6db6b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '3. The self parameter is not required in the __init…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "afa2edea3d7643f99d20d85433803784",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': '4. A class can be described as a ___________.\\n', '…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "26b7420698714653b404e2d88ef69cbd",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Output(outputs=({'name': 'stdout', 'text': \"5. In my_dog = Dog('Rover'), Dog is the class. What…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "try:\n",
    "    display(L6P5Q1, L6P5Q2, L6P5Q3, L6P5Q4, L6P5Q5)\n",
    "except:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd9e3b8a-9224-447f-8cf7-5035cae86421",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 6 - Key Terms<a class=\"anchor\" id=\"DS109L6_page_6\"></a>\n",
    "\n",
    "[Back to Top](#DS109L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81e2098-28ef-4ff5-a155-afe824de4323",
   "metadata": {},
   "source": [
    "# Key Terms\n",
    "\n",
    "<table class=\"table table-striped\">\n",
    "    <tr>\n",
    "        <th>Keyword</th>\n",
    "        <th>Description</th>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Class</td>\n",
    "        <td>A user-defined prototype of an object that defines a set of properties and operations that characterize an object of the class. These class properties and operations, which are called attributes and methods, are accessed via dot(<code>.</code>) notation.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Property</td>\n",
    "        <td> A class property, which is implemented as a variable, is what is used to maintain <i>state</i>. Classes often have multiple properties, or attributes, and they can take the form of class or instance properties.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Instance Property</td>\n",
    "        <td>A property of a class that is applicable only to objects of the class that have been created. A <i>Person</i> class could have instance properties such as <i>age</i>, <i>name</i>, and <i>address</i>.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Class Property</td>\n",
    "        <td>A property of a class that is shared by all objects of that class. These properties are not specific to a single instance of an object, but instead, represent properties that are common to all objects of that type.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Method</td>\n",
    "        <td>A function that is part of the definition of a class is called a <i>method</i>. These are the operations of a class, and like properties, there can be both instance and class methods.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Instance Method</td>\n",
    "        <td>A method of a class that is applicable only to objects of the class that have been created.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Class Method</td>\n",
    "        <td>A method of a class that is shared by all objects of that class. These methods are not specific to a single instance of an object, but instead, provide functionality that is more related to all objects of that type.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Instance</td>\n",
    "        <td>When an object of a class is created, it is an <i>instance</i> of that class. Some people simply refer to an instance as an object.</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td style=\"font-weight: bold;\" nowrap>Instantiation</td>\n",
    "        <td>The creation of an instance of a class.</td>\n",
    "    </tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42cb7d8a-aced-42e5-ac24-32acf8c95473",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 7 - Classes Activity Part 1<a class=\"anchor\" id=\"DS109L6_page_7\"></a>\n",
    "\n",
    "[Back to Top](#DS109L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf0debaf-5fae-4035-8e7d-ae62e62456cb",
   "metadata": {},
   "source": [
    "Given the `Person` class below, create a `Greeter` class with a single static method named `greet`. This method should:\n",
    "- Accept one parameter named `people` that is a list of `Person` objects.\n",
    "\n",
    "- Create a list of greetings (strings). There will be one greeting per person. Each should say `\"Hello FIRST LAST!\"`, where \"FIRST\" and \"LAST\" are replaced with the values from the person (`firstName` and `lastName`).\n",
    "\n",
    "- Return the array of greetings.\n",
    "\n",
    "For instance, if the input to the static `greet` method of the `Greeter` class were two people named \"Bill Barnes\" and \"Sally Smith\", the result would be an array of two Strings:\n",
    "```\n",
    "\"Hello Bill Barnes!\"\n",
    "\"Hello Sally Smith!\"\n",
    "```\n",
    "\n",
    "The `Person` class is defined as follows (you do not need to add this to your code):\n",
    "```python\n",
    "class Person:\n",
    "    \"\"\"This is a person\"\"\"\n",
    "\n",
    "    def __init__(self, firstName, lastName):\n",
    "        \"\"\"Initializer\"\"\"\n",
    "        self.firstName = firstName\n",
    "        self.lastName = lastName\n",
    "```\n",
    "\n",
    "\n",
    "\n",
    "```python\n",
    "class Greeter:\n",
    "    \"\"\" This is a greeter\"\"\"\n",
    "\n",
    "    @staticmethod\n",
    "    def greet(people):\n",
    "        \"\"\"Static method to greet a list of people\"\"\"\n",
    "        greetings = []\n",
    "        for person in people:\n",
    "            greeting = \"Hello \" + person.firstName + \" \" + person.lastName + \"!\"\n",
    "            greetings.append(greeting)\n",
    "        return greetings\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b3f800-0a14-4d13-8c32-390965c537ca",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 8 - Classes Activity Part 2<a class=\"anchor\" id=\"DS109L6_page_8\"></a>\n",
    "\n",
    "[Back to Top](#DS109L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4597e4b4-ce22-448d-843e-eab5ba74a9c4",
   "metadata": {},
   "source": [
    "Create a class named `Rectangle` that:\n",
    "\n",
    "- Has two properties `width` and `height`.\n",
    "\n",
    "- Has an initializer to set the two properties.\n",
    "\n",
    "- Has a method named `area()` that has no parameters (other than _self_) and returns the _area_ of the rectangle (the product of the width and height).\n",
    "\n",
    "\n",
    "```python\n",
    "class Rectangle:\n",
    "    \"\"\"This is a shape\"\"\"\n",
    "\n",
    "    def __init__(self, width, height):\n",
    "        \"\"\"Initializer\"\"\"\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "\n",
    "    def area(self):\n",
    "        \"\"\"Returns the area\"\"\"\n",
    "        return self.width * self.height\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36943bcd-7e16-4af1-97d3-c09e81ae5e99",
   "metadata": {},
   "source": [
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n",
    "\n",
    "# Page 9 - Lesson 6 Hands-On<a class=\"anchor\" id=\"DS109L6_page_9\"></a>\n",
    "\n",
    "[Back to Top](#DS109L6_toc)\n",
    "\n",
    "<hr style=\"height:10px;border-width:0;color:gray;background-color:gray\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdf2cdde-9447-49b5-8936-17d80f46b45e",
   "metadata": {},
   "source": [
    "For your Lesson 6 Hands-On, you will be practicing your new skills with Object Oriented Programming. For this project, you will be creating a new directory, so please follow the below setup instructions. This Hands-On **will** be graded, so be sure you complete all requirements.\n",
    "\n",
    "<div class=\"panel panel-success\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Additional Info!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Before beginning this hands-on, you may want to watch this <a href=\"https://vimeo.com/426091587\"> recorded live workshop </a> that goes over a similar example. </p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "## Setup\n",
    "\n",
    "1. First, open up your command prompt/terminal\n",
    "2. Within your command prompt/terminal, run the following command:\n",
    "    ```text\n",
    "    cd desktop\n",
    "    ``` \n",
    "3. Next, run the following:\n",
    "    ```text\n",
    "    cd python_course\n",
    "    ```\n",
    "4. Run the following to create a new directory for this project:\n",
    "    ```text\n",
    "    mkdir lesson_six_handson\n",
    "    ```\n",
    "5. Open up a new window in VSCode. \n",
    "6. Click on the \"Explorer\" button on the left-hand side of the VSCode window.\n",
    "7. Click the `Open Folder` button.   \n",
    "8. Select the `lesson_six_handson` directory within the `python_course` folder on your Desktop. Click the `Open` button. \n",
    "10. Create a new file named `main.py` by one of the following three ways:\n",
    "    - To the right of __LESSON_SIX_HANDSON__ in the EXPLORER is a button that looks like a piece of paper with a plus symbol in its top-left corner. If you hover your mouse over this button for a moment, a popup will appear indicating that this button will create a new file.\n",
    "    - Choose `File > New File` from the app's menu.\n",
    "    - Press `Control + N` in Windows or `Command + N` on a Mac (the plus means \"and at the same time\").\n",
    "\n",
    "Now you are ready to get started on your Lesson 6 Hands-On!\n",
    "\n",
    "<div class=\"panel panel-info\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Tip!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Remember to pay attention to indenting! When defining a class or a function, you should have a colon at the end of the line, and Python will automatically indent for you. If you're not seeing the next line indented, double check your code!</p>\n",
    "    </div>\n",
    "</div>\n",
    "\n",
    "---\n",
    "\n",
    "## Requirements\n",
    "\n",
    "This hands-on is broken into two parts. Please complete each part within your `main.py` file.\n",
    "\n",
    "---\n",
    "\n",
    "## Part 1\n",
    "\n",
    "1. Create a class named `Stadium` \n",
    "2. Use the `init` method to include the following three properties:\n",
    "    * `name`\n",
    "    * `city_state`\n",
    "    * `capacity`\n",
    "    > Hint! What is the property that is included in _every_ method? Don't forget that one!    \n",
    "3. Initialize each property/attribute within the `init` method\n",
    "4. Include a `docString` for the class _and_ method\n",
    "5. Create another method within the `Stadium` class named `describe_stadium` \n",
    "6. The `describe_stadium` method should utilize each method from the Stadium class which will then print a description of the arena (see step 10 for an example of a description).\n",
    "7. Create a new instance of the `Stadium` class named `stadium1`. \n",
    "8. The `stadium1` instance should provide values for each of the three properties of the `Stadium` class\n",
    "9. Finally, `stadium1` should call the `describe_stadium` method.\n",
    "10. The output should be similar to the following:\n",
    "    ```text\n",
    "    The Mercedes Benz Arena is located in Atlanta, GA and holds 70,000 fans.\n",
    "    ```\n",
    "\n",
    "---\n",
    "## Part 2\n",
    "\n",
    "1. Add two more methods to the `Stadium` class:\n",
    "    * `sport_played` - This method should accept one argument that specifies the sport that is played\n",
    "    * `seats_available` - This method should accept one argument that specifies how many seats are available\n",
    "2. Each of the above method should print out a sentence using the argument provided (see step 4 for output)\n",
    "3. Using the `stadium1` instance, call each of the new methods, providing the relevant arguments. As an example, if the following code to use the class were added:\n",
    "4. After running this program in your terminal, the output should be similar to the following:\n",
    "    ```text\n",
    "    The Mercedes Benz Arena is in Atlanta, GA and holds 70000 fans.\n",
    "    The following sport is mainly played in this stadium: Football\n",
    "    There are 15000 seats still available for tonight's game.\n",
    "    ```\n",
    "\n",
    "<div class=\"panel panel-danger\">\n",
    "    <div class=\"panel-heading\">\n",
    "        <h3 class=\"panel-title\">Caution!</h3>\n",
    "    </div>\n",
    "    <div class=\"panel-body\">\n",
    "        <p>Be sure to zip and submit your entire <code>lesson_six_handson</code> directory when finished!</p>\n",
    "    </div>\n",
    "</div>"
   ]
  }
 ],
 "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}