Python Object Oriented Programming Full Course 🐍

Main ideas & lessons (by topic)

1) Object-Oriented Programming (OOP) Foundations in Python

• Objects: A real-world thing represented in code. Defined as a bundle of related attributes and methods.

• Attributes

  • Like variables that describe what an object “has”.
  • Examples:
    • Phone: version number, powered on (Boolean), price
    • Cup: contents (e.g., coffee), temperature, empty (Boolean)
    • Book: title (string), pages (number)
• Methods
  • Actions an object can do.
  • Clarification: methods belong to objects (a function “within” an object/class).
• Classes
  • Blueprints used to design the structure/layout of objects.
  • A class defines:
    • What attributes instances will have
    • What methods instances can perform
• Constructor / __init__
  • A special method used to initialize new objects.
  • Uses self to refer to the current instance being created.
  • Attribute assignment pattern: self.attribute = parameter

Car class example (attributes + constructor + instance methods)

• Attributes: model, year, color, for_sale (Boolean)
• Creating instances: call the class like a function, e.g. car1 = Car(...)
• Attribute access uses dot notation: car1.model, car1.year, etc.
• Methods demonstrated
  • drive(self): prints driving message using instance attributes
  • stop(self): prints stopping message using instance attributes
  • describe(self): prints a combined description using multiple attributes
• Organization
  • Classes can be moved to a separate file and imported:
    • Example: car.py contains class Car, then imported from the main script

---

2) Class Variables vs Instance Variables

• Instance variables
  • Defined in __init__
  • Unique per object
• Class variables
  • Defined outside __init__
  • Shared among all instances of the class

Practice/student example

• Instance variables: name, age
• Class variables:
  • class_year (same for all students)
  • num_students (shared counter)
• Incrementing shared state inside __init__:
  • Use the class name (e.g., Student.num_students += 1) rather than self.

---

3) Inheritance

• Inheritance concept
  • A class can reuse and extend another class’s attributes/methods.
  • Reduces repetition and supports extensibility.
• Animal example
  • Parent class: Animal
    • __init__: sets name and is_alive = True
    • Methods: eat(), sleep()
  • Child classes: Dog, Cat, Mouse
    • Initially empty but still inherit name, is_alive, eat, sleep
    • Later they get their own speak() implementations:
      • Dog: woof
      • Cat: meow
      • Mouse: squeak
• Why it matters
  • If a parent method changes, it’s updated in one place—not copied across many classes.

---

4) Multiple Inheritance and Multi-level Inheritance

• Multiple inheritance
  • A child class inherits from more than one parent.
  • Example roles:
    • Parents: Prey, Predator
    • Child classes:
      • Rabbit(Prey) → can flee, no hunt
      • Hawk(Predator) → can hunt, no flee
      • Fish(Prey, Predator) → can flee and hunt
• Multi-level inheritance
  • A parent inherits from another class (grandparent relationship).
  • Example:
    • Prey and Predator inherit from Animal
    • Children (Rabbit, Hawk, Fish) inherit everything via the chain:
      • Animal provides eat() and sleep()
      • Prey/Predator add flee()/hunt()
      • Children get all of it

---

5) Abstract Classes

• Abstract class purpose
  • Cannot be instantiated directly.
  • Meant to be subclassed.
  • Can contain abstract methods that must be implemented by children.
• Mechanism
  • Uses:
    • ABC (Abstract Base Class)
    • @abstractmethod
• Vehicle example
  • Abstract parent Vehicle:
    • abstract methods: go(), stop()
  • Child classes must implement both:
    • Car implements go and stop
    • Motorcycle implements go and stop
    • Boat initially fails (missing stop) → TypeError until implemented

---

6) super() Function

• What it does
  • Called inside a child class to invoke parent class methods—commonly the parent __init__.

Shapes example

• Parent: Shape
  • Holds shared attributes: color, is_filled
  • Has a describe() method
• Children: Circle, Square, Triangle
  • Add unique geometry attributes:
    • Circle: radius
    • Square: width
    • Triangle: width, height
  • In each child __init__, use:
    • super().__init__(color, is_filled) to avoid repeating shared setup.
• Method overriding + extension
  • Child describe() can override and still call parent logic using super().describe()

---

7) Polymorphism (via inheritance)

• Meaning
  • “Many forms”: the same interface/operation works differently depending on the object type.
• Shapes polymorphism
  • Base/abstract-like Shape includes an area() concept (implemented per child).
  • Circle.area(), Square.area(), Triangle.area() compute different formulas.
• List processing
  • A list of different shape objects can be iterated, and each object’s area() is called correctly.
• Duck note
  • A “Pizza” class not inheriting from Shape lacks area() → AttributeError.
  • If Pizza inherits from Circle, then it gains area() and fits the “shapes” list.

---

8) Duck Typing (polymorphism without inheritance)

• Idea
  • An object is treated like a type as long as it provides the required methods/attributes.
• Example
  • Animal defines attribute alive
  • Dog and Cat implement speak()
  • A Car class is not an Animal, but if it has speak() (or you rename horn to speak), it can be used in the same loop.
• Minimum requirements
  • If the loop expects speak() and alive, objects must have those or you get AttributeError.
• Duck typing is often summarized as: “If it looks like a duck and quacks like a duck…”

---

9) Aggregation vs Composition

• Aggregation: “Has a”
  • One object contains references to independent objects.
  • Contained objects can exist without the container.
• Composition: “Owns a”
  • The composed object directly owns/creates components.
  • Components typically cannot exist independently of the container.

Examples

• Aggregation
  • Library contains a list of Book objects.
  • Book objects are created independently and stored in Library.
• Composition
  • Car constructs an engine and a list of wheels inside its own constructor.
  • If you delete the Car, its owned components go away as well.

---

10) Nested Classes

• Definition
  • A class defined inside another class.
• Benefits
  • Avoid naming conflicts (shared names in different scopes are allowed).
  • Keeps namespaces clean.
  • Organizes closely related types (e.g., Company.employee).
• Example
  • Company outer class contains inner class employee
    • Company.add_employee(name, position) creates inner employee objects
    • Company.list_employees() returns formatted details via list comprehension

---

11) Static Methods

• Definition
  • Belong to a class, not a particular instance.
  • Typically used for utility functions not needing self or class data.
• Example
  • Employee.is_valid_position(position):
    • Uses a list of allowed positions
    • Returns whether a given position is in that list
  • Called using the class name, not an instance.

---

12) Class Methods

• Definition
  • Work with class-level data.
  • Use cls (class) as the first parameter.
• Example
  • Student:
    • Instance variables: name, GPA
    • Class variable: count (total students)
    • get_count() class method returns the total
    • get_average_gpa() class method computes averages from:
      • accumulated total_gpa
      • divided by count

---

13) Magic / Dunder Methods

• Meaning
  • Methods surrounded by double underscores (__init__, __str__, etc.).
  • Automatically invoked by Python built-in operations.
• Book example
  • __init__: initialize title, author, number_of_pages
  • __str__: controls how print(book) looks (returns a string)
  • __eq__: equality comparison (example ignores page count)
  • __lt__, __gt__: compare page counts
  • __add__: add two books’ page counts together
  • __contains__: support keyword in book searches (e.g., in title or author)
  • __getitem__: support indexing-like access (e.g., by keys like title, author, num_pages)

---

14) @property Decorator (Getters/Setters/Deleters)

• Purpose
  • Expose methods as if they are attributes.
  • Add logic when:
    • reading
    • writing
    • deleting those attributes

Rectangle example

• Stores raw values in “protected” attributes (prefixed with _), e.g.:
  • _width, _height
• Getter methods
  • Return formatted values (e.g., “centimeters” with one decimal place)
• Setter methods
  • Validate input (e.g., must be > 0)
  • Print errors if invalid
• Deleter methods
  • Delete _width / _height and print confirmation

---

Speakers / Sources Featured

• Single on-screen speaker/instructor (no name provided in subtitles) teaching Python OOP concepts across multiple sections of the course.