Classes_and_OOP.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Mtaimoorakmal/OOPS/blob/main/Classes_and_OOP.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6o3BV30iFEVz"
      },
      "source": [
        "Classes\n",
        "==="
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PGp_yP0uFEV7"
      },
      "source": [
        "So far you have learned about Python's core data types: strings, numbers, lists, tuples, and dictionaries. In this section you will learn about the last major data structure, classes. Classes are quite unlike the other data types, in that they are much more flexible. Classes allow you to define the information and behavior that characterize anything you want to model in your program. Classes are a rich topic, so you will learn just enough here to dive into the projects you'd like to get started on."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V6lxl0KzFEV8"
      },
      "source": [
        "There is a lot of new language that comes into play when you start learning about classes. If you are familiar with object-oriented programming from your work in another language, this will be a quick read about how Python approaches OOP. If you are new to programming in general, there will be a lot of new ideas here. Just start reading, try out the examples on your own machine, and trust that it will start to make sense as you work your way through the examples and exercises."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VAUcMLCAFEV9"
      },
      "source": [
        "<a name=\"top\"></a>Contents\n",
        "===\n",
        "- [What are classes?](#what)\n",
        "- [Object-Oriented Terminology](#oop_terminology)\n",
        "    - [General terminology](#general_terminology)\n",
        "    - [A closer look at the Rocket class](#closer_look)\n",
        "        - [The \\_\\_init()\\_\\_ method](#init_method)\n",
        "        - [A simple method](#simple_method)\n",
        "        - [Making multiple objects from a class](#multiple_objects)\n",
        "        - [A quick check-in](#check_in)\n",
        "        - [Exercises](#exercises_closer_look)\n",
        "- [Refining the Rocket class](#refining_rocket)\n",
        "    - [Accepting parameters for the \\_\\_init\\_\\_() method](#init_parameters)\n",
        "    - [Accepting parameters in a method](#method_parameters)\n",
        "    - [Adding a new method](#adding_method)\n",
        "    - [Exercises](#exercises_refining_rocket)\n",
        "- [Inheritance](#inheritance)\n",
        "    - [The Shuttle class](#shuttle)\n",
        "    - [Exercises](#exercises_inheritance)\n",
        "- [Modules and classes](#modules_classes)\n",
        "    - [Storing a single class in a module](#single_class_module)\n",
        "    - [Storing multiple classes in a module](#multiple_classes_module)\n",
        "    - [A number of ways to import modules and classes](#multiple_ways_import)\n",
        "    - [A module of functions](#module_functions)\n",
        "    - [Exercises](#exercises_importing)\n",
        "- [Method Resolution Order (example)](#mro)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_WfwwgPJFEV-"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FM_wNcmrFEV-"
      },
      "source": [
        "<a name=\"what\"></a>What are classes?\n",
        "===\n",
        "Classes are a way of combining information and behavior. For example, let's consider what you'd need to do if you were creating a rocket ship in a game, or in a physics simulation. One of the first things you'd want to track are the x and y coordinates of the rocket. Here is what a simple rocket ship class looks like in code:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "4jYtNjOUFEV_"
      },
      "outputs": [],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = 0\n",
        "        self.y = 0"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cVEayvT4FEWB"
      },
      "source": [
        "One of the first things you do with a class is to define the **\\__init\\__()** method. The \\_\\_init\\_\\_() method sets the values for any parameters that need to be defined when an object is first created. The *self* part will be explained later; basically, it's a syntax that allows you to access a variable from anywhere else in the class.\n",
        "\n",
        "The Rocket class stores two pieces of information so far, but it can't do anything. The first behavior to define is a core behavior of a rocket: moving up. Here is what that might look like in code:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "mWb4XntwFEWD"
      },
      "outputs": [],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = 0\n",
        "        self.y = 0\n",
        "\n",
        "    def move_up(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.y += 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hem7nUlyFEWE"
      },
      "source": [
        "The Rocket class can now store some information, and it can do something. But this code has not actually created a rocket yet. Here is how you actually make a rocket:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PinV3X_EFEWF",
        "outputId": "07874747-f44d-4ca4-b9e3-9a7ded15bd54"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<__main__.Rocket object at 0x785d27fb66b0>\n"
          ]
        }
      ],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = 0\n",
        "        self.y = 0\n",
        "\n",
        "    def move_up(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.y += 1\n",
        "\n",
        "# Create a Rocket object.\n",
        "my_rocket = Rocket()\n",
        "print(my_rocket)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ov0gJc42FEWH"
      },
      "source": [
        "To actually use a class, you create a variable such as *my\\_rocket*. Then you set that equal to the name of the class, with an empty set of parentheses. Python creates an **object** from the class. An object is a single instance of the Rocket class; it has a copy of each of the class's variables, and it can do any action that is defined for the class. In this case, you can see that the variable my\\_rocket is a Rocket object from the \\_\\_main\\_\\_ program file, which is stored at a particular location in memory."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1WVCVvRGFEWI"
      },
      "source": [
        "Once you have a class, you can define an object and use its methods. Here is how you might define a rocket and have it start to move up:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WELfjsrwFEWI",
        "outputId": "454e661d-bfbd-4197-db58-14537cdae382"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Rocket altitude: 0\n",
            "Rocket altitude: 1\n",
            "Rocket altitude: 2\n"
          ]
        }
      ],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = 0\n",
        "        self.y = 0\n",
        "\n",
        "    def move_up(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.y += 1\n",
        "\n",
        "# Create a Rocket object, and have it start to move up.\n",
        "my_rocket = Rocket()\n",
        "print(\"Rocket altitude:\", my_rocket.y)\n",
        "\n",
        "my_rocket.move_up()\n",
        "print(\"Rocket altitude:\", my_rocket.y)\n",
        "\n",
        "my_rocket.move_up()\n",
        "print(\"Rocket altitude:\", my_rocket.y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oLqZqX0fFEWJ"
      },
      "source": [
        "To access an object's variables or methods, you give the name of the object and then use *dot notation* to access the variables and methods. So to get the y-value of *my\\_rocket*, you use *my\\_rocket.y*. To use the move_up() method on my_rocket, you write *my\\_rocket.move\\_up()*."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zoz0syGRFEWK"
      },
      "source": [
        "Once you have a class defined, you can create as many objects from that class as you want. Each object is its own instance of that class, with its own separate variables. All of the objects are capable of the same behavior, but each object's particular actions do not affect any of the other objects."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7OrUlBKNFEWK"
      },
      "source": [
        "Once you have a class, you can define an object and use its methods. Here is how you might define a rocket and have it start to move up:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uV4XpdapFEWL",
        "outputId": "26407f75-1fb9-4414-b26a-d9a5c0f62395"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 <__main__.Rocket object at 0x785cfa6f7bb0>\n",
            "1 <__main__.Rocket object at 0x785cfa6f72b0>\n",
            "2 <__main__.Rocket object at 0x785cfa8e38b0>\n",
            "3 <__main__.Rocket object at 0x785cfa8e3790>\n",
            "4 <__main__.Rocket object at 0x785cfa8e0640>\n"
          ]
        }
      ],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = 0\n",
        "        self.y = 0\n",
        "\n",
        "    def move_up(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.y += 1\n",
        "\n",
        "# Create a fleet of 5 rockets, and store them in a list.\n",
        "my_rockets = []\n",
        "for x in range(0,5):\n",
        "    new_rocket = Rocket()\n",
        "    my_rockets.append(new_rocket)\n",
        "\n",
        "# Show that each rocket is a separate object.\n",
        "for index ,rocket in enumerate(my_rockets):\n",
        "    print(index , rocket)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zoa3y5BxFEWM"
      },
      "source": [
        "You can see that each rocket is at a separate place in memory. By the way, if you understand [list comprehensions](03_lists_tuples.html#comprehensions), you can make the fleet of rockets in one line:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FtmioL6KFEWM",
        "outputId": "552c3b01-842b-4c58-c6fa-e9dea881128d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0: <__main__.Rocket object at 0x785cfab8cc10>\n",
            "1: <__main__.Rocket object at 0x785cfab8da20>\n",
            "2: <__main__.Rocket object at 0x785cfab8d480>\n",
            "3: <__main__.Rocket object at 0x785cfab8d4e0>\n",
            "4: <__main__.Rocket object at 0x785cfab8e5c0>\n"
          ]
        }
      ],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = 0\n",
        "        self.y = 0\n",
        "\n",
        "    def move_up(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.y += 1\n",
        "\n",
        "# Create a fleet of 5 rockets, and store them in a list.\n",
        "my_rockets = [Rocket() for x in range(0,5)]\n",
        "\n",
        "# Show that each rocket is a separate object.\n",
        "for index , rocket in enumerate(my_rockets):\n",
        "    print(f'{index}: {rocket}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RONpwBm3FEWN"
      },
      "source": [
        "You can prove that each rocket has its own x and y values by moving just one of the rockets:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "12eQuNNCFEWN",
        "outputId": "751e2f70-f097-4705-c6a1-99c0e69e74f5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Rocket altitude: 1 Rocket Langitude: 1\n",
            "Rocket altitude: 0 Rocket Langitude: 1\n",
            "Rocket altitude: 0 Rocket Langitude: 0\n",
            "Rocket altitude: 0 Rocket Langitude: 0\n",
            "Rocket altitude: 0 Rocket Langitude: 0\n"
          ]
        }
      ],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = 0\n",
        "        self.y = 0\n",
        "\n",
        "    def move_up(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.y += 1\n",
        "    def move_rigth(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.x += 1\n",
        "\n",
        "# Create a fleet of 5 rockets, and store them in a list.\n",
        "my_rockets = [Rocket() for x in range(0,5)]\n",
        "\n",
        "# Move the first rocket up.\n",
        "my_rockets[0].move_up()\n",
        "my_rockets[0].move_rigth()\n",
        "my_rockets[1].move_rigth()\n",
        "\n",
        "# Show that only the first rocket has moved.\n",
        "for rocket in my_rockets:\n",
        "    print(f\"Rocket altitude: {rocket.y} Rocket Langitude: {rocket.x}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i4MBvB94FEWO"
      },
      "source": [
        "The syntax for classes may not be very clear at this point, but consider for a moment how you might create a rocket without using classes. You might store the x and y values in a dictionary, but you would have to write a lot of ugly, hard-to-maintain code to manage even a small set of rockets. As more features become incorporated into the Rocket class, you will see how much more efficiently real-world objects can be modeled with classes than they could be using just lists and dictionaries."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NGERlJvCFEWO"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-y32dQ0CFEWP"
      },
      "source": [
        "<a name='exercises_what'></a>Exercises\n",
        "---\n",
        "\n",
        "#### Rocket With No Class\n",
        "- Using just what you already know, try to write a program that simulates the [above example](#what) about rockets.\n",
        "    - Store an x and y value for a rocket.\n",
        "    - Store an x and y value for each rocket in a set of 5 rockets. Store these 5 rockets in a list.\n",
        "- Don't take this exercise too far; it's really just a quick exercise to help you understand how useful the class structure is, especially as you start to see more capability added to the Rocket class."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YhPhySw5FEWP",
        "outputId": "9d5cbf80-10fe-45a3-b346-6713a92a318f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(0, 0.0), (1, 1.5), (2, 3.0), (3, 4.5), (4, 6.0)]\n"
          ]
        }
      ],
      "source": [
        "# Ex 9.0 : Rocket with no Class\n",
        "\n",
        "# put your code here\n",
        "\n",
        "# Initialize an empty list to store rockets\n",
        "rockets = []\n",
        "\n",
        "# Create 5 rockets with initial x and y values\n",
        "for i in range(5):\n",
        "  # Each rocket is represented as a tuple (x, y)\n",
        "  rocket = (i, i * 1.5)  # Example: x = i, y = i * 2\n",
        "  rockets.append(rocket)\n",
        "\n",
        "# Print the list of rockets\n",
        "# for index, rocket in enumerate(rockets):\n",
        "#   print(f\"Rocket {index}: x = {rocket[0]}, y = {rocket[1]}\")\n",
        "print(rockets)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4MbTqHSsFEWP"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6mIFOsBRFEWQ"
      },
      "source": [
        "<a name='oop_terminology'></a>Object-Oriented terminology\n",
        "==="
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YT65KNO5FEWQ"
      },
      "source": [
        "Classes are part of a programming paradigm called **object-oriented programming**. Object-oriented programming, or OOP for short, focuses on building reusable blocks of code called classes. When you want to use a class in one of your programs, you make an **object** from that class, which is where the phrase \"object-oriented\" comes from. Python itself is not tied to object-oriented programming, but you will be using objects in most or all of your Python projects. In order to understand classes, you have to understand some of the language that is used in OOP."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xNmUwzWdFEWQ"
      },
      "source": [
        "<a name='general_terminology'></a>General terminology\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4AFnUu-nFEWR"
      },
      "source": [
        "A **class** is a body of code that defines the **attributes** and **behaviors** required to accurately model something you need for your program. You can model something from the real world, such as a rocket ship or a guitar string, or you can model something from a virtual world such as a rocket in a game, or a set of physical laws for a game engine."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uav2i4QCFEWR"
      },
      "source": [
        "An **attribute** is a piece of information. In code, an attribute is just a variable that is part of a class."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s82au4KpFEWR"
      },
      "source": [
        "A **behavior** is an action that is defined within a class. These are made up of **methods**, which are just functions that are defined for the class."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3n4N_ORNFEWS"
      },
      "source": [
        "An **object** is a particular instance of a class. An object has a certain set of values for all of the attributes (variables) in the class. You can have as many objects as you want for any one class."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LPhpQLTFFEWS"
      },
      "source": [
        "There is much more to know, but these words will help you get started. They will make more sense as you see more examples, and start to use classes on your own."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MSbb-MOdFEWS"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KoqZxSmkFEWS"
      },
      "source": [
        "<a name='closer_look'></a>A closer look at the Rocket class\n",
        "---\n",
        "Now that you have seen a simple example of a class, and have learned some basic OOP terminology, it will be helpful to take a closer look at the Rocket class."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "woVRmxqVFEWS"
      },
      "source": [
        "<a name=\"init_method\"></a>The \\_\\_init()\\_\\_ method\n",
        "---\n",
        "Here is the initial code block that defined the Rocket class:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YQMbNmy2FEWT"
      },
      "outputs": [],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = 0\n",
        "        self.y = 0"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P3eBMXx7FEWY"
      },
      "source": [
        "The first line shows how a class is created in Python. The keyword **class** tells Python that you are about to define a class. The rules for naming a class are the same rules you learned about [naming variables](var_string_num.html#naming_rules), but there is a strong convention among Python programmers that classes should be named using CamelCase. If you are unfamiliar with CamelCase, it is a convention where each letter that starts a word is capitalized, with no underscores in the name. The name of the class is followed by a set of parentheses. These parentheses will be empty for now, but later they may contain a class upon which the new class is based."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0s0qwdEgFEWZ"
      },
      "source": [
        "It is good practice to write a comment at the beginning of your class, describing the class. There is a [more formal syntax](http://www.python.org/dev/peps/pep-0257/) for documenting your classes, but you can wait a little bit to get that formal. For now, just write a comment at the beginning of your class summarizing what you intend the class to do. Writing more formal documentation for your classes will be easy later if you start by writing simple comments now."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wk-9CRRuFEWZ"
      },
      "source": [
        "Function names that start and end with two underscores are special built-in functions that Python uses in certain ways. The \\_\\_init()\\_\\_ method is one of these special functions. It is called automatically when you create an object from your class. The \\_\\_init()\\_\\_ method lets you make sure that all relevant attributes are set to their proper values when an object is created from the class, before the object is used. In this case, The \\_\\_init\\_\\_() method initializes the x and y values of the Rocket to 0."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jSLQ-A96FEWZ"
      },
      "source": [
        "The **self** keyword often takes people a little while to understand. The word \"self\" refers to the current object that you are working with. When you are writing a class, it lets you refer to certain attributes from any other part of the class. Basically, all methods in a class need the *self* object as their first argument, so they can access any attribute that is part of the class."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bG1D5gyWFEWZ"
      },
      "source": [
        "Now let's take a closer look at a **method**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PAku-FRRFEWZ"
      },
      "source": [
        "<a name='simple_method'></a>A simple method\n",
        "---\n",
        "Here is the method that was defined for the Rocket class:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5kJUqTdtFEWa"
      },
      "outputs": [],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = 0\n",
        "        self.y = 0\n",
        "\n",
        "    def move_up(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.y += 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a-uAlRgRFEWa"
      },
      "source": [
        "A method is just a function that is part of a class. Since it is just a function, you can do anything with a method that you learned about with functions. You can accept [positional](08_more_functions.html#positional_arguments) arguments, [keyword](08_more_functions.html#keyword_arguments) arguments, an arbitrary [list of argument values](08_more_functions.html#arbitrary_sequence), an arbitrary [dictionary of arguments](08_more_functions.html#arbitrary_keyword_arguments), or any combination of these. Your arguments can return a value or a set of values if you want, or they can just do some work without returning any values."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mkmm5PfzFEWa"
      },
      "source": [
        "Each method has to accept one argument by default, the value **self**. This is a reference to the particular object that is calling the method. This *self* argument gives you access to the calling object's attributes. In this example, the self argument is used to access a Rocket object's y-value. That value is increased by 1, every time the method move_up() is called by a particular Rocket object. This is probably still somewhat confusing, but it should start to make sense as you work through your own examples."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xeo-cYVPFEWa"
      },
      "source": [
        "If you take a second look at what happens when a method is called, things might make a little more sense:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "w1Wx5qyIFEWa",
        "outputId": "04068b21-0bcc-40bf-c150-ec7650aadb73"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Rocket altitude: 0\n",
            "Rocket altitude: 1\n",
            "Rocket altitude: 2\n"
          ]
        }
      ],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = 0\n",
        "        self.y = 0\n",
        "\n",
        "    def move_up(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.y += 1\n",
        "\n",
        "# Create a Rocket object, and have it start to move up.\n",
        "my_rocket = Rocket()\n",
        "print(\"Rocket altitude:\", my_rocket.y)\n",
        "\n",
        "my_rocket.move_up()\n",
        "print(\"Rocket altitude:\", my_rocket.y)\n",
        "\n",
        "my_rocket.move_up()\n",
        "print(\"Rocket altitude:\", my_rocket.y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xQnAK3ieFEWb"
      },
      "source": [
        "In this example, a Rocket object is created and stored in the variable my_rocket. After this object is created, its y value is printed. The value of the attribute *y* is accessed using dot notation. The phrase *my\\_rocket.y* asks Python to return \"the value of the variable y attached to the object my_rocket\".\n",
        "\n",
        "After the object my_rocket is created and its initial y-value is printed, the method move_up() is called. This tells Python to apply the method move_up() to the object my_rocket. Python finds the y-value associated with my_rocket and adds 1 to that value. This process is repeated several times, and you can see from the output that the y-value is in fact increasing."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TZC7pGYIFEWb"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eVktEW1mFEWb"
      },
      "source": [
        "<a name='multiple_objects'></a>Making multiple objects from a class\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y6nW_D0HFEWb"
      },
      "source": [
        "One of the goals of object-oriented programming is to create reusable code. Once you have written the code for a class, you can create as many objects from that class as you need. It is worth mentioning at this point that classes are usually saved in a separate file, and then imported into the program you are working on. So you can build a library of classes, and use those classes over and over again in different programs. Once you know a class works well, you can leave it alone and know that the objects you create in a new program are going to work as they always have."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vESDJBo5FEWc"
      },
      "source": [
        "You can see this \"code reusability\" already when the Rocket class is used to make more than one Rocket object. Here is the code that made a fleet of Rocket objects:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tSLa8JlAFEWc",
        "outputId": "ff859996-e4d8-42aa-8842-d3927c3e13fa"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<__main__.Rocket object at 0x7f6f50763090>\n",
            "<__main__.Rocket object at 0x7f6f5077ead0>\n",
            "<__main__.Rocket object at 0x7f6f50763990>\n",
            "<__main__.Rocket object at 0x7f6f50763a10>\n",
            "<__main__.Rocket object at 0x7f6f50763a50>\n"
          ]
        }
      ],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = 0\n",
        "        self.y = 0\n",
        "\n",
        "    def move_up(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.y += 1\n",
        "\n",
        "# Create a fleet of 5 rockets, and store them in a list.\n",
        "my_rockets = []\n",
        "for x in range(0,5):\n",
        "    new_rocket = Rocket()\n",
        "    my_rockets.append(new_rocket)\n",
        "\n",
        "# Show that each rocket is a separate object.\n",
        "for rocket in my_rockets:\n",
        "    print(rocket)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ra7XiTEbFEWd"
      },
      "source": [
        "If you are comfortable using list comprehensions, go ahead and use those as much as you can. I'd rather not assume at this point that everyone is comfortable with comprehensions, so I will use the slightly longer approach of declaring an empty list, and then using a for loop to fill that list. That can be done slightly more efficiently than the previous example, by eliminating the temporary variable *new\\_rocket*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "P8Ua9C-uFEWd",
        "outputId": "92b5874e-071d-40ba-875a-e3f0c38df444"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<__main__.Rocket object at 0x7f6f50763990>\n",
            "<__main__.Rocket object at 0x7f6f50763a10>\n",
            "<__main__.Rocket object at 0x7f6f50763750>\n",
            "<__main__.Rocket object at 0x7f6f506fd8d0>\n",
            "<__main__.Rocket object at 0x7f6f506fd6d0>\n"
          ]
        }
      ],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = 0\n",
        "        self.y = 0\n",
        "\n",
        "    def move_up(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.y += 1\n",
        "\n",
        "# Create a fleet of 5 rockets, and store them in a list.\n",
        "my_rockets = []\n",
        "for x in range(0,5):\n",
        "    my_rockets.append(Rocket())\n",
        "\n",
        "# Show that each rocket is a separate object.\n",
        "for rocket in my_rockets:\n",
        "    print(rocket)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ts2afR93FEWe"
      },
      "source": [
        "What exactly happens in this for loop? The line *my\\_rockets.append(Rocket())* is executed 5 times. Each time, a new Rocket object is created and then added to the list my\\_rockets. The \\_\\_init\\_\\_() method is executed once for each of these objects, so each object gets its own x and y value. When a method is called on one of these objects, the *self* variable allows access to just that object's attributes, and ensures that modifying one object does not affect any of the other objecs that have been created from the class.\n",
        "\n",
        "Each of these objects can be worked with individually. At this point we are ready to move on and see how to add more functionality to the Rocket class. We will work slowly, and give you the chance to start writing your own simple classes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6aL4kpj9FEWe"
      },
      "source": [
        "<a name='check_in'></a>A quick check-in\n",
        "---\n",
        "If all of this makes sense, then the rest of your work with classes will involve learning a lot of details about how classes can be used in more flexible and powerful ways. If this does not make any sense, you could try a few different things:\n",
        "\n",
        "- Reread the previous sections, and see if things start to make any more sense.\n",
        "- Type out these examples in your own editor, and run them. Try making some changes, and see what happens.\n",
        "- Try the next exercise, and see if it helps solidify some of the concepts you have been reading about.\n",
        "- Read on. The next sections are going to add more functionality to the Rocket class. These steps will involve rehashing some of what has already been covered, in a slightly different way.\n",
        "\n",
        "Classes are a huge topic, and once you understand them you will probably use them for the rest of your life as a programmer. If you are brand new to this, be patient and trust that things will start to sink in."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k02y-TVjFEWf"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CDy9RsyrFEWf"
      },
      "source": [
        "<a name='exercises_closer_look'></a>Exercises\n",
        "---\n",
        "#### Your Own Rocket\n",
        "- Without looking back at the previous examples, try to recreate the [Rocket class](#multiple_objects) as it has been shown so far.\n",
        "    - Define the Rocket() class.\n",
        "    - Define the \\_\\_init\\_\\_() method, which sets an x and a y value for each Rocket object.\n",
        "    - Define the move_up() method.\n",
        "    - Create a Rocket object.\n",
        "    - Print the object.\n",
        "    - Print the object's y-value.\n",
        "    - Move the rocket up, and print its y-value again.\n",
        "    - Create a fleet of rockets, and prove that they are indeed separate Rocket objects."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Mn_GMNTvFEWg"
      },
      "outputs": [],
      "source": [
        "# Ex 9.1 : Your Own Rocket\n",
        "\n",
        "# put your code here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W7H0Tm3RFEWg"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KsCDqFQEFEWh"
      },
      "source": [
        "<a name='refining_rocket'></a>Refining the Rocket class\n",
        "===\n",
        "The Rocket class so far is very simple. It can be made a little more interesting with some refinements to the \\_\\_init\\_\\_() method, and by the addition of some methods."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-6SsBEaiFEWh"
      },
      "source": [
        "<a name='init_parameters'></a>Accepting paremeters for the \\_\\_init\\_\\_() method\n",
        "---\n",
        "The \\_\\_init\\_\\_() method is run automatically one time when you create a new object from a class. The \\_\\_init\\_\\_() method for the Rocket class so far is pretty simple:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4nsZZX20FEWi"
      },
      "outputs": [],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = 0\n",
        "        self.y = 0\n",
        "\n",
        "    def move_up(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.y += 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b6Ral5DMFEWi"
      },
      "source": [
        "All the \\_\\_init\\_\\_() method does so far is set the x and y values for the rocket to 0. We can easily add a couple keyword arguments so that new rockets can be initialized at any position:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tjq6XNBpFEWj"
      },
      "outputs": [],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self, x=0, y=0):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def move_up(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.y += 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u-BvtfyDFEWj"
      },
      "source": [
        "Now when you create a new Rocket object you have the choice of passing in arbitrary initial values for x and y:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xknUVxK1FEWk",
        "outputId": "a1a64bd0-4617-4382-8148-bfc9753b2232"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Rocket 0 is at (0, 0).\n",
            "Rocket 1 is at (0, 10).\n",
            "Rocket 2 is at (100, 0).\n"
          ]
        }
      ],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self, x=0, y=0):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def move_up(self):\n",
        "        # Increment the y-position of the rocket.\n",
        "        self.y += 1\n",
        "\n",
        "# Make a series of rockets at different starting places.\n",
        "rockets = []\n",
        "rockets.append(Rocket())\n",
        "rockets.append(Rocket(0,10))\n",
        "rockets.append(Rocket(100,0))\n",
        "\n",
        "# Show where each rocket is.\n",
        "for index, rocket in enumerate(rockets):\n",
        "    print(\"Rocket %d is at (%d, %d).\" % (index, rocket.x, rocket.y))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SiNopyXPFEWk"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rJD0-ErdFEWl"
      },
      "source": [
        "<a name='method_parameters'></a>Accepting paremeters in a method\n",
        "---\n",
        "The \\_\\_init\\_\\_ method is just a special method that serves a particular purpose, which is to help create new objects from a class. Any method in a class can accept parameters of any kind. With this in mind, the move_up() method can be made much more flexible. By accepting keyword arguments, the move_up() method can be rewritten as a more general move_rocket() method."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QZjprpmdFEWl"
      },
      "source": [
        "This new method will allow the rocket to be moved any amount, in any direction:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KPiPAOeBFEWl"
      },
      "outputs": [],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self, x=0, y=0):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def move_rocket(self, x_increment=0, y_increment=1):\n",
        "        # Move the rocket according to the paremeters given.\n",
        "        #  Default behavior is to move the rocket up one unit.\n",
        "        self.x += x_increment\n",
        "        self.y += y_increment"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uurdSe2LFEWm"
      },
      "source": [
        "The paremeters for the move() method are named x_increment and y_increment rather than x and y. It's good to emphasize that these are changes in the x and y position, not new values for the actual position of the rocket. By carefully choosing the right default values, we can define a meaningful default behavior. If someone calls the method move_rocket() with no parameters, the rocket will simply move up one unit in the y-direciton. Note that this method can be given negative values to move the rocket left or right:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eppmydtoFEWm",
        "outputId": "51f21ad3-cba6-46d6-a410-b4f8e46254a3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Rocket 0 is at (0, 1).\n",
            "Rocket 1 is at (10, 10).\n",
            "Rocket 2 is at (-10, 0).\n"
          ]
        }
      ],
      "source": [
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self, x=0, y=0):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def move_rocket(self, x_increment=0, y_increment=1):\n",
        "        # Move the rocket according to the paremeters given.\n",
        "        #  Default behavior is to move the rocket up one unit.\n",
        "        self.x += x_increment\n",
        "        self.y += y_increment\n",
        "\n",
        "# Create three rockets.\n",
        "rockets = [Rocket() for x in range(0,3)]\n",
        "\n",
        "# Move each rocket a different amount.\n",
        "rockets[0].move_rocket()\n",
        "rockets[1].move_rocket(10,10)\n",
        "rockets[2].move_rocket(-10,0)\n",
        "\n",
        "# Show where each rocket is.\n",
        "for index, rocket in enumerate(rockets):\n",
        "    print(\"Rocket %d is at (%d, %d).\" % (index, rocket.x, rocket.y))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i1IWnbo7FEWn"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YKauyAmIFEWo"
      },
      "source": [
        "<a name='adding_method'></a>Adding a new method\n",
        "---\n",
        "One of the strengths of object-oriented programming is the ability to closely model real-world phenomena by adding appropriate attributes and behaviors to classes. One of the jobs of a team piloting a rocket is to make sure the rocket does not get too close to any other rockets. Let's add a method that will report the distance from one rocket to any other rocket.\n",
        "\n",
        "If you are not familiar with distance calculations, there is a fairly simple formula to tell the distance between two points if you know the x and y values of each point."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1MO0I1x_FEWo"
      },
      "source": [
        "This new method performs that calculation, and then returns the resulting distance."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Nd7dWZrpFEWp",
        "outputId": "d7f9c030-8613-4275-f96b-12497f823717"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The rockets are 11.180340 units apart.\n"
          ]
        }
      ],
      "source": [
        "from math import sqrt\n",
        "\n",
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self, x=0, y=0):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def move_rocket(self, x_increment=0, y_increment=1):\n",
        "        # Move the rocket according to the paremeters given.\n",
        "        #  Default behavior is to move the rocket up one unit.\n",
        "        self.x += x_increment\n",
        "        self.y += y_increment\n",
        "\n",
        "    def get_distance(self, other_rocket):\n",
        "        # Calculates the distance from this rocket to another rocket,\n",
        "        #  and returns that value.\n",
        "        distance = sqrt((self.x-other_rocket.x)**2+(self.y-other_rocket.y)**2)\n",
        "        return distance\n",
        "\n",
        "# Make two rockets, at different places.\n",
        "rocket_0 = Rocket()\n",
        "rocket_1 = Rocket(10,5)\n",
        "\n",
        "# Show the distance between them.\n",
        "distance = rocket_0.get_distance(rocket_1)\n",
        "print(\"The rockets are %f units apart.\" % distance)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZrrRXycOFEWp"
      },
      "source": [
        "Hopefully these short refinements show that you can extend a class' attributes and behavior to model the phenomena you are interested in as closely as you want. The rocket could have a name, a crew capacity, a payload, a certain amount of fuel, and any number of other attributes. You could define any behavior you want for the rocket, including interactions with other rockets and launch facilities, gravitational fields, and whatever you need it to! There are techniques for managing these more complex interactions, but what you have just seen is the core of object-oriented programming.\n",
        "\n",
        "At this point you should try your hand at writing some classes of your own. After trying some exercises, we will look at object inheritance, and then you will be ready to move on for now."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n8mLb3o5FEWq"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Aa_Uc8VNFEWq"
      },
      "source": [
        "<a name='exercises_refining_rocket'></a>Exercises\n",
        "---\n",
        "#### Your Own Rocket 2\n",
        "- There are enough new concepts here that you might want to try re-creating the [Rocket class](#adding_method) as it has been developed so far, looking at the examples as little as possible. Once you have your own version, regardless of how much you needed to look at the example, you can modify the class and explore the possibilities of what you have already learned.\n",
        "    - Re-create the Rocket class as it has been developed so far:\n",
        "        - Define the Rocket() class.\n",
        "        - Define the \\_\\_init\\_\\_() method. Let your \\_\\_init\\_\\_() method accept x and y values for the initial position of the rocket. Make sure the default behavior is to position the rocket at (0,0).\n",
        "        - Define the move_rocket() method. The method should accept an amount to move left or right, and an amount to move up or down.\n",
        "        - Create a Rocket object. Move the rocket around, printing its position after each move.\n",
        "        - Create a small fleet of rockets. Move several of them around, and print their final positions to prove that each rocket can move independently of the other rockets.\n",
        "        - Define the get_distance() method. The method should accept a Rocket object, and calculate the distance between the current rocket and the rocket that is passed into the method.\n",
        "        - Use the get_distance() method to print the distances between several of the rockets in your fleet.\n",
        "\n",
        "#### Rocket Attributes\n",
        "- Start with a copy of the Rocket class, either one you made from a previous exercise or the latest version from the [last section](#adding_method).\n",
        "- Add several of your own attributes to the \\_\\_init\\_\\_() function. The values of your attributes can be set automatically by the \\_\\_init\\_\\_ function, or they can be set by paremeters passed into \\_\\_init\\_\\_().\n",
        "- Create a rocket and print the values for the attributes you have created, to show they have been set correctly.\n",
        "- Create a small fleet of rockets, and set different values for one of the attributes you have created. Print the values of these attributes for each rocket in your fleet, to show that they have been set properly for each rocket.\n",
        "- If you are not sure what kind of attributes to add, you could consider storing the height of the rocket, the crew size, the name of the rocket, the speed of the rocket, or many other possible characteristics of a rocket.\n",
        "\n",
        "#### Rocket Methods\n",
        "- Start with a copy of the Rocket class, either one you made from a previous exercise or the latest version from the [last section](#adding_method).\n",
        "- Add a new method to the class. This is probably a little more challenging than adding attributes, but give it a try.\n",
        "    - Think of what rockets do, and make a very simple version of that behavior using print statements. For example, rockets lift off when they are launched. You could make a method called *launch()*, and all it would do is print a statement such as \"The rocket has lifted off!\" If your rocket has a name, this sentence could be more descriptive.\n",
        "    - You could make a very simple *land_rocket()* method that simply sets the x and y values of the rocket back to 0. Print the position before and after calling the *land_rocket()* method to make sure your method is doing what it's supposed to.\n",
        "    - If you enjoy working with math, you could implement a *safety_check()* method. This method would take in another rocket object, and call the get_distance() method on that rocket. Then it would check if that rocket is too close, and print a warning message if the rocket is too close. If there is zero distance between the two rockets, your method could print a message such as, \"The rockets have crashed!\" (Be careful; getting a zero distance could mean that you accidentally found the distance between a rocket and itself, rather than a second rocket.)\n",
        "    \n",
        "#### <a name='exercise_person_class'></a>Person Class\n",
        "- Modeling a person is a classic exercise for people who are trying to learn how to write classes. We are all familiar with characteristics and behaviors of people, so it is a good exercise to try.\n",
        "    - Define a Person() class.\n",
        "    - In the \\_\\_init()\\_\\_ function, define several attributes of a person. Good attributes to consider are name, age, place of birth, and anything else you like to know about the people in your life.\n",
        "    - Write one method. This could be as simple as *introduce_yourself()*. This method would print out a statement such as, \"Hello, my name is Eric.\"\n",
        "    - You could also make a method such as *age_person()*. A simple version of this method would just add 1 to the person's age.\n",
        "        - A more complicated version of this method would involve storing the person's birthdate rather than their age, and then calculating the age whenever the age is requested. But dealing with dates and times is not particularly easy if you've never done it in any other programming language before.\n",
        "    - Create a person, set the attribute values appropriately, and print out information about the person.\n",
        "    - Call your method on the person you created. Make sure your method executed properly; if the method does not print anything out directly, print something before and after calling the method to make sure it did what it was supposed to.\n",
        "    \n",
        "#### <a name='exercise_car_class'></a>Car Class\n",
        "- Modeling a car is another classic exercise.\n",
        "    - Define a Car() class.\n",
        "    - In the \\_\\_init\\_\\_() function, define several attributes of a car. Some good attributes to consider are make (Subaru, Audi, Volvo...), model (Outback, allroad, C30), year, num_doors, owner, or any other aspect of a car you care to include in your class.\n",
        "    - Write one method. This could be something such as *describe_car()*. This method could print a series of statements that describe the car, using the information that is stored in the attributes. You could also write a method that adjusts the mileage of the car or tracks its position.\n",
        "    - Create a car object, and use your method.\n",
        "    - Create several car objects with different values for the attributes. Use your method on several of your cars."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "m3Zy0udHFEWr"
      },
      "outputs": [],
      "source": [
        "# Ex 9.2 : Your Own Rocket 2\n",
        "\n",
        "# put your code here"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RO4vTNCUFEWs"
      },
      "outputs": [],
      "source": [
        "# Ex 9.3 : Rocket Attributes\n",
        "\n",
        "# put your code here"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3ng6kHxaFEWs"
      },
      "outputs": [],
      "source": [
        "# Ex 9.4 : Rocket Methods\n",
        "\n",
        "# put your code here"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L0GXWGgJFEWt"
      },
      "outputs": [],
      "source": [
        "# Ex 9.5 : Person Class\n",
        "\n",
        "# put your code here"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CVWOknCQFEWt"
      },
      "outputs": [],
      "source": [
        "# Ex 9.6 : Car Class\n",
        "\n",
        "# put your code here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uT-b3c71FEWt"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0NCdqMy3FEWt"
      },
      "source": [
        "<a name='inheritance'></a>Inheritance\n",
        "==="
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KqnVCvFlFEWt"
      },
      "source": [
        "One of the most important goals of the object-oriented approach to programming is the creation of stable, reliable, reusable code. If you had to create a new class for every kind of object you wanted to model, you would hardly have any reusable code."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZHWnYzF_FEWu"
      },
      "source": [
        "In Python and any other language that supports OOP, one class can **inherit** from another class. This means you can base a new class on an existing class; the new class *inherits* all of the attributes and behavior of the class it is based on."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f0bGH6m7FEWu"
      },
      "source": [
        "A new class can override any undesirable attributes or behavior of the class it inherits from, and it can add any new attributes or behavior that are appropriate. The original class is called the **parent** class, and the new class is a **child** of the parent class. The parent class is also called a **superclass**, and the child class is also called a **subclass**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RzGe_cx8FEWu"
      },
      "source": [
        "The child class inherits all attributes and behavior from the parent class, but any attributes that are defined in the child class are not available to the parent class. This may be obvious to many people, but it is worth stating."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rS41BcAgFEWu"
      },
      "source": [
        "This also means a child class can override behavior of the parent class. If a child class defines a method that also appears in the parent class, objects of the child class will use the new method rather than the parent class method.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PtY_vn62FEWu"
      },
      "source": [
        "To better understand inheritance, let's look at an example of a class that can be based on the Rocket class."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EARkwxbPFEWu"
      },
      "source": [
        "<a name='shuttle'></a>The SpaceShuttle class\n",
        "---\n",
        "If you wanted to model a space shuttle, you could write an entirely new class. But a space shuttle is just a special kind of rocket. Instead of writing an entirely new class, you can inherit all of the attributes and behavior of a Rocket, and then add a few appropriate attributes and behavior for a Shuttle.\n",
        "\n",
        "One of the most significant characteristics of a space shuttle is that it can be reused. So the only difference we will add at this point is to record the number of flights the shutttle has completed. Everything else you need to know about a shuttle has already been coded into the Rocket class."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qv3obozJFEWv"
      },
      "source": [
        "Here is what the Shuttle class looks like:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xBmqyuCTFEWv",
        "outputId": "c11821de-80ec-4d28-eb78-426bdb28dea3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "<__main__.Shuttle object at 0x7f1e62ba6cd0>\n"
          ]
        }
      ],
      "source": [
        "from math import sqrt\n",
        "\n",
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self, x=0, y=0):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def move_rocket(self, x_increment=0, y_increment=1):\n",
        "        # Move the rocket according to the paremeters given.\n",
        "        #  Default behavior is to move the rocket up one unit.\n",
        "        self.x += x_increment\n",
        "        self.y += y_increment\n",
        "\n",
        "    def get_distance(self, other_rocket):\n",
        "        # Calculates the distance from this rocket to another rocket,\n",
        "        #  and returns that value.\n",
        "        distance = sqrt((self.x-other_rocket.x)**2+(self.y-other_rocket.y)**2)\n",
        "        return distance\n",
        "\n",
        "class Shuttle(Rocket):\n",
        "    # Shuttle simulates a space shuttle, which is really\n",
        "    #  just a reusable rocket.\n",
        "\n",
        "    def __init__(self, x=0, y=0, flights_completed=0):\n",
        "        super().__init__(x, y)\n",
        "        self.flights_completed = flights_completed\n",
        "\n",
        "shuttle = Shuttle(10,0,3)\n",
        "print(shuttle)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YyfRvFSgFEWv"
      },
      "source": [
        "When a new class is based on an existing class, you write the name of the parent class in parentheses when you define the new class:\n",
        "\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zl-O-ZdQFEWv"
      },
      "outputs": [],
      "source": [
        "class NewClass(ParentClass):"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AP79TO63FEWv"
      },
      "source": [
        "The \\_\\_init\\_\\_() function of the new class needs to call the \\_\\_init\\_\\_() function of the parent class. The \\_\\_init\\_\\_() function of the new class needs to accept all of the parameters required to build an object from the parent class, and these parameters need to be passed to the \\_\\_init\\_\\_() function of the parent class. The *super().\\_\\_init\\_\\_()* function takes care of this:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lq2V-LiKFEWw"
      },
      "outputs": [],
      "source": [
        "class NewClass(ParentClass):\n",
        "\n",
        "    def __init__(self, arguments_new_class, arguments_parent_class):\n",
        "        super().__init__(arguments_parent_class)\n",
        "        # Code for initializing an object of the new class."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xkpPb5VgFEWw"
      },
      "source": [
        "The *super()* function passes the *self* argument to the parent class automatically. You could also do this by explicitly naming the parent class when you call the \\_\\_init\\_\\_() function, but you then have to include the *self* argument manually:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TnYdsbMuFEWw"
      },
      "outputs": [],
      "source": [
        "class Shuttle(Rocket):\n",
        "    # Shuttle simulates a space shuttle, which is really\n",
        "    #  just a reusable rocket.\n",
        "\n",
        "    def __init__(self, x=0, y=0, flights_completed=0):\n",
        "        Rocket.__init__(self, x, y)\n",
        "        self.flights_completed = flights_completed"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0xq2dE_ZFEWw"
      },
      "source": [
        "This might seem a little easier to read, but it is preferable to use the *super()* syntax. When you use *super()*, you don't need to explicitly name the parent class, so your code is more resilient to later changes. As you learn more about classes, you will be able to write child classes that inherit from multiple parent classes, and the *super()* function will call the parent classes' \\_\\_init\\_\\_() functions for you, in one line. This explicit approach to calling the parent class' \\_\\_init\\_\\_() function is included so that you will be less confused if you see it in someone else's code."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tm1i9udvFEWw"
      },
      "source": [
        "The output above shows that a new Shuttle object was created. This new Shuttle object can store the number of flights completed, but it also has all of the functionality of the Rocket class: it has a position that can be changed, and it can calculate the distance between itself and other rockets or shuttles. This can be demonstrated by creating several rockets and shuttles, and then finding the distance between one shuttle and all the other shuttles and rockets."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-1ewCKQUFEWx"
      },
      "source": [
        "This example uses a simple function called [randint](https://docs.python.org/3/library/random.html#random.randint), which generates a random integer between a lower and upper bound, to determine the position of each rocket and shuttle:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vjbe5hvTFEWx"
      },
      "outputs": [],
      "source": [
        "from math import sqrt\n",
        "from random import randint\n",
        "\n",
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self, x=0, y=0):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def move_rocket(self, x_increment=0, y_increment=1):\n",
        "        # Move the rocket according to the paremeters given.\n",
        "        #  Default behavior is to move the rocket up one unit.\n",
        "        self.x += x_increment\n",
        "        self.y += y_increment\n",
        "\n",
        "    def get_distance(self, other_rocket):\n",
        "        # Calculates the distance from this rocket to another rocket,\n",
        "        #  and returns that value.\n",
        "        distance = sqrt((self.x-other_rocket.x)**2+(self.y-other_rocket.y)**2)\n",
        "        return distance"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "o4pjgorCFEWx"
      },
      "outputs": [],
      "source": [
        "class Shuttle(Rocket):\n",
        "    # Shuttle simulates a space shuttle, which is really\n",
        "    #  just a reusable rocket.\n",
        "\n",
        "    def __init__(self, x=0, y=0, flights_completed=0):\n",
        "        super().__init__(x, y)\n",
        "        self.flights_completed = flights_completed"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Vjl4tuG3FEWx"
      },
      "outputs": [],
      "source": [
        "# Create several shuttles and rockets, with random positions.\n",
        "#  Shuttles have a random number of flights completed.\n",
        "shuttles = []\n",
        "for x in range(0,3):\n",
        "    x = randint(0,100)\n",
        "    y = randint(1,100)\n",
        "    flights_completed = randint(0,10)\n",
        "    shuttles.append(Shuttle(x, y, flights_completed))\n",
        "\n",
        "rockets = []\n",
        "for x in range(0,3):\n",
        "    x = randint(0,100)\n",
        "    y = randint(1,100)\n",
        "    rockets.append(Rocket(x, y))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "OKbb6oeYFEWx",
        "outputId": "c7cbed5e-0618-415a-e3c0-46eda517009d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Shuttle 0 has completed 8 flights.\n",
            "Shuttle 1 has completed 6 flights.\n",
            "Shuttle 2 has completed 9 flights.\n",
            "\n",
            "\n",
            "The first shuttle is 0.000000 units away from shuttle 0.\n",
            "The first shuttle is 40.199502 units away from shuttle 1.\n",
            "The first shuttle is 30.886890 units away from shuttle 2.\n"
          ]
        }
      ],
      "source": [
        "# Show the number of flights completed for each shuttle.\n",
        "for index, shuttle in enumerate(shuttles):\n",
        "    print(\"Shuttle %d has completed %d flights.\" % (index, shuttle.flights_completed))\n",
        "\n",
        "print(\"\\n\")\n",
        "# Show the distance from the first shuttle to all other shuttles.\n",
        "first_shuttle = shuttles[0]\n",
        "for index, shuttle in enumerate(shuttles):\n",
        "    distance = first_shuttle.get_distance(shuttle)\n",
        "    print(\"The first shuttle is %f units away from shuttle %d.\" % (distance, index))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c-peE3ysFEWy",
        "outputId": "56bca7b5-42f8-469a-ecdb-9a877023cafd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "The first shuttle is 40.311289 units away from rocket 0.\n",
            "The first shuttle is 15.556349 units away from rocket 1.\n",
            "The first shuttle is 76.694198 units away from rocket 2.\n"
          ]
        }
      ],
      "source": [
        "print(\"\\n\")\n",
        "# Show the distance from the first shuttle to all other rockets.\n",
        "for index, rocket in enumerate(rockets):\n",
        "    distance = first_shuttle.get_distance(rocket)\n",
        "    print(\"The first shuttle is %f units away from rocket %d.\" % (distance, index))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "odTeFCu2FEWy"
      },
      "source": [
        "Inheritance is a powerful feature of object-oriented programming. Using just what you have seen so far about classes, you can model an incredible variety of real-world and virtual phenomena with a high degree of accuracy. The code you write has the potential to be stable and reusable in a variety of applications."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JkECNqJVFEWy"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fHLCRtnfFEWy"
      },
      "source": [
        "<a name='exercises_inheritance'></a>Exercises\n",
        "---\n",
        "#### <a name='exercise_student_class'></a>Student Class\n",
        "- Start with your program from [Person Class](#exercise_person_class).\n",
        "- Make a new class called Student that inherits from Person.\n",
        "- Define some attributes that a student has, which other people don't have.\n",
        "    - A student has a school they are associated with, a graduation year, a gpa, and other particular attributes.\n",
        "- Create a Student object, and prove that you have used inheritance correctly.\n",
        "    - Set some attribute values for the student, that are only coded in the Person class.\n",
        "    - Set some attribute values for the student, that are only coded in the Student class.\n",
        "    - Print the values for all of these attributes.\n",
        "\n",
        "#### Refining Shuttle\n",
        "- Take the latest version of the [Shuttle class](#shuttle). Extend it.\n",
        "    - Add more attributes that are particular to shuttles such as maximum number of flights, capability of supporting spacewalks, and capability of docking with the ISS.\n",
        "    - Add one more method to the class, that relates to shuttle behavior. This method could simply print a statement, such as \"Docking with the ISS,\" for a dock_ISS() method.\n",
        "    - Prove that your refinements work by creating a Shuttle object with these attributes, and then call your new method."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Crw7D-3eFEWz"
      },
      "outputs": [],
      "source": [
        "# Ex 9.7 : Student Class\n",
        "\n",
        "# put your code here"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3FMS6tFUFEWz"
      },
      "outputs": [],
      "source": [
        "# Ex 9.8 : Refining Shuttle\n",
        "\n",
        "# put your code here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0bidrfKBFEWz"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9tMTqlMiFEWz"
      },
      "source": [
        "<a name='modules_classes'></a>Modules and classes\n",
        "===\n",
        "Now that you are starting to work with classes, your files are going to grow longer. This is good, because it means your programs are probably doing more interesting things. But it is bad, because longer files can be more difficult to work with. Python allows you to save your classes in another file and then import them into the program you are working on. This has the added advantage of isolating your classes into files that can be used in any number of different programs. As you use your classes repeatedly, the classes become more reliable and complete overall."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ukILkhXKFEW0"
      },
      "source": [
        "<a name='single_class_module'></a>Storing a single class in a module\n",
        "---\n",
        "\n",
        "When you save a class into a separate file, that file is called a **module**. You can have any number of classes in a single module. There are a number of ways you can then import the class you are interested in.\n",
        "\n",
        "Start out by saving just the Rocket class into a file called *rocket.py*. Notice the naming convention being used here: the module is saved with a lowercase name, and the class starts with an uppercase letter."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KSXgilu7FEW0"
      },
      "source": [
        "This convention is pretty important for a number of reasons, and it is a really good idea to follow the convention."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0OyrmajTFEW0"
      },
      "outputs": [],
      "source": [
        "# Save as rocket.py\n",
        "from math import sqrt\n",
        "\n",
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self, x=0, y=0):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def move_rocket(self, x_increment=0, y_increment=1):\n",
        "        # Move the rocket according to the paremeters given.\n",
        "        #  Default behavior is to move the rocket up one unit.\n",
        "        self.x += x_increment\n",
        "        self.y += y_increment\n",
        "\n",
        "    def get_distance(self, other_rocket):\n",
        "        # Calculates the distance from this rocket to another rocket,\n",
        "        #  and returns that value.\n",
        "        distance = sqrt((self.x-other_rocket.x)**2+(self.y-other_rocket.y)**2)\n",
        "        return distance"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QSnI4jIRFEW0"
      },
      "source": [
        "Make a separate file called *rocket_game.py*. If you are more interested in science than games, feel free to call this file something like *rocket_simulation.py*. Again, to use standard naming conventions, make sure you are using a lowercase_underscore name for this file."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kcywA7BmFEW0",
        "outputId": "68d10ad9-d3a4-4ccb-a5d0-5d2e32d89015"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The rocket is at (0, 0).\n"
          ]
        }
      ],
      "source": [
        "# Save as rocket_game.py\n",
        "from rocket import Rocket\n",
        "\n",
        "rocket = Rocket()\n",
        "print(\"The rocket is at (%d, %d).\" % (rocket.x, rocket.y))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QiAvJLqGFEW1"
      },
      "source": [
        "This is a really clean and uncluttered file. A rocket is now something you can define in your programs, without the details of the rocket's implementation cluttering up your file. You don't have to include all the class code for a rocket in each of your files that deals with rockets; the code defining rocket attributes and behavior lives in one file, and can be used anywhere."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DA4scqCaFEW1"
      },
      "source": [
        "The first line tells Python to look for a file called *rocket.py*. It looks for that file in the same directory as your current program. You can put your classes in other directories, but we will get to that convention a bit later. Notice that you do not."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZcnmmL4LFEW1"
      },
      "source": [
        "When Python finds the file *rocket.py*, it looks for a class called *Rocket*. When it finds that class, it imports that code into the current file, without you ever seeing that code. You are then free to use the class Rocket as you have seen it used in previous examples."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TVSlkcrEFEW2"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5pesrP_lFEW2"
      },
      "source": [
        "<a name='multiple_classes_module'></a>Storing multiple classes in a module\n",
        "---\n",
        "\n",
        "A module is simply a file that contains one or more classes or functions, so the Shuttle class actually belongs in the rocket module as well:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MQH0vE6AFEW2"
      },
      "outputs": [],
      "source": [
        "# Save as rocket.py\n",
        "from math import sqrt\n",
        "\n",
        "class Rocket():\n",
        "    # Rocket simulates a rocket ship for a game,\n",
        "    #  or a physics simulation.\n",
        "\n",
        "    def __init__(self, x=0, y=0):\n",
        "        # Each rocket has an (x,y) position.\n",
        "        self.x = x\n",
        "        self.y = y\n",
        "\n",
        "    def move_rocket(self, x_increment=0, y_increment=1):\n",
        "        # Move the rocket according to the paremeters given.\n",
        "        #  Default behavior is to move the rocket up one unit.\n",
        "        self.x += x_increment\n",
        "        self.y += y_increment\n",
        "\n",
        "    def get_distance(self, other_rocket):\n",
        "        # Calculates the distance from this rocket to another rocket,\n",
        "        #  and returns that value.\n",
        "        distance = sqrt((self.x-other_rocket.x)**2+(self.y-other_rocket.y)**2)\n",
        "        return distance\n",
        "\n",
        "\n",
        "class Shuttle(Rocket):\n",
        "    # Shuttle simulates a space shuttle, which is really\n",
        "    #  just a reusable rocket.\n",
        "\n",
        "    def __init__(self, x=0, y=0, flights_completed=0):\n",
        "        super().__init__(x, y)\n",
        "        self.flights_completed = flights_completed"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o9fFB-cuFEW2"
      },
      "source": [
        "Now you can import the Rocket and the Shuttle class, and use them both in a clean uncluttered program file:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Xf4VdxOgFEW3",
        "outputId": "7aeb140f-7787-4b43-fe01-a11f16623b83"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The rocket is at (0, 0).\n",
            "\n",
            "The shuttle is at (0, 0).\n",
            "The shuttle has completed 0 flights.\n"
          ]
        }
      ],
      "source": [
        "# Save as rocket_game.py\n",
        "from rocket import Rocket, Shuttle\n",
        "\n",
        "rocket = Rocket()\n",
        "print(\"The rocket is at (%d, %d).\" % (rocket.x, rocket.y))\n",
        "\n",
        "shuttle = Shuttle()\n",
        "print(\"\\nThe shuttle is at (%d, %d).\" % (shuttle.x, shuttle.y))\n",
        "print(\"The shuttle has completed %d flights.\" % shuttle.flights_completed)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C7HFYaS-FEW3"
      },
      "source": [
        "The first line tells Python to import both the *Rocket* and the *Shuttle* classes from the *rocket* module. You don't have to import every class in a module; you can pick and choose the classes you care to use, and Python will only spend time processing those particular classes."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wlEcZZ7xFEW3"
      },
      "source": [
        "<a name='multiple_ways_import'></a>A number of ways to import modules and classes\n",
        "---\n",
        "There are several ways to import modules and classes, and each has its own merits."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EVD78yFLFEW3"
      },
      "source": [
        "### import *module_name*\n",
        "\n",
        "The syntax for importing classes that was just shown:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bTfZi_FeFEW3"
      },
      "outputs": [],
      "source": [
        "from module_name import ClassName"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "05T9nZC1FEW4"
      },
      "source": [
        "is straightforward, and is used quite commonly. It allows you to use the class names directly in your program, so you have very clean and readable code. This can be a problem, however, if the names of the classes you are importing conflict with names that have already been used in the program you are working on. This is unlikely to happen in the short programs you have been seeing here, but if you were working on a larger program it is quite possible that the class you want to import from someone else's work would happen to have a name you have already used in your program."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nHvuY_l4FEW4"
      },
      "source": [
        "In this case, you can use simply import the module itself:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TFAS3F7MFEW4",
        "outputId": "932b12b3-4b08-4309-a98d-7250b868673f"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The rocket is at (0, 0).\n",
            "\n",
            "The shuttle is at (0, 0).\n",
            "The shuttle has completed 0 flights.\n"
          ]
        }
      ],
      "source": [
        "# Save as rocket_game.py\n",
        "import rocket\n",
        "\n",
        "rocket_0 = rocket.Rocket()\n",
        "print(\"The rocket is at (%d, %d).\" % (rocket_0.x, rocket_0.y))\n",
        "\n",
        "shuttle_0 = rocket.Shuttle()\n",
        "print(\"\\nThe shuttle is at (%d, %d).\" % (shuttle_0.x, shuttle_0.y))\n",
        "print(\"The shuttle has completed %d flights.\" % shuttle_0.flights_completed)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vYG2v3kmFEW4"
      },
      "source": [
        "The general syntax for this kind of import is:\n",
        "\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "FcF20lY8FEW5"
      },
      "outputs": [],
      "source": [
        "import module_name"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8LOsXGmTFEW5"
      },
      "source": [
        "After this, classes are accessed using dot notation:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pT0l4uj5FEW5"
      },
      "outputs": [],
      "source": [
        "module_name.ClassName"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GlXqv7IsFEW5"
      },
      "source": [
        "This prevents some name conflicts. If you were reading carefully however, you might have noticed that the variable name *rocket* in the previous example had to be changed because it has the same name as the module itself. This is not good, because in a longer program that could mean a lot of renaming."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "haJgC7DvFEW5"
      },
      "source": [
        "### import *module_name* as *local_module_name*\n",
        "\n",
        "There is another syntax for imports that is quite useful:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "agckAdxXFEW5"
      },
      "outputs": [],
      "source": [
        "import module_name as local_module_name"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xtm-QPdgFEW6"
      },
      "source": [
        "When you are importing a module into one of your projects, you are free to choose any name you want for the module in your project. So the last example could be rewritten in a way that the variable name *rocket* would not need to be changed:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Od7Fq6lCFEW6",
        "outputId": "b5866e92-2018-41c0-b6ab-087bcaf3d037"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The rocket is at (0, 0).\n",
            "\n",
            "The shuttle is at (0, 0).\n",
            "The shuttle has completed 0 flights.\n"
          ]
        }
      ],
      "source": [
        "# Save as rocket_game.py\n",
        "import rocket as rocket_module\n",
        "\n",
        "rocket = rocket_module.Rocket()\n",
        "print(\"The rocket is at (%d, %d).\" % (rocket.x, rocket.y))\n",
        "\n",
        "shuttle = rocket_module.Shuttle()\n",
        "print(\"\\nThe shuttle is at (%d, %d).\" % (shuttle.x, shuttle.y))\n",
        "print(\"The shuttle has completed %d flights.\" % shuttle.flights_completed)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N6iLvaKkFEW6"
      },
      "source": [
        "This approach is often used to shorten the name of the module, so you don't have to type a long module name before each class name that you want to use. But it is easy to shorten a name so much that you force people reading your code to scroll to the top of your file and see what the shortened name stands for. In this example,"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4bgmEgmdFEW6"
      },
      "outputs": [],
      "source": [
        "import rocket as rocket_module"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WRKFFgwgFEW7"
      },
      "source": [
        "leads to much more readable code than something like:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QD1AMyxKFEW7"
      },
      "outputs": [],
      "source": [
        "import rocket as r"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rGnqUoOoFEW7"
      },
      "source": [
        "### from *module_name* import *\n",
        "There is one more import syntax that you should be aware of, but you should probably avoid using. This syntax imports all of the available classes and functions in a module:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EubjI3BRFEW7"
      },
      "outputs": [],
      "source": [
        "from module_name import *"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fM3OZvLTFEW8"
      },
      "source": [
        "This is not recommended, for a couple reasons. First of all, you may have no idea what all the names of the classes and functions in a module are. If you accidentally give one of your variables the same name as a name from the module, you will have naming conflicts. Also, you may be importing way more code into your program than you need.\n",
        "\n",
        "If you really need all the functions and classes from a module, just import the module and use the `module_name.ClassName` syntax in your program."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sOhI67-lFEW8"
      },
      "source": [
        "You will get a sense of how to write your imports as you read more Python code, and as you write and share some of your own code."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gF7d-9oqFEW8"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P-G6ku7_FEW9"
      },
      "source": [
        "<a name='module_functions'></a>A module of functions\n",
        "---\n",
        "You can use modules to store a set of functions you want available in different programs as well, even if those functions are not attached to any one class. To do this, you save the functions into a file, and then import that file just as you saw in the last section. Here is a really simple example; save this is *multiplying.py*:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Bgv1inXBFEW9"
      },
      "outputs": [],
      "source": [
        "# Save as multiplying.py\n",
        "def double(x):\n",
        "    return 2*x\n",
        "\n",
        "def triple(x):\n",
        "    return 3*x\n",
        "\n",
        "def quadruple(x):\n",
        "    return 4*x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U3MDAlp7FEW9"
      },
      "source": [
        "Now you can import the file *multiplying.py*, and use these functions. Using the `from module_name import function_name` syntax:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ckxMsUnhFEW-",
        "outputId": "77e88556-62e8-46b8-f8b3-d5c82a526a40"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10\n",
            "15\n",
            "20\n"
          ]
        }
      ],
      "source": [
        "from multiplying import double, triple, quadruple\n",
        "\n",
        "print(double(5))\n",
        "print(triple(5))\n",
        "print(quadruple(5))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O_bmiuq4FEW-"
      },
      "source": [
        "Using the `import module_name` syntax:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_7mok4tHFEW-",
        "outputId": "306f968c-52fd-4655-8b56-68f1e49b23a8"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10\n",
            "15\n",
            "20\n"
          ]
        }
      ],
      "source": [
        "import multiplying\n",
        "\n",
        "print(multiplying.double(5))\n",
        "print(multiplying.triple(5))\n",
        "print(multiplying.quadruple(5))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bwlsvH_cFEW_"
      },
      "source": [
        "Using the `import module_name as local_module_name` syntax:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xs9P7zgQFEW_",
        "outputId": "d049aa56-2fa3-4e5a-b084-b849207fc937"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10\n",
            "15\n",
            "20\n"
          ]
        }
      ],
      "source": [
        "import multiplying as m\n",
        "\n",
        "print(m.double(5))\n",
        "print(m.triple(5))\n",
        "print(m.quadruple(5))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nS5CDEM9FEXA"
      },
      "source": [
        "Using the `from module_name import *` syntax:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7aP8srbAFEXA",
        "outputId": "c93c7f86-3f42-4a05-8c47-d6b1b1b33573"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "10\n",
            "15\n",
            "20\n"
          ]
        }
      ],
      "source": [
        "from multiplying import *\n",
        "\n",
        "print(double(5))\n",
        "print(triple(5))\n",
        "print(quadruple(5))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_pwnqkAoFEXB"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FIPxmDWCFEXC"
      },
      "source": [
        "<a name='exercises_importing'></a>Exercises\n",
        "---\n",
        "#### Importing Student\n",
        "- Take your program from [Student Class](#exercise_student_class)\n",
        "    - Save your Person and Student classes in a separate file called *person.py*.\n",
        "    - Save the code that uses these classes in four separate files.\n",
        "        - In the first file, use the `from module_name import ClassName` syntax to make your program run.\n",
        "        - In the second file, use the `import module_name` syntax.\n",
        "        - In the third file, use the `import module_name as different_local_module_name` syntax.\n",
        "        - In the fourth file, use the `import *` syntax.\n",
        "        \n",
        "#### Importing Car\n",
        "- Take your program from [Car Class](#exercise_car_class)\n",
        "    - Save your Car class in a separate file called *car.py*.\n",
        "    - Save the code that uses the car class into four separate files.\n",
        "        - In the first file, use the `from module_name import ClassName` syntax to make your program run.\n",
        "        - In the second file, use the `import module_name` syntax.\n",
        "        - In the third file, use the `import module_name as different_local_module_name` syntax.\n",
        "        - In the fourth file, use the `import *` syntax."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LvzlaDgtFEXD"
      },
      "outputs": [],
      "source": [
        "# Ex 9.9 : Importing Student\n",
        "\n",
        "# put your code here"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vn3S1mnKFEXE"
      },
      "outputs": [],
      "source": [
        "# Ex 9.10 : Importing Car\n",
        "\n",
        "# put your code here"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pz6fDy6YFEXE"
      },
      "source": [
        "[top](#top)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qXET0cilFEXE"
      },
      "source": [
        "<a name=\"mro\"></a>Method Resolution Order (`mro`)\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PhsLQZMdFEXE",
        "outputId": "3a8f9ba6-fc2e-491a-9900-eae8f3c18a0c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "MRO:  [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class '__main__.GreatB'>, <class 'object'>]\n",
            "c.a:  A\n",
            "c.b:  B\n",
            "Greetings from Type:  <class '__main__.C'>\n",
            "Greetings from Type:  <class '__main__.C'>\n",
            "Greetings from Type:  <class '__main__.C'>\n"
          ]
        }
      ],
      "source": [
        "class A:\n",
        "    def __init__(self, a):\n",
        "        self.a = a\n",
        "\n",
        "\n",
        "class GreatB:\n",
        "\n",
        "    def greetings(self):\n",
        "        print('Greetings from Type: ', self.__class__)\n",
        "\n",
        "class B(GreatB):\n",
        "    def __init__(self, b):\n",
        "        self.b = b\n",
        "\n",
        "\n",
        "class C(A,B):\n",
        "    def __init__(self, a, b):\n",
        "        A.__init__(self, a)\n",
        "        B.__init__(self, b)\n",
        "\n",
        "print('MRO: ', C.mro())\n",
        "c = C('A', 'B')\n",
        "print('c.a: ', c.a)\n",
        "print('c.b: ', c.b)\n",
        "\n",
        "c.greetings()\n",
        "super(C, c).greetings()\n",
        "super(B, c).greetings()\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.5.1"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}