{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Document contents\n",
"***\n",
"This document contains 2 sections:\n",
"* **Section 1 (non-graded)**: Lesson 12 review\n",
"* **Section 2 (graded)**: Assignment 12\n",
"\n",
"To improve your understanding of OOP and classes, start by reading through section 1 before working on the assignment (section 2).\n",
"\n",
"\n",
"# *Section 1* - Lesson 12 review\n",
"***\n",
"\n",
"## Introduction to classes\n",
"\n",
"In this assignment, you will be learning about Python classes through practice. As you know from the lesson materials, classes and objects are fundamental concepts in object oriented programming. But to understand this powerful programming model, let's consider the model of programming that we have been using so far. \n",
"\n",
"## Procedural Programming\n",
"Thus far, you have been writing programs that execute a series of commands/calculations to achieve some goal. Your scripts consisted of mainly 3 types of Python objects: functions, iterators, and data containers. These are all objects in Python (they are builtin types from the standard library). So if these are objects, is it fair to say that you have learned object-oriented programming? *Using* objects (like functions) and *creating* objects are different interactions with classes in Python. \n",
"\n",
"Your coding experience in this class has so far been according to the \"procedural programming paradigm\". Procedural programming simply refers to the use of procedures (functions or \"routines\") to execute a series of computational steps. Our focus, then, has been to write \"functions which operate on data\" <sup>[1]</sup>. Notice the specific language in the last statement: the functions operate on the data. In other words, there is separation between the function (i.e. \"the doer\") and the data. Contrast this to object-oriented programming, where the \"focus is on the creation of classes and objects which contain **both data and functionality together**\"<sup>[1]</sup>.\n",
"\n",
"## Object-Oriented Programming *(OOP)*\n",
"\n",
"### Definitional understanding\n",
"\n",
"* When you create a class, you are creating a blueprint for an object. The idea is no different from creating a blueprint for a building or a car. \n",
"* The object, then, is an instance of that blueprint (class). Said differently: an object is a representation or occurrence of a class. \n",
"\n",
"Classes represent the structure of objects. They contain data and methods, which are known as \"functions inside of a class\". Methods perform some calculations on object/instance attributes. There are other kinds of methods as well (which perform operations on the *class* or on unrelated namespaces). For the purpose of this assignment, think of methods as functions that perform some task with respect to the **object** only.\n",
"\n",
"Every time that you create an object, you are \"instantiating\" the class. This is to say, you are creating an *instance* of a class. This instance now has specific attributes and methods. \n",
"\n",
"### Conceptual understanding\n",
"\n",
"Let's explore classes and objects with an example: airplanes. There are many kinds of planes. There are commercial planes, such as the Boeing 777 or Airbus 330. There are cargo planes, such as the Antonov-225 (civilian purposes). There military cargo planes, such as the Boeing Globemaster. There are civilian/corporate planes such as the Gulf Stream G650. And there are military jets, such as the F-22 Raptor. \n",
"\n",
"You get the idea: all of these are planes. If we were to represent these planes programmatically, in OOP, we would do this with a class. And this class would be called *planes*. Now, think about the characteristics of planes. What do they all usually have in common? Usually, they all have two wings, a vertical stabilizer, horizontal stabilizer, engines, landing gear, etc. These are what we call class *attributes*. More specfically, they are object attributes.\n",
"\n",
"Let's say we are writing a program and we want to \"manifest\" or create a plane. How would we do this? We would create a plane by instantiating our blueprint. Yes, the *Plane* class! So, by creating a plane from the *Plane* class, we are creating an instance of a class. In the process, we are passing arguments to our class, which are initiated as object attributes. \n",
"\n",
"### An example\n",
"\n",
"Let's work through a small example. First, create the *Plane* class:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"class Plane(object):\n",
" # Notice the 'self' keyword. It refers to the object itself. \n",
" # Notice the other parameters. These are placeholders for arguments.\n",
" # What arguments, you ask? The arguments that we will pass to this class when we create an object.\n",
" def __init__(self, name, aircraft_type, capacity, aircraft_range, airline):\n",
"    # They will be used to define the instance variables below.\n",
"    self.name = name\n",
"    self.aircraft_type = aircraft_type\n",
"    self.capacity = capacity\n",
"    self.aircraft_range = aircraft_range\n",
"    self.airline = airline\n",
"\n",
" # This is a method (function inside of a class). It performs some task on the object. \n",
" # Again, notice the 'self' keyword. It is a reference to the instance.\n",
" def extend_capacity(self, additional_seats):\n",
"    self.capacity += additional_seats\n",
"    return self.capacity\n",
"\n",
" # Another method\n",
" def change_owner(self, new_owner):\n",
"    self.airline = new_owner\n",
"    return self.airline\n",
"\n",
" # And another method\n",
" def show_details(self):\n",
"    print(f\"Airline: {self.airline}. Capacity: {self.capacity}. Name: {self.name}. Type: {self.aircraft_type}\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Now, let's create an object:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",

Description For this project, we will explore more complex interac...