assignments/Ind_Assignment_2_Object_Orientation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Object-Oriented Programming (OOP) Assignment\n",
    "\n",
    "Welcome to your second individual assignment, where we delve into the fundamental concepts of Object-Oriented Programming (OOP) in Python. In this assignment, you will embark on a journey to transform how you think about solving problems in Python—shifting from a procedural approach to one that models real-world entities and their interactions as objects.\n",
    "\n",
    "## Why OOP?\n",
    "\n",
    "Object-Oriented Programming is a powerful paradigm that allows developers to structure software in a way that is both modular and scalable. By thinking in terms of objects, you can create systems that are easier to understand, maintain, and extend. In this assignment, you will not only learn how to create and manipulate objects in Python, but you will also explore how these objects can be organized into classes, how they can inherit and extend behaviors, and how you can leverage design patterns to solve common problems efficiently.\n",
    "\n",
    "## What You Will Learn\n",
    "\n",
    "By the end of this assignment, you will have achieved the following:\n",
    "\n",
    "1. **Mastered OOP Fundamentals**: You'll start with the basics of classes and objects, understanding how they serve as the building blocks of Python programs.\n",
    "2. **Developed Object-Oriented Thinking**: You will practice designing systems that encapsulate functionality within objects, thinking about how these objects interact to perform tasks.\n",
    "3. **Explored OOP Design Patterns**: You will be introduced to common design patterns that solve recurring problems in software design, enhancing your ability to write clean and reusable code.\n",
    "4. **Applied Advanced OOP Techniques**: Finally, you will implement more advanced concepts like inheritance, polymorphism, and abstraction, solidifying your understanding of how to create robust, scalable systems.\n",
    "\n",
    "## The Importance of Practice\n",
    "\n",
    "As you work through the tasks in this assignment, remember that OOP is not just about writing code—it's about modeling the complexities of the real world in a way that is both intuitive and powerful. The exercises are designed to help you think critically about how to structure your code and apply best practices that will serve you well in this course and beyond.\n",
    "\n",
    "## Let’s Get Started\n",
    "\n",
    "Take your time to explore each concept and exercise, and don't hesitate to revisit the materials provided in class if you need a refresher. This assignment is a key step in your journey towards becoming proficient in Python and OOP, so embrace the challenge and enjoy the process of learning!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Try it– Developing Classes and Manipulating Objects\n",
    "\n",
    "The objective of this assignment is to provide you with hands-on experience in creating and manipulating objects in Python using object-oriented programming concepts. You will gain proficiency in defining classes, creating instances, setting attributes, and implementing methods.\n",
    "\n",
    "This first step is to create the **class** - a definition of what an **object** of that class will look like.  The class is a blueprint for the object.  The object is the actual instance of the class that you will be working with.  Classes define the attributes (data) and methods (functions) that the object will have.  \n",
    "\n",
    "So just like we have an idea of what a car is, we can define a class for a car that has attributes like *make*, *model*, *year*, and *color*, and methods like *start*, *stop*, and *drive*.  The object is the actual instance of the class that has specific values for those attributes, in this case the actual car in my driveway, a 2015 Honda Civic, white.\n",
    "\n",
    "## Step 1 - Object Instantiation\n",
    "Here we are going to play around with creating instances of the class (```Person```) that have been defined for you and then manipulating them after they are created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This module contains the People class, which is used to create a list of people and the different types of people in our system\n",
    "# Create a class called Person which is the base class from which other classes will inherit.\n",
    "class Person:\n",
    "\n",
    "    # A person has an ID, first name and last name\n",
    "    def __init__(self, id, first_name, last_name):\n",
    "        # We are using the set_id method to set the id property of the person\n",
    "        #  this ensures that all the checks we setup are run when we create a new person\n",
    "        self.id = id\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "\n",
    "    # The id property is a unique identifier for each person\n",
    "    # You may have noticed that we are using a getter and setter for the id property\n",
    "    #  this is because we want to ensure that the id is always a positive integer\n",
    "    @property\n",
    "    def id(self):\n",
    "        # Notice that _id is a protected property,\n",
    "        #   this means that it can only be accessed by the Person class and any classes that inherit from it\n",
    "        return self._id\n",
    "\n",
    "    # The setter for the id property.  This ensure we can do checks before accepting the value\n",
    "    @id.setter\n",
    "    def id(self, id):\n",
    "        # Check if the id is a positive integer, if not raise an exception\n",
    "        if id < 0:\n",
    "            raise ValueError(\"ID must be a positive integer\")\n",
    "        self._id = id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have defined the class ```Person```, we can create instances of this class, also known as objects. Each object will represent a specific person with a first name, last name, and age."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a new person object\n",
    "p = Person(1, \"John\", \"Doe\")\n",
    "print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll notice that when we ```print``` the object we get some nasty output.  This is because we haven't defined a ```__str__``` method in the class.  We'll discuss how we would fix this later in the assignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's look at some of their details\n",
    "print(f\"Our person object's first name is: {p.first_name}\")\n",
    "print(f\"Our person object's last name is: {p.last_name}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Notice here that in the class there is no id property (the property is _id), but we can still access it\n",
    "# this is because we have created a getter and setter for the id property\n",
    "print(\"Our person object's ID is: \", p.id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Again, we can set the id property even though it is not directly accessible\n",
    "p.id = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this next block try setting the value of id to something other than 1.  What happens?  Why?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You try setting the id to something other than a positive integer\n",
    "p.id = -1\n",
    "# You should get an error message\n",
    "# This is because our code in the setter method checks that the id is a positive integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## __str__ and __repr__ methods\n",
    "Notice above when we `print(p)` how it showed something like `<__main__.Person object at 0x7f567c7caf10>`.  This is telling us that there is an object here and the memory address at which the object of type `Person` is stored.  This is quite ugly.  \n",
    "\n",
    "We can improve this if we like by overriding one or both of the methods `__str__` and `__repr__` (these are auto-inherited from the default base Class `object` provided by Python).\n",
    "\n",
    "`__str__()` is used to provide a human readable string representation of the object.  It's called automatically whenever you use the `print()` or `str()` methods.  Though keep in mind, if you loop through an array of objects, you are not really printing the object, instead you are getting the representation of the object.\n",
    "\n",
    "`__repr__()` is used to provide an unambigious representation of the object.  By default it returns the ugly string you've seen above `<__main__.Person object at ...`.  It is helpful for debugging, but if you want to make sure that whenever you print or otherwise output a representation of your object it is pretty, you can override this method.\n",
    "\n",
    "I've provided an example of how to override the `__str__` method in the `Person` class below.  Try it out and see how it changes the output of the `print(p)` statement.  You can also try overriding the `__repr__` method if you like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is the same definition as the Person class, but with __str__ and __repr__ methods added\n",
    "class RealPerson:\n",
    "\n",
    "    # A person has an ID, first name and last name\n",
    "    def __init__(self, id, first_name, last_name):\n",
    "        # We are using the set_id method to set the id property of the person\n",
    "        #  this ensures that all the checks we setup are run when we create a new person\n",
    "        self.id = id\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "\n",
    "    # The id property is a unique identifier for each person\n",
    "    # You may have noticed that we are using a getter and setter for the id property\n",
    "    #  this is because we want to ensure that the id is always a positive integer\n",
    "    @property\n",
    "    def id(self):\n",
    "        # Notice that _id is a protected property,\n",
    "        #   this means that it can only be accessed by the Person class and any classes that inherit from it\n",
    "        return self._id\n",
    "\n",
    "    # The setter for the id property.  This ensure we can do checks before accepting the value\n",
    "    @id.setter\n",
    "    def id(self, id):\n",
    "        # Check if the id is a positive integer, if not raise an exception\n",
    "        if id < 0:\n",
    "            raise ValueError(\"ID must be a positive integer\")\n",
    "        self._id = id\n",
    "        \n",
    "    # This method is called when we use the print function on a RealPerson object\n",
    "    def __str__(self):\n",
    "        return f\"Person {self.id}: {self.first_name} {self.last_name}\"\n",
    "    \n",
    "    # This method is called when we use the repr function on a RealPerson object\n",
    "    def __repr__(self):\n",
    "        return f\"RealPerson({self.id}, {self.first_name}, {self.last_name})\"\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at what this does when we use the `print()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rp = RealPerson(1, \"John\", \"Doe\")  \n",
    "print(rp) # This will call the __str__ method\n",
    "rp # This will call the __repr__ method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rp = RealPerson(1, \"John\", \"Doe\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your Turn - Part 1\n",
    "The next cell shows how to use the class we created above.  Remember a class is a blueprint, a container of sorts, which has spots for all the data we want to store about a particular \"thing\" (in this case, the thing is a person.)  We can fill in the data about the \"thing\" when we create an instance of the the thing (using a special function called a constructor ```__init__```) or we can set these values after we create the person."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a person called John Smith\n",
    "new_person = Person(1,\"John\", \"Smith\")\n",
    "# Print out the person's details:\n",
    "#  Print the person's ID\n",
    "print(\"Id: \", new_person.id)\n",
    "#  Print the person's first name\n",
    "print(\"First Name: \", new_person.first_name)\n",
    "#  Print the person's last name\n",
    "print(\"Last Name: \", new_person.last_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Following the comments below, create a new person object (an instance of the Person class), print their details, change their name and print their details again.\n",
    "\n",
    "**_Note_: You can break this up into as many cells as you find helpful**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a person called Susan Jones with ID 2\n",
    "# Print out Susan's details:\n",
    "#  Print the Susan's ID\n",
    "#  Print the Susan's first name\n",
    "#  Print the Susan's last name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Susan and John decided to get married and so Susan changed her last name.  Update the object with Susan's information to reflect her new name.  (Don't create a new object, just update the current one)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Change the person's last name to Smith-Jones\n",
    "# Print out the person's details again"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 2 - Class inheritance\n",
    "Inheritance is a powerful feature of object-oriented programming that allows you to define a new class based on an existing class. The new class, known as a subclass, inherits attributes and methods from the existing class, known as a superclass. This allows you to reuse code and create a hierarchy of classes that model real-world relationships.  For instance, we could have a class `Person` and a subclass `Student` that inherits from `Person`.  The `Student` class would have all the attributes and methods of the `Person` class, but could also have additional attributes and methods that are specific to a student.  Let's see how this works.\n",
    "\n",
    "Now we are going to get a little more specific and define `Instructor`, which is a special kind of `Person` that happens to teach `Course(s)` at our university.  The following code snippet defines the `Instructor` class and the `Course` class.\n",
    "\n",
    "`Instructor` has the following attributes:\n",
    "- `first_name` (inherits from Person)\n",
    "- `last_name` (inherits from Person)\n",
    "- `id` (inherits from Person)\n",
    "- `courses` (a list of courses the instructor teaches)\n",
    "- `first_year_teaching` (the first year the instructor started teaching at the university)\n",
    "\n",
    "and the following functions\n",
    "- `add_course(course)` (adds a course to the list of courses the instructor teaches)\n",
    "- `remove_course(course)` (removes a course from the list of courses the instructor teaches)\n",
    "\n",
    "**NOTE**: While not required by syntax, it is a good practice to capitalize the first letter of each word in a class name.  It's helpful to differentiate classes from variables and functions which are typically lowercase.\n",
    "**NOTE2**: In Python, we can \"hide\" attributes by prepending them with an underscore. This is a convention to let other developers know that they should not be directly accessed.  Instead, we should use a method to access or modify these attributes.  This is a form of encapsulation, which is a key concept in OOP.  You see in the instructor class `_courses_teaching`, we don't want users of the class manipulating this list directly, but rather we want them to use the `add_course()`, `remove_course()`, `get_courses()` functions instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a class called course\n",
    "# A course is a class that a student can take and an instructor can teach\n",
    "class Course:\n",
    "\n",
    "    # A course has a course ID, course name, description, department and credits\n",
    "    def __init__(self, course_number, course_name, description, department, credits):\n",
    "        # By setting these properties to default values we can ensure that they are always set\n",
    "        self.credits = credits\n",
    "        self.course_name = course_name\n",
    "        self.description = description\n",
    "        self.department = department\n",
    "\n",
    "        # Using the setter for the course number we can ensure that the value is correct\n",
    "        self.course_number = course_number\n",
    "        \n",
    "    # The course number is a unique identifier for each course\n",
    "    @property\n",
    "    def course_number(self):\n",
    "        return self._course_number\n",
    "\n",
    "    # The course number is a unique identifier for each course which must be greater than 0\n",
    "    # Also, at the UofA the last number in the course number is the number of credits\n",
    "    @course_number.setter\n",
    "    def course_number(self, course_number):\n",
    "        if course_number < 0:\n",
    "            raise ValueError(\"Course number must be a positive integer\")\n",
    "        # Checking the last digit of the course number is the number of credits\n",
    "        if course_number % 10 != self.credits:\n",
    "            raise ValueError(\"The last digit of the course number must be the number of credits\")\n",
    "        self._course_number = course_number\n",
    "\n",
    "    # The course ID is a combination of the department and course number\n",
    "    # It can't be set directly, but can be retrieved\n",
    "    @property\n",
    "    def course_id(self):\n",
    "        return f'{self.department}{self.course_number}'\n",
    "    \n",
    "    # This method is called when we use the print function on a Course object\n",
    "    def __str__(self):\n",
    "        return f\"{self.course_id}: {self.course_name}\"\n",
    "\n",
    "\n",
    "# Create a class called Instructor which inherits from the Person class\n",
    "# An instructor is a person who teaches one or more courses\n",
    "class Instructor(Person):\n",
    "\n",
    "    # An instructor has an ID, first name, last name, and first year teaching\n",
    "    def __init__(self, id, first_name, last_name, first_year_teaching=1950):\n",
    "        # Initialize the Person class\n",
    "        super().__init__(id, first_name, last_name)\n",
    "        # By using the setter for the first year teaching we can ensure that the value is correct\n",
    "        #  If we were to just do 'self._first_year_teaching = first_year_teaching', we would be bypassing the checks\n",
    "        self.first_year_teaching = first_year_teaching\n",
    "        \n",
    "        # We want to ensure that someone doesn't accidentally change the value of the courses_teaching property\n",
    "        #  so we are going to make it a protected property\n",
    "        self._courses = {}\n",
    "\n",
    "    # Build a property for the first year teaching\n",
    "    @property\n",
    "    def first_year_teaching(self):\n",
    "        return self._first_year_teaching\n",
    "\n",
    "    @first_year_teaching.setter\n",
    "    def first_year_teaching(self, year):\n",
    "        # We will check to ensure that the first year teaching is after 1950\n",
    "        if year < 1950:\n",
    "            raise ValueError(\"First year teaching must be a positive integer after 1950\")\n",
    "        self._first_year_teaching = year\n",
    "\n",
    "    # An instructor can teach a course\n",
    "    def add_course(self, course):\n",
    "        if course.course_id in self._courses:\n",
    "            raise ValueError(\"Instructor is already teaching this course\")\n",
    "        self._courses[course.course_id] = course\n",
    "\n",
    "    # An instructor can stop teaching a course\n",
    "    def remove_course(self, course):\n",
    "        if course.course_id not in self._courses_teaching:\n",
    "            raise ValueError(\"Instructor is not teaching this course\")\n",
    "        del self._courses[course.course_id]\n",
    "\n",
    "    # An instructor can get a list of courses they are teaching\n",
    "    #  We didn't create a setter for this property because we don't want someone to accidentally change the list\n",
    "    @property\n",
    "    def courses(self):\n",
    "        # We are just going to return the courses (the values) from the dictionary\n",
    "        return self._courses.values()\n",
    "\n",
    "    # This method is called when we use the print function on an Instructor object\n",
    "    def __str__(self):\n",
    "        return f\"Instructor {self.id}: {self.first_name} {self.last_name}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice we have added a property (```courses```) and a few methods for dealing with the courses ```add_course()```, ```remove_course()```.  Again, since we have created only a **getter** for the ```courses``` property, there is no way to set the ```courses``` property directly.\n",
    "\n",
    "```python\n",
    "    new_instructor = Instructor(1, 'James', 'Beam',2020)\n",
    "    # This will return an error\n",
    "    new_course = Course(5713,'Advanced Python',\"Introduction to advanced Python programming\",'ISYS',3)\n",
    "    new_instructor.courses = new_course\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "isys_1234 = Course(1234, \"Introduction to Programming\", \"This course introduces students to programming\", \"ISYS\", 4)\n",
    "isys_5713 = Course(course_number=5713, \n",
    "                   course_name=\"Advanced Programming\", \n",
    "                   description=\"This course introduces students to advanced programming\", \n",
    "                   department=\"ISYS\",\n",
    "                   credits= 3)\n",
    "# Get the default representation of the course\n",
    "print(isys_1234)\n",
    "print()\n",
    "# Print the details associated with the course\n",
    "print(isys_1234.course_name)\n",
    "print('----------')\n",
    "print(f'{isys_1234.department}{isys_1234.course_number}')\n",
    "print(isys_1234.description)\n",
    "print(f'credits: {isys_1234.credits}')\n",
    "print()\n",
    "\n",
    "# Get the default representation of the course\n",
    "print(isys_5713)\n",
    "print()\n",
    "print(isys_5713.course_name)\n",
    "print('----------')\n",
    "print(f'{isys_5713.department}{isys_5713.course_number}')\n",
    "print(isys_5713.description)\n",
    "print(f'credits: {isys_5713.credits}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's add a course to the instructor's list of courses.  We can do this by calling the `add_course()` method.  Let's see how this works.  We would similarly use the `remove_course()` method to remove a course from the instructor's list of courses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_instructor = Instructor(1, \"James\", \"Beam\", 2020)\n",
    "# We've defined two courses in the previous cell, isys_1234 and isys_5713, let's add them\n",
    "#  to the instructor's list of courses\n",
    "new_instructor.add_course(isys_1234)\n",
    "new_instructor.add_course(isys_5713)\n",
    "\n",
    "for course in new_instructor.courses:\n",
    "    print(course)\n",
    "    print(f'Course Department: {course.department}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A key note here.  We are adding `Courses` (objects of type `Course`) to an `Instructor` object.  While this may look like we are just adding strings, we are in fact adding `Course` objects.  This is a key concept in OOP.  We can have objects that are made up of other objects.  This is called **composition**.  We are composing the `Instructor` object of `Course` objects.  This is a powerful concept that allows us to model complex systems in a very intuitive way.\n",
    "\n",
    "If you just add the course as a string, then we don't get all the other features of the `Course` object.  For instance, we can't get the `id` of the course, the `department` or `credits`.  So it's important to add the actual `Course` object to the `Instructor` object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Your Turn #2\n",
    "Define a new instructor according to the code comments below and follow the steps as outlined.  You should use as many notebook cells as you like (for instance, you may prefer to create one cell for each modification, showing the before and after at each step)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create an instructor called Alex Abbott , he started teaching in 2015 and teaches ISYS1234\n",
    "# Print out the instructor's details\n",
    "# Print out the courses the instructor is teaching (include the number, name, description and department)\n",
    "# Add a new course for the instructor to teach (ISYS5713)\n",
    "# Print out the courses the instructor is teaching (include the number, name, description and department)\n",
    "# Remove a course for the instructor to teach\n",
    "# Print out the courses the instructor is teaching (include the number, name, description and department)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3 - Creating new classes\n",
    "Now it's time to venture out on your own.  Here you should create a `Student` class.  `Student`s are a special type of `Person`.  They are similar to `Instructor`s in that they also have `Course`s, but they also have some unique features like `grade point averages`.  They don't have a year they began teaching, so we can't inherit from the `Instructor` class, but like the `Instructor` class, we should have a way to add and remove courses from the student's schedule without manipulating the list directly.\n",
    "\n",
    "### Your Turn #3\n",
    "1. Create a `Student` class.  It should be a subclass of `Person`, but also have a list of courses they are currently taking and a current grade point average (int)\n",
    "2. Create a `Student` object for a student called _Susan Smartinez_, you can choose her GPA and which courses she is taking\n",
    "3. Add a course, remove a course, and update her GPA.  Show the results of each step along the way.\n",
    "\n",
    "***For extra credit, modify the student class to keep track of the grade for each course and the semester it was taken***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# STEP 1: Create a class called Student which inherits from the Person class\n",
    "# A student is a person who is taking one or more courses and has a GPA\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# STEP 2: Create a Student object called Susan Smartinez who has an ID of 1, a GPA of 3.5 and is taking ISYS1234\n",
    "# Print out the student's details (ID, first name, last name, GPA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# STEP 3a: Add a new course for the student to take (ISYS5713)\n",
    "# Print out the courses the student is taking (include the number, name, description and department)\n",
    "# STEP 3b: Remove a course for the student to take\n",
    "# Print out the courses the student is taking (include the number, name, description and department)\n",
    "# STEP 3c: Change the student's GPA to 4.0\n",
    "# Print out the student's details (ID, first name, last name, GPA)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 4: Create a new class from scratch\n",
    "Now that you have seen how to create a class that inherits from another class, you should create a new class from scratch.  This class should be something that you are familiar with and can easily model in a class.  For instance, you could create a class to model a `Car`, `Animal`, `Book`, etc.  The class should have at least 3 attributes and 3 methods.  You should create an object of this class and demonstrate how to use the methods and access the attributes."
   ]
  }
 ],
 "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.11.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}