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, 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:

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

Who This Course Is For

Who Should Not Take This Course?

This course is not for absolute beginners. If you’re still finding your footing with Python basics like functions, dictionaries, and control flow, this will move too fast. Check out Real Python’s Python Basics Learning Path first.

Meet Your Instructor

Stephen Gruppetta, PhD
Core Team member at Real Python and acclaimed Python educator who combines years of teaching expertise and storytelling techniques to make complex programming concepts clear, engaging, and unforgettable.

Stephen Gruppetta is a seasoned Python educator and author known for his engaging narrative approach to explaining complex concepts, drawing on his PhD in physics and years as a lecturer and technical writer.

With experience ranging from corporate training to creating accessible resources like The Python Coding Book, he’s dedicated to helping learners master Python with clarity and creativity.

Why Learn With Real Python?

Real Python started as a Kickstarter project in 2012. Today, over 1 million developers, data scientists, and ML engineers read it every month.

Our content goes through what very few Python resources match:

• Expert technical review for accuracy
• Teaching specialist evaluation for learning effectiveness
• Professional editing for clarity

Our live courses bring that same review process to an interactive, instructor-led format. You get the questions, the live discussion, and a community that’s been learning Python with us since 2012.

What Learners Say About
Stephen’s Courses

“Ever since we’ve been taking the course, I’ve really changed a lot of the way that I’m programming… I started to see, oh, I could replace this with classes and it would be a lot more readable, a lot more efficient.”

“Honestly, just the first two weeks of this course was worth it for me.”

“It’s definitely given me more confidence to go deep dive into things I just took for granted… But after this course I feel much stronger in being able to understand the fundamentals of why things work in Python that it’s given me more confidence to go deeper.”

— Matt Thacker, Sr. Solutions Engineer at Eptura

“I normally would just be doing functions, right? Just simple functions running the script. But the class stuff is pretty great. I really liked seeing the dunder call and how that’s used in your own classes—it just kind of clicked for me. Now when something goes wrong with one of our internal applications, I can go into the code and see better why something’s going wrong. This is gonna help a lot.”

“Even reading code now […] some of my coworkers, going through and looking at some of their code, I now can understand better on what they’re doing and what the classes are actually performing.”

— Chris Kessler, Software Engineer at Sony Pictures

“I felt like I was a really well-studied Python beginner… But I couldn’t quite get out of there to the next level. And [Stephen's course] is helping because it’s all about that deeper understanding.”

“I can look at modules, I can look at other people’s code and I understand why they’re doing what they’re doing. And it’s not just taking things for granted anymore… I can go on and start exploring more complex things without immediately getting lost.”

— Jerry Wilson, Technical Lead at AIM EMS Software

Why This Course Works

OOP is hard to learn from isolated examples because the design tradeoffs are missing.

A Dog class can show syntax, but it rarely shows why a class was the right abstraction in the first place.

In this course, each concept appears inside the same growing codebase. You see the before and after:

• the dictionary version before the class
• the hand-rolled method before the data model method
• the conditional-heavy version before the subclass
• the boilerplate version before @dataclass
• the rigid constructor before @classmethod

OOP is not the answer to every design problem. But when your code has durable concepts, changing state, and behavior that belongs with that state, classes become one of Python’s most useful design tools.

This course helps you build that judgment.

Frequently Asked Questions

Have another question? Email us at info@realpython.com