Object-Oriented Python:
Master OOP & Write More Pythonic Code

Object-Oriented Python: Master OOP & Write More Pythonic Code

5 Days • Live Course

Beyond class Foo: and def __init__. Learn the data model, design judgment, and decisions that separate working Python from Python that lasts.

Hosted By

Stephen Gruppetta
Stephen Gruppetta, PhD
Core Team member at Real Python and the author of Object-Oriented Programming in Python. He teaches Real Python's Intermediate Python Deep Dive cohort and brings the same hands-on approach to this course.

You can write Python code that works.

But there’s a corner of the language you keep walking around…

As your programs grow, the design questions get harder to avoid:

“Should this be a class or a function?”

“Where should this state live?”

“When does inheritance help, and when does it make the design worse?”

“What are __repr__, @property, @classmethod, and the sequence protocol actually for?”

You’re not a beginner, but classes and object-oriented design still feel like someone else’s vocabulary sometimes.

The thing is:

You can ship useful Python without thinking deeply about OOP. Many people do.

But once your programs have state, behavior, multiple representations, and changing requirements, object design starts to matter.

The codebases you want to write, the ones that hold up under change, that other devs can enjoy reading on a Monday morning, that scale past a handful of files, are the codebases where someone made deliberate decisions about objects.

About “what should know what.” About when a class earns its keep and when it doesn’t.

What Makes This Course Special

The Code Asks for the Class. Then You Write It.

Most OOP courses front-load the vocabulary. Encapsulation. Polymorphism. Inheritance. Then they hand you Animal, Dog, Cat and hope the abstractions stick.

This one runs the other direction:

We carefully structured the curriculum around a hands-on coding project that you’ll build and improve step-by-step, one live session at a time.

Every concept in this course shows up the moment the code can’t go further without it.

You write a script that almost works. You feel exactly where it strains…

Then you reach for the tool that fixes the strain in front of you, and the name for that tool (“a class,” “an @property,” “the sequence protocol”) arrives attached to a problem you just lived through.

Over the week, you’ll build a sushi-conveyor restaurant simulator while adding OOP features only when the design needs them:

  • turn fragile dictionaries into classes with useful __repr__ output
  • make custom objects behave like Python sequences
  • compare inheritance and composition in a concrete model
  • use @property to protect invariants without Java-style getters
  • add alternative constructors with @classmethod

Each OOP feature appears only when the code has reached a point where the next design decision matters.

You’ll start with simple data structures that almost work, then refactor them into objects that are easier to inspect, extend, and reason about.

By the end, you won’t just know what a class is. You’ll have practiced deciding when a class earns its keep.

Course Curriculum

Five 2-hour live Zoom sessions, Monday through Friday. Setup is minimal: Python 3.12+, your editor of choice, and Zoom. That’s it.

The first four days are hands-on instruction. You code along with Stephen and finish each day with a working piece of the simulator. Friday is two open hours of Q&A and recap.

A cohort forum runs alongside the live sessions, so you can ask questions between days, share what you’re building, and stay connected with Stephen and your peers throughout the week.

Can’t attend live? You’ll get the recording the next morning.

Here’s what happens each day:

Monday, August 24, 2026

Day 1: From Scribbles to Objects · Classes & Instances

By the end of today, you’ll have written your first real classes, and you’ll know when to reach for one instead of a dict.

What you’ll build: Your first object-oriented version of the simulator’s core data: classes with constructors, instance state, and useful __repr__ output.

What you’ll learn:

  • How to define a class and create instances with __init__ and self
  • Where state lives: class attributes vs. instance attributes
  • The mutable-class-attribute trap (a mistake you’ll hit in your own code within a week if you don’t see it now)
  • When to reach for a named class instead of a dictionary
Aug 24

Day 1: From Scribbles to Objects · Classes & Instances

Mon, Aug 24 @ 19:30 UTC (2 hours)

Tuesday, August 25, 2026

Day 2: The Day Python Clicks · Methods & Data Model

By the end of today, your custom classes will plug into Python’s built-in syntax (for-loops, indexing, sorting, printing) the way native types do.

What you’ll build: Classes that participate in Python’s data model: iterable, indexable, sortable, comparable, and concatenable.

What you’ll learn:

  • The three flavors of methods (instance, class, and static), and when each is the right tool
  • @classmethod as a clean way to expose alternate constructors (a pattern you’ll lean on again on Day 3)
  • Python’s data model and the dunder methods that hook into it: __repr__, __str__, __eq__, __lt__, __hash__, __len__, __iter__, __getitem__, __add__, __contains__
  • How to make your own classes behave like native Python sequences instead of inventing parallel APIs
Aug 25

Day 2: The Day Python Clicks · Methods & Data Model

Tue, Aug 25 @ 19:30 UTC (2 hours)

Wednesday, August 26, 2026

Day 3: A Real Restaurant Takes Shape · Object Creation, Inheritance & Composition

By the end of today, you’ll have made the most consequential decision in OO design (when to inherit, when to compose), and written both in the same growing codebase.

What you’ll build: A class hierarchy alongside a composed parent class, so inheritance and composition sit side by side in one project.

What you’ll learn:

  • Multiple alternate constructors via @classmethod, so each way an object gets created has a clean, named entry point
  • Inheritance (is-a) vs. composition (has-a), plus the cardinal over-inheritance mistake new OO developers make
  • Two shapes of composition: has-one (single attribute) and has-many (collection)
  • Abstract base classes (ABC) and @abstractmethod to formalize the contract subclasses must implement, so missing methods fail at construction rather than somewhere downstream
Aug 26

Day 3: A Real Restaurant Takes Shape · Object Creation, Inheritance & Composition

Wed, Aug 26 @ 19:30 UTC (2 hours)

Thursday, August 27, 2026

Day 4: A Restaurant That Lasts · Properties, Dataclasses & SOLID

By the end of today, the complete simulator runs in your terminal: guarded state, less boilerplate, swappable behavior, every concept from the week working together.

What you’ll build: The finished simulator, with validated attributes, dataclass-driven small types, and pluggable behavior the rest of the code doesn’t have to know about.

What you’ll learn:

  • @property for read-only attributes, validated setters, and computed values that can’t go stale, all without changing the obj.x syntax callers use
  • @dataclass (with field(default_factory=...) and frozen=True) to kill __init__/__repr__/__eq__ boilerplate on the many small classes every codebase accumulates
  • Two SOLID principles in depth: Open/Closed (extend behavior without rewriting existing classes) and Dependency Inversion (depend on a protocol, not a concrete type)
  • The remaining three SOLID principles named and pointed at

The session closes with a full run of the simulator: every class from the four days working together, the belt cycling, orders queueing, pricing flipping to happy hour at 4pm.

Aug 27

Day 4: A Restaurant That Lasts · Properties, Dataclasses & SOLID

Thu, Aug 27 @ 19:30 UTC (2 hours)

Friday, August 28, 2026

Day 5 — Q&A and Recap

Two open hours with Stephen to close the loop on anything that didn’t land.

What you’ll get:

  • A short visual recap of the week’s concepts
  • Open Q&A with Stephen: bring your code, your sticky problems, and the patterns you want to revisit
  • Time to discuss how the patterns from the simulator map onto your own projects
Aug 28

Day 5: Q&A and Recap

Fri, Aug 28 @ 19:30 UTC (2 hours)

Course Dates: August 24–28, 2026 (Mon–Fri)

Join the Waitlist →Be First in Line for the Next Cohort.

View Course Curriculum

Real Python Satisfaction Guarantee

This course is backed by Real Python's guarantee. You can receive a full refund within 14 days after the course ends, provided you meet the completion criteria in our refund policy.

What You’ll Be Able to Do

  • Design classes that bundle data and behavior, instead of wrestling sprawling dicts and stranded helper functions
  • Make your own classes feel native to Python by hooking into the data model, so they're iterable, indexable, sortable, and printable
  • Recognize when to inherit and when to compose, and avoid the most common mistake new OO developers make

What You’ll Receive

  • 5 live 2-hour sessions (Mon–Fri) via Zoom
  • 2-hour open Q&A on Friday. Cohort forum with instructor and your peers throughout the week
  • Complete project codebase to keep and extend