oop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bfd2fc1f",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "# Object-oriented programming"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "linear-pierre",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h3>Table of Contents<span class=\"tocSkip\"></span></h3>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#What-is-OOP---Object-Oriented-Programming?\" data-toc-modified-id=\"What-is-OOP---Object-Oriented-Programming?-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>What is OOP - Object Oriented Programming?</a></span><ul class=\"toc-item\"><li><span><a href=\"#Fundamental-Principles\" data-toc-modified-id=\"Fundamental-Principles-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Fundamental Principles</a></span></li></ul></li><li><span><a href=\"#Classes-and-instances\" data-toc-modified-id=\"Classes-and-instances-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Classes and instances</a></span></li><li><span><a href=\"#functional-vs-OOP-(Object-oriented-programming)\" data-toc-modified-id=\"functional-vs-OOP-(Object-oriented-programming)-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>functional vs OOP (Object oriented programming)</a></span></li><li><span><a href=\"#---\" data-toc-modified-id=\"----4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>  -</a></span></li><li><span><a href=\"#Definition-of-a-class\" data-toc-modified-id=\"Definition-of-a-class-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Definition of a class</a></span><ul class=\"toc-item\"><li><span><a href=\"#Self:\" data-toc-modified-id=\"Self:-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>Self:</a></span><ul class=\"toc-item\"><li><span><a href=\"#Defining-a-function\" data-toc-modified-id=\"Defining-a-function-5.1.1\"><span class=\"toc-item-num\">5.1.1&nbsp;&nbsp;</span>Defining a function</a></span></li><li><span><a href=\"#Calling-a-function\" data-toc-modified-id=\"Calling-a-function-5.1.2\"><span class=\"toc-item-num\">5.1.2&nbsp;&nbsp;</span>Calling a function</a></span></li><li><span><a href=\"#Defining-a-class\" data-toc-modified-id=\"Defining-a-class-5.1.3\"><span class=\"toc-item-num\">5.1.3&nbsp;&nbsp;</span>Defining a class</a></span></li><li><span><a href=\"#Instansiating-a-class\" data-toc-modified-id=\"Instansiating-a-class-5.1.4\"><span class=\"toc-item-num\">5.1.4&nbsp;&nbsp;</span>Instansiating a class</a></span></li></ul></li><li><span><a href=\"#Exploring-a-class\" data-toc-modified-id=\"Exploring-a-class-5.2\"><span class=\"toc-item-num\">5.2&nbsp;&nbsp;</span>Exploring a class</a></span></li><li><span><a href=\"#Instance-Attributes\" data-toc-modified-id=\"Instance-Attributes-5.3\"><span class=\"toc-item-num\">5.3&nbsp;&nbsp;</span>Instance Attributes</a></span><ul class=\"toc-item\"><li><span><a href=\"#Default-attributes\" data-toc-modified-id=\"Default-attributes-5.3.1\"><span class=\"toc-item-num\">5.3.1&nbsp;&nbsp;</span>Default attributes</a></span></li></ul></li><li><span><a href=\"#Instance-Methods\" data-toc-modified-id=\"Instance-Methods-5.4\"><span class=\"toc-item-num\">5.4&nbsp;&nbsp;</span>Instance Methods</a></span><ul class=\"toc-item\"><li><span><a href=\"#Python-is-built-with-objects\" data-toc-modified-id=\"Python-is-built-with-objects-5.4.1\"><span class=\"toc-item-num\">5.4.1&nbsp;&nbsp;</span>Python is built with objects</a></span></li></ul></li><li><span><a href=\"#Class-variables\" data-toc-modified-id=\"Class-variables-5.5\"><span class=\"toc-item-num\">5.5&nbsp;&nbsp;</span>Class variables</a></span></li></ul></li><li><span><a href=\"#Before-continuing,-let's-take-a-breath-and-review-vocabulary\" data-toc-modified-id=\"Before-continuing,-let's-take-a-breath-and-review-vocabulary-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Before continuing, let's take a breath and review vocabulary</a></span><ul class=\"toc-item\"><li><ul class=\"toc-item\"><li><span><a href=\"#Easy-exercise\" data-toc-modified-id=\"Easy-exercise-6.0.1\"><span class=\"toc-item-num\">6.0.1&nbsp;&nbsp;</span>Easy exercise</a></span></li></ul></li></ul></li><li><span><a href=\"#Inheritance\" data-toc-modified-id=\"Inheritance-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Inheritance</a></span><ul class=\"toc-item\"><li><span><a href=\"#super()\" data-toc-modified-id=\"super()-7.1\"><span class=\"toc-item-num\">7.1&nbsp;&nbsp;</span>super()</a></span></li></ul></li><li><span><a href=\"#Summary\" data-toc-modified-id=\"Summary-8\"><span class=\"toc-item-num\">8&nbsp;&nbsp;</span>Summary</a></span></li><li><span><a href=\"#Furthermaterials\" data-toc-modified-id=\"Furthermaterials-9\"><span class=\"toc-item-num\">9&nbsp;&nbsp;</span>Furthermaterials</a></span><ul class=\"toc-item\"><li><span><a href=\"#Methods-ADVANCED-@classmethod@staticmethod\" data-toc-modified-id=\"Methods-ADVANCED-@classmethod@staticmethod-9.1\"><span class=\"toc-item-num\">9.1&nbsp;&nbsp;</span>Methods <strong>ADVANCED</strong> @classmethod@staticmethod</a></span></li></ul></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44bbe54e",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## What is OOP - Object Oriented Programming?\n",
    "\n",
    "Object-oriented programming is a programming paradigm, a style and technique for software development that extends beyond mere code implementation. This paradigm is centered on the concept of \"objects,\" which serve as self-contained units containing both data (referred to as \"attributes\") and code for manipulating that data (referred to as \"methods\").\n",
    "\n",
    "The essence of OOP lies in encapsulating these attributes and methods within a unified data structure known as a \"class.\" Think of classes as blueprints that define the structure and behavior of objects, much like a cookie cutter defines the shape of cookies.\n",
    "\n",
    "When objects are instantiated from a class, they share a common structure and specific attributes, similar to cookies created from the same cookie cutter mold. However, just as each cookie can have its unique properties like color, texture, or flavor, objects can possess distinct attributes and behaviors.\n",
    "\n",
    "In summary, OOP promotes modularity and code reusability by enabling developers to create and manipulate objects based on predefined classes. This approach has a profound impact on software engineering and forms the basis of various software development methodologies."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fallen-brazil",
   "metadata": {},
   "source": [
    "![clases](https://files.realpython.com/media/Object-Oriented-Programming-OOP-in-Python-3_Watermarked.0d29780806d5.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92d02d2c",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### Fundamental Principles"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0473322c",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "\n",
    "Object-Oriented Programming (OOP) is built on four fundamental principles that help structure and organize code in a more intuitive and modular way:\n",
    "\n",
    "1. **Data Abstraction**: Human thinking naturally abstracts concrete information into broader concepts or classes. For example, when we think of a \"car,\" we envision a vehicle with specific characteristics like four wheels, a steering wheel, and an engine. This ability to abstract concepts is crucial for language development and is mirrored in programming as well. In OOP, we refer to the abstract concept as a \"class\" and its concrete realizations as \"objects\" or \"instances.\" Your specific car is an object, an instance of the broader \"car\" class.\n",
    "\n",
    "2. **Encapsulation**:Each object in OOP contains its own data (attributes) and can be manipulated through specific actions (methods). For example, a car object might have attributes like tire pressure, color, and fuel level. These attributes are encapsulated within the object, meaning they are accessible and modifiable only through that object. This encapsulation ensures that data is self-contained, reducing the need for separate lists or variables to store related information.\n",
    "\n",
    "3. **Inheritance**: Inheritance allows one class to specialize or derive from another. The specialized class inherits properties and behaviors from a more general class, known as the \"superclass.\" For instance, \"Car\" and \"Truck\" classes can inherit from the \"Vehicle\" superclass. This approach promotes code reuse by inheriting common attributes and methods from a superior class. Python even supports \"multiple inheritance,\" enabling a class to inherit from multiple parent classes simultaneously.\n",
    "\n",
    "4. **Polymorphism**:Polymorphism allows objects of different classes to be treated as objects of a common superclass. This is achieved by defining methods in the superclass and allowing subclasses to override those methods with their own implementations. For example, both \"Square\" and \"Circle\" classes may be subclasses of \"Shape,\" and all of them implement a common method like \"draw().\" When you call this method on an object, the specific subclass's implementation is executed. This flexibility allows functions to accept objects of the superclass as parameters, not needing to know the exact subclass, promoting code reusability and adaptability.\n",
    "\n",
    "These four principles collectively form the foundation of OOP, enabling more organized, modular, and flexible code development.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f325c4f9",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Classes and instances"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1423c0e",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "In Python, a **class** serves as a blueprint or template for creating objects, and each object created from a class is called an **instance**. A class defines both the structure (attributes) and behavior (methods) of objects that belong to it.\n",
    "\n",
    "- **Class Definition**: Here's a basic example of defining a class in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "62065c55",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, color):\n",
    "        self.color = color\n",
    "        self.position = 0  # Initialize position as an attribute\n",
    "    \n",
    "    def move(self):\n",
    "        self.position += 1  # Increment the position attribute by 1\n",
    "        return self.position  # Return the updated position"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9e27174",
   "metadata": {},
   "source": [
    "In this example:\n",
    "\n",
    "- We define a class named `Car`, which serves as the blueprint for creating car objects (instances).\n",
    "- The `__init__` method is a special method called a constructor. It initializes the attributes of the object when it's created. In this case, we set the `color` attribute of the car and the `position` to 0.\n",
    "- The `move` method is a simple function defined within the class. It simulates the car's movement and returns a new position.\n",
    "\n",
    "**Creating Instances**, once we've defined the class, we can create instances of that class, each representing a unique car:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "791910bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "bmw = Car(\"red\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e17afe1a",
   "metadata": {},
   "source": [
    "After creating an instance, we can access its attributes and methods using dot notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ed404283",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "position = bmw.move()  # Call the move() method\n",
    "car_color = bmw.color  # Access the color attribute"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5487f47c",
   "metadata": {},
   "source": [
    "In this line of code, we create an instance of the `Car` class named `bmw` and specify its color as \"red.\"\n",
    "\n",
    "In this example, we call the `move()` method to simulate the car's movement and store its position. We also access the color attribute to retrieve the car's `color`.\n",
    "\n",
    "Classes and instances provide a powerful way to model real-world objects and their behaviors in Python, promoting code reusability and organization."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5082ae7",
   "metadata": {},
   "source": [
    "## Recap\n",
    "\n",
    "1. Imperative Programming:\n",
    "    - **Imperative programming** is a paradigm that focuses on describing how a program operates step by step.\n",
    "    - It emphasizes changing program state through a series of statements or commands.\n",
    "    - Key characteristics include variables, loops, conditionals, and explicit state changes.\n",
    "    - Programs written in this paradigm are often easy to understand sequentially but can become complex with increasing size and complexity.\n",
    "\n",
    "\n",
    "2. Functional Programming:\n",
    "    - **Functional programming** is a paradigm that treats computation as the evaluation of mathematical functions and avoids changing state and mutable data.\n",
    "    - It emphasizes immutability, pure functions, and declarative expressions.\n",
    "    - Key characteristics include higher-order functions, first-class functions, and the absence of side effects.\n",
    "    - Functional programs are often concise, maintainable, and easier to reason about.\n",
    "\n",
    "\n",
    "3. Object-Oriented Programming (OOP):\n",
    "    - **Object-Oriented Programming (OOP)** is a paradigm based on the concept of \"objects,\" which combine data (attributes) and behavior (methods) into a single unit.\n",
    "    - It emphasizes modeling real-world entities and their interactions in code.\n",
    "    - Key characteristics include classes, objects, inheritance, encapsulation, and polymorphism.\n",
    "    - OOP promotes modularity, reusability, and abstraction.\n",
    "\n",
    "\n",
    "## Functional vs. OOP:\n",
    "\n",
    "1. **State Management**:\n",
    "    - Functional programming typically avoids mutable state and encourages immutability, making it easier to reason about code. In contrast, OOP often involves changing object states.\n",
    "\n",
    "\n",
    "2. **Data Structures**:\n",
    "    - Functional programming relies on built-in data structures and functions, while OOP defines custom classes to represent data and behavior.\n",
    "\n",
    "\n",
    "3. **Abstraction**:\n",
    "    - OOP focuses on modeling real-world objects with classes, promoting a natural abstraction. Functional programming abstracts through functions and transformations.\n",
    "\n",
    "\n",
    "4. **Inheritance**:\n",
    "    - OOP uses inheritance to define relationships between classes. Functional programming relies on composition and higher-order functions.\n",
    "\n",
    "\n",
    "5. **Side Effects**:\n",
    "    - Functional programming discourages side effects and promotes pure functions. OOP may involve side effects through method calls and state changes.\n",
    "\n",
    "\n",
    "6. **Modularity**:\n",
    "    - Both paradigms support modularity but achieve it differently. OOP uses classes and objects, while functional programming relies on function composition.\n",
    "\n",
    "\n",
    "7. **Complexity**:\n",
    "    - Functional programming often results in more concise and less complex code due to immutability and purity. OOP code can become complex with deep inheritance hierarchies.\n",
    "\n",
    "\n",
    "In summary, functional programming and OOP are distinct paradigms with different philosophies and trade-offs. Functional programming prioritizes immutability, pure functions, and declarative expressions, while OOP focuses on modeling real-world entities using classes and objects. The choice between them depends on the problem domain and design goals of a software project."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2c51df8",
   "metadata": {},
   "source": [
    "## A Specific Example of a Class in Python\n",
    "\n",
    "In object-oriented programming (OOP), a **class** is like a blueprint or template for creating objects. An **instance** is a specific object created from a class. To understand instances better, let's take the example of the built-in `str` class.\n",
    "\n",
    "### The `str` Class:\n",
    "\n",
    "- In Python, `str` is a built-in class that represents strings (sequences of characters).\n",
    "- The `str` class defines various methods and attributes that can be used with string objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cf4df36",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example 1: Creating Instances\n",
    "name = \"Alfons\"  # Creating an instance of the str class\n",
    "text = \"sdsfdsxg\"  # Another instance of the str class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a492376e",
   "metadata": {},
   "source": [
    "### Instances of `str`:\n",
    "\n",
    "- When you create a string, like `name = \"Alfons\"` or `text = \"sdsfdsxg\"`, you are creating instances of the `str` class.\n",
    "- Each instance of `str` (e.g., \"Alfons\" or \"sdsfdsxg\") is a specific object with its own data (the characters in the string) and behavior (methods for string manipulation).\n",
    "\n",
    "### Exploring Methods and Attributes:\n",
    "\n",
    "- To explore the methods and attributes of a class (including built-in classes like `str`), you can use the `dir()` function.\n",
    "- You can call `dir()` on either an object or the class itself to see what methods and attributes are available."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "71c75881",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Methods and attributes of the str class:\n",
      "['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']\n"
     ]
    }
   ],
   "source": [
    "# Example 2: Exploring Methods and Attributes\n",
    "# Using the dir() function to see available methods and attributes\n",
    "print(\"Methods and attributes of the str class:\")\n",
    "print(dir(str))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54296e0f",
   "metadata": {},
   "source": [
    "### Dunder (Magic) Methods:\n",
    "\n",
    "- In Python, methods and attributes with names enclosed in double underscores, such as `.__str__()` or `.__len__()`, are often called **dunder methods** or **magic methods**.\n",
    "- Dunder methods are meant for Python's internal use and are invoked automatically in certain situations.\n",
    "- For example, when you use the `str()` function to convert an object to a string, Python internally calls the `.__str__()` dunder method if it's defined for that object.\n",
    "- Dunder methods provide a way to customize the behavior of your classes when they interact with built-in Python functions and operators.\n",
    "\n",
    "Overall, instances are specific objects created from classes, and you can explore their available methods and attributes using `dir()`. Dunder methods are special methods in Python, recognized by their double underscores, and they allow you to customize the behavior of your classes in various situations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8a96098c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example 3: Dunder Methods\n",
    "# Defining a custom class with dunder methods\n",
    "class CustomString:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"CustomString({self.value})\"\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "dd9f7914",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating instances of the custom class\n",
    "custom_text = CustomString(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8126bce4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using the str() function to convert an object to a string\n",
    "# It internally calls the __str__() dunder method if defined\n",
    "print(str(custom_text))  # Output: \"CustomString(Hello, World!)\"\n",
    "\n",
    "# Using the len() function to get the length of an object\n",
    "# It internally calls the __len__() dunder method if defined\n",
    "print(len(custom_text))  # Output: 13"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffc3bd0b",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Definition of a class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8917064a",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "In Python, we can define our own classes to model real-world entities or abstract concepts. A class is like a blueprint that defines the attributes (data) and methods (functions) that objects of that class will have. Once a class is defined, we can create instances (objects) of that class, each with its own set of attributes and the ability to perform actions defined by the class's methods.\n",
    "\n",
    "To create a class, we use the `class` keyword and define the attributes and methods within the class block. Attributes are variables that store data for each instance, and methods are functions that allow instances to perform actions or operations.\n",
    "\n",
    "Let's explore class definition and instantiation with an example involving a `Teacher` class to represent educators in a school management system.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6b5c7512",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Definition of a class - Teacher\n",
    "class Teacher:\n",
    "    # Constructor method (__init__) to initialize attributes\n",
    "    def __init__(self, name, subject):\n",
    "        self.name = name\n",
    "        self.subject = subject\n",
    "        self.courses_taught = []\n",
    "\n",
    "    # Method to add a course taught by the teacher\n",
    "    def add_course(self, course_name):\n",
    "        self.courses_taught.append(course_name)\n",
    "\n",
    "    # Method to display teacher's information\n",
    "    def display_info(self):\n",
    "        print(f\"Teacher Name: {self.name}\")\n",
    "        print(f\"Teaching Subject: {self.subject}\")\n",
    "        print(f\"Courses Taught: {', '.join(self.courses_taught)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e9d86f01",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating instances of the Teacher class\n",
    "teacher1 = Teacher(\"Alice\", \"Math\")\n",
    "teacher2 = Teacher(\"Bob\", \"Science\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9b3f6863",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding courses taught by the teachers\n",
    "teacher1.add_course(\"Algebra\")\n",
    "teacher2.add_course(\"Biology\")\n",
    "teacher2.add_course(\"Chemistry\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7053f6e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Displaying teacher information\n",
    "teacher1.display_info()\n",
    "teacher2.display_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dffb2147",
   "metadata": {},
   "source": [
    "### Self: \n",
    "\n",
    "In Python classes, the `self` keyword plays a crucial role. It refers to the instance of the class itself and is used to access its attributes and methods. While it might seem like an extra requirement compared to some other programming languages, understanding and using `self` correctly is fundamental to writing effective and maintainable object-oriented Python code.\n",
    "\n",
    "The use of `self` is a Python convention and helps in distinguishing between instance variables (belonging to the object) and local variables (used only within a method). By using `self`, you make it clear that you are working with instance variables and methods.\n",
    "\n",
    "To maintain consistency and adhere to Python's naming conventions, you can refer to resources like the Python PEP 8, [here](https://realpython.com/python-pep8/#naming-styles), style guide, which provides guidelines for naming variables, classes, functions, and more. Following these conventions can improve code readability and make your code more accessible to other Python developers.\n",
    "\n",
    "Let's dive into the role of `self` and how it's used within Python classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c932085",
   "metadata": {
    "lang": "en"
   },
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    def __init__(self, name, breed):\n",
    "        self.name = name\n",
    "        self.breed = breed\n",
    "\n",
    "    def bark(self):\n",
    "        return f\"{self.name} is barking!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33db14d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating instances of the Dog class\n",
    "dog1 = Dog(\"Buddy\", \"Golden Retriever\")\n",
    "dog2 = Dog(\"Max\", \"Labrador\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59408b7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Accessing instance variables using self\n",
    "print(dog1.name)  # Output: Buddy\n",
    "print(dog2.breed)  # Output: Labrador"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21d84917",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calling a method using self\n",
    "print(dog1.bark())  # Output: Buddy is barking!\n",
    "print(dog2.bark())  # Output: Max is barking!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e404f40d",
   "metadata": {},
   "source": [
    "In this example:\n",
    "\n",
    "- We define a `Dog` class with an `__init__` method that takes two parameters, `name` and `breed`, and initializes instance variables `self.name` and `self.breed`.\n",
    "\n",
    "- The `bark` method uses `self` to access the `name` attribute of the instance to generate a bark message.\n",
    "\n",
    "- We create two instances of the `Dog` class, `dog1` and `dog2`, and initialize them with different names and breeds.\n",
    "\n",
    "- We access instance variables (`name` and `breed`) and call the `bark` method on each instance using `self`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8751e24c",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "#### Default attributes\n",
    "\n",
    "In Python classes, you can initialize attributes with default values. This means that if no specific value is provided when creating instances, the attributes will have these default values. This feature allows you to set sensible defaults, which can be overridden if needed.\n",
    "\n",
    "Let's illustrate this with an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "755ea01e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    def __init__(self, name=\"Unknown\", breed=\"Unknown\"):\n",
    "        self.name = name\n",
    "        self.breed = breed\n",
    "\n",
    "    def bark(self):\n",
    "        return f\"{self.name} says Woof!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "1f703912",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating instances with and without attribute values\n",
    "dog1 = Dog(\"Buddy\", \"Golden Retriever\")\n",
    "dog2 = Dog()  # Using default attribute values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "d62c3c26",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'laura.molas@ironhack.com'"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(dog1.bark())  # Output: \"Buddy says Woof!\"\n",
    "print(dog2.bark())  # Output: \"Unknown says Woof!\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fd00e7f",
   "metadata": {},
   "source": [
    "In the `Dog` class, we provide default values for `name` and `breed` in the `__init__` method. When creating instances like `dog2`, if no values are specified, the default values are used. This flexibility makes it convenient to handle various scenarios when creating objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ce1eb62",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### Instance Methods\n",
    "\n",
    "In Python, instance methods are functions associated with a class that can be called on instances (objects) created from that class. These methods can access and manipulate the attributes of an instance, making them a powerful tool for performing actions related to the class's data.\n",
    "\n",
    "Let's explore the concept of instance methods with an example involving a `Staff` class, which represents staff members at a fictional company. We'll define attributes such as `name`, `fname`, `email`, and `time_off`, and create methods like `greetings` and `takes_days_off` to demonstrate how instance methods work within a class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "7f3ecad3",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Staff ():\n",
    "    \n",
    "    # 1. Atributes\n",
    "    def __init__ (self, name, fname):\n",
    "        self.name = name\n",
    "        self.fname = fname\n",
    "    \n",
    "        self.email = (self.name + \".\" + self.fname + \"@ironhack.com\").lower()\n",
    "        \n",
    "        self.time_off = 30\n",
    "        \n",
    "    # 2. Methods\n",
    "    \n",
    "    def greetings (self):\n",
    "        return f\"Hello!!!!!!\"\n",
    "    \n",
    "    def takes_days_off (self, n):\n",
    "        self.time_off -= n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "5aacfe9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's create the first employee\n",
    "Employee_1 = Staff(\"Alfons\", \"Marques\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba441ae5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's access the attribute time_off\n",
    "Employee_1.time_off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2e1995d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# I took one day off\n",
    "Employee_1.takes_days_off(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "188d5a9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# How many do I have now?\n",
    "Employee_1.time_off"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ee11a36",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's do something\n",
    "Employee_1.greetings()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b7de249",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "**Instance methods, are functions within the classes that can save us a lot of time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdda9183",
   "metadata": {},
   "source": [
    "**⚠️ Target Variables When Instantiating, Ignoring Defaults**\n",
    "\n",
    "In Python, when we instantiate (create) objects from a class, we often provide values for attributes to customize each instance. However, there may be cases where we want to use the default values defined in the class's `__init__` method for certain attributes.\n",
    "\n",
    "In the example provided, we have a `Staff` class representing staff members at a company. This class has attributes like `name`, `fname`, `email`, and `time_off`. We've also defined two instance methods: `greetings` for a friendly greeting and `takes_days_off` for managing time-off requests.\n",
    "\n",
    "Pay attention to how we can target specific variables when instantiating `Staff` objects while ignoring the defaults for some attributes, such as the number of days off. This flexibility allows us to customize objects as needed while relying on default values when appropriate.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "aa27d407",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Staff ():\n",
    "    \n",
    "    # 1. Atributes\n",
    "    def __init__ (self, name, fname):\n",
    "        self.name = name\n",
    "        self.fname = fname\n",
    "    \n",
    "        self.email = (self.name + \".\" + self.fname + \"@ironhack.com\").lower()\n",
    "        \n",
    "        self.time_off = 30\n",
    "        \n",
    "    # 2. Methods\n",
    "    \n",
    "    def greetings (self):\n",
    "        return f\"Hello!!!!!!\"\n",
    "    \n",
    "    def takes_days_off (self, days=1):\n",
    "        \"\"\"Default: take one day unless passed oterhwise\"\"\"\n",
    "        if days <= self.time_off:\n",
    "            self.time_off -= days\n",
    "            return f\"You have these many days left: {self.time_off}\"\n",
    "        else: \n",
    "            return f\"You only have {self.time_off} days available\" "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c584762d",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "**Watch Out** 👀\n",
    "\n",
    "When modifying a class by adding new attributes or methods, it's important to be aware that existing objects created from that class won't automatically have the new attributes or methods. You'll need to recreate those objects to ensure they are initialized with the updates.\n",
    "\n",
    "In the example provided, we have a `Staff` class representing staff members at a company. Initially, the class has attributes like `name`, `fname`, `email`, `time_off`, and `hobbies`. We've also defined methods like `greetings`, `takes_days_off`, and `hobbies_function`.\n",
    "\n",
    "Take note of this important point, especially when you make changes to a class's structure. If you add new attributes or methods, any existing objects of that class will not automatically gain access to these changes. Recreating the objects is necessary to incorporate the updates effectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "id": "2c523f6d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Staff ():\n",
    "    \n",
    "    # 1. Atributes\n",
    "    def __init__ (self, name, fname):\n",
    "        self.name = name\n",
    "        self.fname = fname\n",
    "    \n",
    "        self.email = (self.name + \".\" + self.fname + \"@ironhack.com\").lower()\n",
    "        \n",
    "        self.time_off = 30\n",
    "        \n",
    "        self.hobbies = []\n",
    "        \n",
    "        \n",
    "    # 2. Methods\n",
    "    \n",
    "    def greetings (self):\n",
    "        return f\"Hello!!!!!!\"\n",
    "    \n",
    "    def takes_days_off (self, days=1):\n",
    "        \"\"\"Default: take one day unless passed oterhwise\"\"\"\n",
    "        if days <= self.time_off:\n",
    "            self.time_off -= days\n",
    "            return f\"You have these many days left: {self.time_off}\"\n",
    "        else: \n",
    "            return f\"You only have {self.time_off} days available\"\n",
    "    \n",
    "    def hobbies_function(self, hobbie):\n",
    "        # adds elements to hobbies\n",
    "            # 1. what should this receive: hobbie\n",
    "            # 2. what should it do\n",
    "            # 3. return?\n",
    "        \n",
    "        self.hobbies.append(hobbie)\n",
    "        return f\"My hobbies are {self.hobbies}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9595e979",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Play with this class a litle bit"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b7c965f",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### Class Variables\n",
    "\n",
    "In object-oriented programming, class variables are attributes shared by all instances (objects) of a class. Unlike instance variables, which are unique to each object, class variables maintain the same value across all instances of the class.\n",
    "\n",
    "Class variables are typically defined within the class but outside of any instance methods. They are associated with the class itself, rather than with specific instances of the class. This means that any changes made to a class variable affect all objects created from that class.\n",
    "\n",
    "Class variables are useful for storing data or properties that are common to all instances of a class, such as configuration settings, default values, or constants. They can also be accessed and modified through the class itself, making them a powerful tool for managing shared data within a class.\n",
    "\n",
    "In Python, class variables are often denoted using a naming convention with uppercase letters to distinguish them from instance variables, which usually have lowercase names. Understanding the use of class variables is essential when designing and working with classes in object-oriented programming."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e55d6664",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    # Class variable\n",
    "    COMPANY = \"XYZ Corporation\"\n",
    "    \n",
    "    def __init__(self, name, emp_id):\n",
    "        # Instance variables\n",
    "        self.name = name\n",
    "        self.emp_id = emp_id\n",
    "    \n",
    "    def get_employee_info(self):\n",
    "        return f\"Name: {self.name}, Employee ID: {self.emp_id}, Company: {Employee.company}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d9866125",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Create instances of the Employee class\n",
    "employee1 = Employee(\"John Doe\", 1001)\n",
    "employee2 = Employee(\"Alice Smith\", 1002)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ebebdd61",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Access and display the class variable\n",
    "print(\"Company:\", Employee.company)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72f969de",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Access and display instance-specific information\n",
    "print(employee1.get_employee_info())\n",
    "print(employee2.get_employee_info())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a28ab69",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "In general, class attributes should not be used, except to store constant values."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ad7387e",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "**Exercise: Creating a Class for Student Records**\n",
    "\n",
    "In this exercise, we'll explore how to use classes in a data analytics context. Imagine you work at a university's data analytics department, and you're tasked with managing and analyzing student records. To streamline your work and improve data organization, you decide to create a Python class called `Student` to represent individual student records.\n",
    "\n",
    "The `Student` class will encapsulate student attributes such as name, ID, courses, and grades. Additionally, it will provide methods to calculate the student's GPA, add courses, and display the student's information.\n",
    "\n",
    "By creating this class, you'll demonstrate how classes can help you organize and analyze student data efficiently. This exercise is beginner-friendly and aims to illustrate the practical use of classes in a data analytics context.\n",
    "\n",
    "Now, let's dive into the Python code to create the `Student` class and perform various operations on student records."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec50974b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the Student class\n",
    "class Student:\n",
    "    def __init__(self, name, student_id):\n",
    "        self.name = name\n",
    "        self.student_id = student_id\n",
    "        self.courses = {}\n",
    "    \n",
    "    def add_course(self, course_name, grade):\n",
    "        self.courses[course_name] = grade\n",
    "    \n",
    "    def calculate_gpa(self):\n",
    "        total_grade_points = sum(self.courses.values())\n",
    "        num_courses = len(self.courses)\n",
    "        if num_courses == 0:\n",
    "            return 0.0\n",
    "        else:\n",
    "            return total_grade_points / num_courses\n",
    "    \n",
    "    def display_student_info(self):\n",
    "        print(f\"Student Name: {self.name}\")\n",
    "        print(f\"Student ID: {self.student_id}\")\n",
    "        print(\"Courses and Grades:\")\n",
    "        for course, grade in self.courses.items():\n",
    "            print(f\"{course}: {grade}\")\n",
    "        print(f\"Overall GPA: {self.calculate_gpa():.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "dac73fea",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Clean code example:\n",
    "class Student:\n",
    "    def __init__(self, name: str, student_id: str):\n",
    "        \"\"\"\n",
    "        Initialize a Student object with name and student ID.\n",
    "\n",
    "        Args:\n",
    "            name (str): The student's name.\n",
    "            student_id (str): The student's unique identifier.\n",
    "        \"\"\"\n",
    "        self.name = name\n",
    "        self.student_id = student_id\n",
    "        self.courses = {}\n",
    "\n",
    "    def add_course(self, course_name: str, grade: float):\n",
    "        \"\"\"\n",
    "        Add a course and its grade to the student's record.\n",
    "\n",
    "        Args:\n",
    "            course_name (str): The name of the course.\n",
    "            grade (float): The grade received in the course.\n",
    "        \"\"\"\n",
    "        self.courses[course_name] = grade\n",
    "\n",
    "    def calculate_gpa(self) -> float:\n",
    "        \"\"\"\n",
    "        Calculate the student's GPA based on course grades.\n",
    "\n",
    "        Returns:\n",
    "            float: The calculated GPA.\n",
    "        \"\"\"\n",
    "        total_grade_points = sum(self.courses.values())\n",
    "        num_courses = len(self.courses)\n",
    "        if num_courses == 0:\n",
    "            return 0.0\n",
    "        else:\n",
    "            return total_grade_points / num_courses\n",
    "\n",
    "    def display_student_info(self):\n",
    "        \"\"\"\n",
    "        Display information about the student, including name, ID, courses, and GPA.\n",
    "        \"\"\"\n",
    "        print(f\"Student Name: {self.name}\")\n",
    "        print(f\"Student ID: {self.student_id}\")\n",
    "        print(\"Courses and Grades:\")\n",
    "        for course, grade in self.courses.items():\n",
    "            print(f\"{course}: {grade}\")\n",
    "        print(f\"Overall GPA: {self.calculate_gpa():.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99f4f14d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create instances of the Student class\n",
    "student1 = Student(\"Alice Smith\", \"S12345\")\n",
    "student2 = Student(\"Bob Johnson\", \"S67890\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4bbc4a74",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add courses and grades for each student\n",
    "student1.add_course(\"Math\", 90)\n",
    "student1.add_course(\"History\", 85)\n",
    "student2.add_course(\"Science\", 92)\n",
    "student2.add_course(\"English\", 88)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d96adf5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Display student information\n",
    "student1.display_student_info()\n",
    "student2.display_student_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87cccad5",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Before continuing, let's take a breath and review vocabulary\n",
    "\n",
    "- **Class**: Think of a class as a blueprint or a cookie mold. It defines the structure and behavior of objects. When you create a class, you're specifying how objects of that class should look and behave.\n",
    "\n",
    "- **Object** or **Instance**: An object is a concrete, individual realization of a class, much like a freshly baked cookie from a mold. Each object created from a class shares the same structure defined by the class but can have different data and attributes.\n",
    "\n",
    "- **Attribute**: Attributes are like the ingredients that give each object its unique characteristics. In Python, attributes are defined as arguments in the `__init__` function (the constructor) and are stored as data within each object. Think of them as variables that hold specific information for each object.\n",
    "\n",
    "    - **Object/Instance Attribute**: These attributes are specific to each individual object. For example, in a `Student` class, the student's name and ID are instance attributes because they vary from one student object to another.\n",
    "\n",
    "    - **Class Attribute**: Class attributes are shared among all objects created from the same class. They are constants or values that remain consistent for all instances. For instance, if you have a `School` class, the school's name can be a class attribute because it's the same for all students in that school.\n",
    "\n",
    "- **Method**: Methods are like the actions or functions that objects can perform. They define the behavior of objects. Methods are essentially functions that operate on object data or attributes. For example, a `Student` class might have a `calculate_gpa` method that calculates the student's GPA based on their grades.\n",
    "\n",
    "Understanding these concepts helps us structure and organize our code effectively, making it easier to create, manage, and manipulate objects in an object-oriented programming paradigm.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8772dea7",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Business challenge: Managing Sales Data with Python Classes\n",
    "\n",
    "In this exercise, we'll explore how Python classes can be used to manage and analyze sales data. Imagine you work for a small retail company, and your task is to organize and analyze sales information for various products. To achieve this, we'll create a Python class called `Product` to represent individual products and another class called `SalesData` to manage sales data efficiently.\n",
    "\n",
    "### Part 1: Create the Product Class\n",
    "\n",
    "1. Define a class called `Product` with the following attributes and methods:\n",
    "   - Attributes:\n",
    "     - `name` (str): The name of the product.\n",
    "     - `price` (float): The price of the product.\n",
    "     - `quantity_sold` (int): The quantity of the product sold.\n",
    "   - Methods:\n",
    "     - `__init__(self, name, price)`: The constructor method that initializes the `name`, `price`, and sets `quantity_sold` to 0.\n",
    "     - `sell(self, quantity)`: A method that increments the `quantity_sold` attribute by the given quantity when a product is sold.\n",
    "     - `get_revenue(self)`: A method that calculates and returns the total revenue generated by selling this product (price * quantity_sold).\n",
    "\n",
    "### Part 2: Create the SalesData Class\n",
    "\n",
    "2. Define a class called `SalesData` with the following attributes and methods:\n",
    "   - Attributes:\n",
    "     - `products` (list): A list to store instances of the `Product` class.\n",
    "   - Methods:\n",
    "     - `__init__(self)`: The constructor method that initializes an empty list to store products.\n",
    "     - `add_product(self, product)`: A method that adds a `Product` object to the list of products.\n",
    "     - `get_total_revenue(self)`: A method that calculates and returns the total revenue generated from selling all products.\n",
    "     - `get_best_selling_product(self)`: A method that identifies and returns the product with the highest quantity sold.\n",
    "\n",
    "### Part 3: Using the Classes\n",
    "\n",
    "3. Create instances of the `Product` class to represent different products in your inventory.\n",
    "\n",
    "4. Create an instance of the `SalesData` class to manage your sales data.\n",
    "\n",
    "5. Add the created product instances to the `SalesData` instance.\n",
    "\n",
    "6. Simulate sales for each product using the `sell` method of the `Product` class.\n",
    "\n",
    "7. Calculate the total revenue using the `get_total_revenue` method of the `SalesData` class.\n",
    "\n",
    "8. Identify the best-selling product using the `get_best_selling_product` method of the `SalesData` class.\n",
    "\n",
    "### Additional Challenges (Optional, only if you have time):\n",
    "\n",
    "9. Implement error handling in your classes to ensure that negative quantities or incorrect input are handled gracefully.\n",
    "\n",
    "10. Create a method to display the product details, including name, price, quantity sold, and revenue, for all products in the `SalesData` class.\n",
    "\n",
    "This exercise will help you understand how classes can be used to organize and analyze sales data effectively, making it easier to manage and extract valuable insights from your data. It demonstrates the practical application of classes in a data analytics context.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b6a27bcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Part 1: Create the Product Class\n",
    "class Product:\n",
    "    def __init__(self, name, price):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "        self.quantity_sold = 0\n",
    "        #[your code here...]\n",
    "\n",
    "# Part 2: Create the SalesData Class\n",
    "class SalesData:\n",
    "    def __init__(self):\n",
    "        self.products = []\n",
    "        #[your code here...]\n",
    "    \n",
    "\n",
    "# Part 3: Using the Classes\n",
    "# Create instances of the Product class\n",
    "product1 = Product(\"Laptop\", 800.0)\n",
    "product2 = Product(\"Phone\", 500.0)\n",
    "\n",
    "#[your code here...]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "pressed-proof",
   "metadata": {},
   "source": [
    "## Inheritance\n",
    "\n",
    "Inheritance is a fundamental concept in object-oriented programming that allows you to define new classes based on existing ones. In this relationship, the existing class is referred to as the \"parent class,\" \"superclass,\" or \"parent,\" while the new class is known as the \"child class\" or \"subclass.\"\n",
    "\n",
    "The key idea behind inheritance is that a child class inherits all the properties (attributes and methods) of its parent class. This inheritance mechanism provides several advantages, with code reusability being one of the most significant benefits.\n",
    "\n",
    "By inheriting from a parent class, a child class can reuse the attributes and methods defined in the parent class, saving developers from rewriting the same code. This promotes a more efficient and organized approach to software development, as changes or updates can be made in one place (the parent class) and automatically applied to all child classes.\n",
    "\n",
    "In addition to inheriting attributes and methods, child classes have the flexibility to override or extend these inherited elements. This means that child classes can provide their own implementations of methods (method overriding) or introduce new attributes and methods specific to their requirements.\n",
    "\n",
    "In summary, inheritance is a powerful concept that fosters code reusability, maintainability, and flexibility in object-oriented programming, allowing developers to build upon existing classes to create new ones with shared functionalities.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "wanted-works",
   "metadata": {},
   "source": [
    "\n",
    "![miniyoda](https://media.giphy.com/media/j0eRJzyW7XjMpu1Pqd/giphy.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37b8b77c",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "- **Method Defined in the Parent Class**\n",
    "\n",
    "When a method is defined in the parent class but not in the child class, the child class inherits the method without any need for modification. This means that the method in the child class will work exactly the same way as it does in the parent class, and there is no requirement to override it.\n",
    "\n",
    "- **Method Defined Only in Child Class**\n",
    "\n",
    "In some cases, a method may be defined exclusively in the child class and not in the parent class. In this scenario, the method belongs solely to the child class, and there is no inheritance in the opposite direction. This approach allows the child class to have its unique behavior and functionality.\n",
    "\n",
    "- **Method Defined in Both Parent and Child Classes**\n",
    "\n",
    "When a method is defined in both the parent and child classes, the child class's implementation takes precedence. This means that the method defined in the child class will override the parent class's method. However, there is a way to utilize the original method defined in the parent class while extending it in the child class.\n",
    "\n",
    "To achieve this, Python provides the `super()` function, which allows you to call any method of the parent class from the child class. By invoking `super()`, you can access the parent class's method and add extra functionality or behavior to it in the child class. It's essential to ensure that you provide all the necessary attributes and parameters when calling the parent class's method via `super()`.\n",
    "\n",
    "**Example 1**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f449d01",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parent class\n",
    "class Shape:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    \n",
    "    def get_name(self):\n",
    "        return f\"We are working with a {self.name}.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4ec15c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Child class\n",
    "class Circle(Shape):\n",
    "    def __init__(self, name, radius):\n",
    "        super().__init__(name)\n",
    "        self.radius = radius\n",
    "    \n",
    "    def area(self):\n",
    "        return 3.14 * self.radius**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da4ec9a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Child class\n",
    "class Rectangle(Shape):\n",
    "    def __init__(self, name, length, width):\n",
    "        super().__init__(name)\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "    \n",
    "    def area(self):\n",
    "        return self.length * self.width"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9bfc1b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating instances\n",
    "circle = Circle(\"Circle\", 5)\n",
    "rectangle = Rectangle(\"Rectangle\", 4, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b08f40cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calling methods\n",
    "print(circle.area())       # Uses child class's area method\n",
    "print(circle.get_name())   # Uses parent class's get_name method\n",
    "print(rectangle.area())    # Uses child class's area method\n",
    "print(rectangle.get_name())# Uses parent class's get_name method"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e42e586",
   "metadata": {},
   "source": [
    "**Example 2:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 365,
   "id": "5bfd8b43",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parent class\n",
    "class Animal:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    \n",
    "    def speak(self):\n",
    "        return f\"{self.name} makes a sound\"        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "id": "33b2c2c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Child class\n",
    "class Dog(Animal):\n",
    "    def __init__(self, name, breed):\n",
    "        super().__init__(name) #taking the things from PARENT class\n",
    "        self.breed = breed\n",
    "    \n",
    "    def speak(self):\n",
    "        return f\"{self.name} the {self.breed} barks loudly\"\n",
    "    \n",
    "    def fetch(self):\n",
    "        return f\"{self.name} fetches the ball\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e6e824b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Child class\n",
    "class Cat(Animal):\n",
    "    def __init__(self, name, color):\n",
    "        super().__init__(name) #taking the things from PARENT class\n",
    "        self.color = color\n",
    "    \n",
    "    def speak(self):\n",
    "        return f\"{self.name} the {self.color} cat meows softly\"\n",
    "    \n",
    "    def chase_mice(self):\n",
    "        return f\"{self.name} the {self.color} cat is chasing a mouse\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d21c9a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating instances\n",
    "dog = Dog(\"Buddy\", \"Golden Retriever\")\n",
    "cat = Cat(\"Whiskers\", \"Gray\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbcfaa0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calling methods\n",
    "print(dog.speak())         # Overrides parent's speak method\n",
    "print(dog.fetch())         # Additional method in the child class\n",
    "print(cat.speak())         # Overrides parent's speak method\n",
    "print(cat.chase_mice())    # Additional method in the child class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c86dd52",
   "metadata": {},
   "source": [
    "In this example:\n",
    "\n",
    "- We have a parent class `Animal` with an `__init__` method to initialize the `name` attribute and a `speak` method that returns a generic sound.\n",
    "\n",
    "- We create two child classes, `Dog` and `Cat`, which inherit from the `Animal` parent class.\n",
    "\n",
    "- Both child classes have their `__init__` methods that call the parent class's `__init__` method using `super()`. They also have their `speak` methods, which override the parent class's `speak` method to provide species-specific sounds. Additionally, each child class has its own unique method (`fetch` for `Dog` and `chase_mice` for `Cat`).\n",
    "\n",
    "- We create instances of the `Dog` and `Cat` classes and call their methods. When we call the `speak` method on each instance, it uses the overridden method specific to that class. The additional methods (`fetch` and `chase_mice`) are also available for the respective instances.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06927b5c",
   "metadata": {},
   "source": [
    "## Summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c2bda49",
   "metadata": {},
   "source": [
    "# Object-Oriented Programming (OOP) Simplified\n",
    "\n",
    "- OOP is a \"fascinating\" programming paradigm alongside imperative and functional styles.\n",
    "- In OOP, everything is an object, combining data (attributes) and behavior (methods).\n",
    "- Follow naming conventions: `class Object()`, `def a_function()`, `CONSTANTS = PI`, `variables`, `one_variable`.\n",
    "  \n",
    "## Instances: Bringing Objects to Life\n",
    "\n",
    "- Instances are concrete examples of a class, like Laura and Albert being instances of the Staff class.\n",
    "- The class provides the blueprint, and instances embody it.\n",
    "- To create instances, use `def __init__(self):` and specify what it needs when instantiating.\n",
    "  \n",
    "## The Power of 'self'\n",
    "\n",
    "- `self` is the object referring to itself, enabling access to its attributes and methods.\n",
    "- For example: `\"sdsdsdsd\".upper()`, `self.time_off`, `self.email`, where `self` represents the object itself.\n",
    "  \n",
    "## Methods: The Doers in OOP\n",
    "\n",
    "- All methods take `self` as the first argument, which means they operate on the instance itself.\n",
    "- Methods can also accept other arguments beyond `self`, allowing for additional functionality.\n",
    "  \n",
    "## Flexible Attributes\n",
    "\n",
    "- Attributes can be passed when instantiating an object or have default values.\n",
    "- For instance, an email address or holiday days can be set as default attributes.\n",
    "  \n",
    "## Class Inheritance: Building on Foundations\n",
    "\n",
    "- Inheritance lets you create specialized classes from existing ones.\n",
    "- For instance: `class Staff()`, `class Marketing(Staff)`, `class PaidSocialMedia(Marketing)`.\n",
    "  \n",
    "## Instances Receive Values\n",
    "\n",
    "- Instances can receive values, including attributes from other objects.\n",
    "- Just like Mario can acquire the power of a mushroom, objects can exchange data.\n",
    "- For example, a gym can record the membership amount from a new customer.\n",
    "\n",
    "In this simplified guide, we've explored key OOP concepts, demystifying this powerful programming paradigm. OOP brings structure and organization to code, making it easier to design, understand, and maintain. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d8865bd",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "## Further materials\n",
    "\n",
    "- Youtube Tutorial by [Corey Schafer](https://www.youtube.com/watch?v=ZDa-Z5JzLYM)\n",
    "- [Real Python](https://docs.hektorprofe.net/python/object-oriented-programming/classes-and-objects/)\n",
    "- [Interesting read](https://medium.com/@shaistha24/functional-programming-vs-object-oriented-programming-oop-which-is-better-82172e53a526) --> OOP vs Functional programming"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92bd3cce",
   "metadata": {
    "lang": "en"
   },
   "source": [
    "### Methods **ADVANCED** @classmethod@staticmethod\n",
    "* [Real Python - @classmethod/@stathicmethod](https://realpython.com/instance-class-and-static-methods-demystified/). Advanced Python with decorators (we'll mention them later)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d590f49c",
   "metadata": {},
   "source": [
    "## Solutions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b38b429",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Part 1: Create the Product Class\n",
    "class Product:\n",
    "    def __init__(self, name, price):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "        self.quantity_sold = 0\n",
    "    \n",
    "    def sell(self, quantity):\n",
    "        if quantity > 0:\n",
    "            self.quantity_sold += quantity\n",
    "        else:\n",
    "            print(\"Invalid quantity. Please enter a positive number.\")\n",
    "    \n",
    "    def get_revenue(self):\n",
    "        return self.price * self.quantity_sold\n",
    "\n",
    "# Part 2: Create the SalesData Class\n",
    "class SalesData:\n",
    "    def __init__(self):\n",
    "        self.products = []\n",
    "    \n",
    "    def add_product(self, product):\n",
    "        self.products.append(product)\n",
    "    \n",
    "    def get_total_revenue(self):\n",
    "        total_revenue = 0\n",
    "        for product in self.products:\n",
    "            total_revenue += product.get_revenue()\n",
    "        return total_revenue\n",
    "    \n",
    "    def get_best_selling_product(self):\n",
    "        if not self.products:\n",
    "            return None\n",
    "        \n",
    "        best_product = self.products[0]\n",
    "        for product in self.products:\n",
    "            if product.quantity_sold > best_product.quantity_sold:\n",
    "                best_product = product\n",
    "        return best_product\n",
    "\n",
    "# Part 3: Using the Classes\n",
    "# Create instances of the Product class\n",
    "product1 = Product(\"Laptop\", 800.0)\n",
    "product2 = Product(\"Phone\", 500.0)\n",
    "\n",
    "# Create an instance of the SalesData class\n",
    "sales_data = SalesData()\n",
    "\n",
    "# Add the created product instances to the SalesData instance\n",
    "sales_data.add_product(product1)\n",
    "sales_data.add_product(product2)\n",
    "\n",
    "# Simulate sales for each product\n",
    "product1.sell(5)\n",
    "product2.sell(8)\n",
    "\n",
    "# Calculate the total revenue\n",
    "total_revenue = sales_data.get_total_revenue()\n",
    "print(f\"Total Revenue: ${total_revenue:.2f}\")\n",
    "\n",
    "# Identify the best-selling product\n",
    "best_selling_product = sales_data.get_best_selling_product()\n",
    "if best_selling_product:\n",
    "    print(f\"Best Selling Product: {best_selling_product.name}\")\n",
    "else:\n",
    "    print(\"No products in sales data.\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  },
  "nbTranslate": {
   "displayLangs": [
    "en",
    "es"
   ],
   "hotkey": "alt-a",
   "langInMainMenu": true,
   "sourceLang": "es",
   "targetLang": "en",
   "useGoogleTranslate": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "288px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}