Go From Working Python to Well-Designed Python…

Modern Object-Oriented Python:
Write Clean, Pythonic Code With OOP

Master Classes, Python’s Data Model, and Object-Oriented Design. Fully Up to Date for Today’s Python

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.

Here’s the thing:

The codebases that hold up under change are the ones with deliberate decisions about objects:

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.

Modern Object-Oriented Python teaches you the vocabulary and the judgment:

What Python’s object-oriented features are for, how they hook into the language, and, just as important, when a class makes your code better, and when it just gets in the way.

It’s the best of a decade of Real Python’s OOP teaching, all in one book.

So what does that look like in practice? Picture the next few weeks after reading this book:

Next week, in code review: a teammate asks “why is this a class?” and you have an answer that isn’t “it felt right.”

A few days later, your AI coding agent proposes five classes, three levels of inheritance, and a metaclass. You spot at a glance that the problem needed one @dataclass, and you push back with reasons.

Next sprint, requirements change, and you update one class instead of twelve call sites.

And one evening, you open a library’s source code, and the special methods read like sentences instead of alphabet soup.

That’s where this book takes you:

Goals—
By the End of the Book You’ll Be Able To:

• Model your data with well-designed classes instead of wrestling sprawling dicts and parallel lists
• Write objects that feel native to Python: printable, comparable, sortable, iterable
• Make the judgment calls that define good design: class or function, inheritance or composition, data class or hand-written
• Cut the boilerplate with properties, data classes, and alternate constructors
• Build designs that survive changing requirements, guided by the SOLID object-oriented design principles for clean & maintainable code

Modern Object-Oriented Python:
Write Clean, Pythonic Code With OOP

Modern Object-Oriented Python takes Real Python’s most trusted tutorials on object-oriented programming, material that has already helped millions of Pythonistas, and re-edits them into a single, coherent curriculum.

Each page is carefully typeset with syntax-highlighted code examples and clearly marked notes, tips, and warnings:

Curated and edited by our expert team, the book takes you from your first class to confident design:

👉 The fundamentals: classes, instances, data attributes, and methods, plus why classes beat dictionaries and parallel lists once your data has behavior.

👉 Python’s object model: special methods, object creation and initialization, and how to make your own classes feel native to Python: iterable, sortable, printable, comparable.

👉 Design choices: inheritance vs. composition, managing attributes with properties, cutting boilerplate with data classes, and a practical look at the SOLID principles.

And it’s modern:

Every example is tested against the latest Python release, so you’re learning today’s idioms (@dataclass, properties, alternate constructors), not 2010-era OOP.

Meet the Team Behind the Book

Modern Object-Oriented Python was produced by a small team at Real Python with decades of combined professional Python experience under their belt. The team members who contributed and worked on the book are: Aldren Santos, Brenda Weleschuk, Dan Bader, David Amos, Geir Arne Hjelle, Isaac Rodriguez, Kyle Stratis, Leodanis Pozo Ramos, Martin Breuss, and Sarah Jane Ross.

Table of Contents
& Sample Chapters

Here’s what you’ll learn with Modern Object-Oriented Python:

Chapter 1: Introduction to Object-Oriented Programming What OOP is and why it matters in Python. You’ll see where primitive data structures fall short, define your first classes, and understand the difference between a class and an instance.

Chapter 2: Data Attributes Where data lives in your objects: class attributes vs. instance attributes, how Python looks them up, and the pitfalls to avoid when attaching data to classes and instances.

Chapter 3: Methods Instance, class, and static methods demystified. You’ll build a Pizza class with delicious factory methods and learn exactly when each kind of method is the right choice.

Chapter 4: Special Methods The heart of Pythonic OOP. Control how your objects print with .__repr__() and .__str__(), support operators and comparisons, implement iteration, and build custom sequences and mappings that behave like Python’s built-in types.

Chapter 5: Creation and Initialization of Objects How Python actually constructs objects: .__init__(), .__new__(), and how to provide multiple constructors so each way of creating an object has a clean, named entry point.

Chapter 6: Inheritance and Composition The most consequential decision in object-oriented design. Model is-a and has-a relationships, use super() with confidence, and build an HR payroll system that shows both approaches side by side, plus clear guidance on choosing between them.

Chapter 7: Properties Managed attributes with property(): read-only, read-write, and write-only attributes, validation, computed values that can’t go stale, and how to override properties in subclasses.

Chapter 8: Data Classes Write less boilerplate with @dataclass: flexible fields and defaults, immutable instances with frozen=True, inheritance, and when a data class is (and isn’t) the right tool.

Chapter 9: SOLID Principles to Improve Object-Oriented Design Single responsibility, open-closed, Liskov substitution, interface segregation, and dependency inversion. Each principle is explained with practical Python examples.

Want to see the book’s style for yourself? Download the free sample chapters (PDF) and start reading in the next two minutes.

Here’s What’s “In the Box”

✅ The complete Modern Object-Oriented Python book in DRM-free PDF, ePub, and Kindle formats

✅ Nine in-depth chapters: from your first class to the SOLID principles

✅ All example code as ready-to-run scripts, licensed CC0 so you can use it freely in your own projects

✅ Book home page in your realpython.com account with downloads, errata, changelog, and a comments section to ask questions

✅ Free updates for life, including everything we improve during Early Access

✅ Backed by our 1-year money-back guarantee

Who Should Read This Book?

👉 If you write procedural Python, and you’re fluent with functions, lists, dicts, and comprehensions but haven’t built anything serious with classes, this book gives you the missing layer. You’ll learn to bundle data and behavior instead of wrestling sprawling dicts and stranded helper functions.

👉 If you’ve used classes without feeling confident, subclassing BaseModel, models.Model, or unittest.TestCase because the framework told you to, you’ll finally understand what’s happening under the hood, and how to design a class from scratch.

👉 If you learned OOP in another language, like Java or C#, and Python’s approach feels loose and confusing, you’ll learn the Pythonic way: properties instead of getters, data classes instead of boilerplate, composition over deep hierarchies, and the data model that makes it all click.

👉 If you avoided classes altogether because they felt unnecessary or overcomplicated, this book won’t force OOP on you. It’ll show you what classes are genuinely good for, what the alternatives are, and how to make that call yourself.

Who Should Not Read This Book?

This book is not for complete beginners. You should already be comfortable with variables, functions, conditionals, loops, and Python’s built-in data types. If you’re still building that foundation, start with our Python Basics book first. It covers everything you need to get ready for this one.

“Why Learn OOP When AI Writes My Code Now?”

Because you’re the one who signs off on it.

AI coding assistants are fantastic at producing object-oriented code. They’re far less reliable at deciding whether that code is any good.

Ask an agent to design your system, and it will confidently hand you a class hierarchy. Sometimes it’s exactly what the problem needs. Sometimes it’s an over-engineered maze that will fight you for months.

The only way to tell the difference is to understand object-oriented design yourself.

You may write less code by hand than you did five years ago. But you review more code than ever, and you own every line you ship, no matter who or what wrote it. If you can’t read a class hierarchy and smell what’s wrong with it, you’re not reviewing your agent’s work.

You’re clicking “approve” and hoping for the best.

That’s the judgment this book builds: you’ll direct your AI tools instead of trusting them blindly, push back on bad designs, and sign off on good ones with confidence.

What Pythonistas Say
About Real Python’s Books

Prefer to Learn Live?

This book pairs with our Object-Oriented Python live course, a 5-day instructor-led cohort taught by Stephen where you build a complete project while applying the same concepts. Live course students receive a digital copy of this book as part of their course package. If you’d rather learn with an instructor and a cohort, enrollment for the August 24–28 cohort is open now →

FAQ

Is the book finished, or am I buying a work in progress? The book is complete: all nine chapters are written, edited, and ready to read today. “Early Access” means we’re applying a final round of polish based on reader feedback before the official release, and you get every update for free.

Does OOP still matter now that AI writes so much code? More than ever. AI assistants will happily generate classes, hierarchies, and design patterns. Your job is knowing whether what they produced is any good. This book builds the design judgment you need to review, correct, and confidently sign off on object-oriented code you didn’t write by hand.

Can I read part of the book before buying? Yes! Download the free sample chapters (PDF) to get a feel for the book’s style, depth, and typesetting.

How do I access the book after purchase? The book is added to your realpython.com account immediately. From its page you can download all formats, check the errata and changelog, and post comments or questions.

Which Python version does the book cover? All examples are written for modern Python and tested against the latest release of the language (Python 3.14 and the upcoming Python 3.15). The concepts apply to any recent Python 3 release.

How skilled do I need to be in Python to use this book? You should know the fundamentals: variables, functions, conditionals, loops, and the built-in data types. No prior OOP experience is required. The book starts from your first class and builds up to design principles.

Can I order a print version? A paperback edition is planned for after the Early Access period. Buy the ebook now and you can start reading today. We’ll announce the print release by email.

How will I receive updates? We announce updates via email as they come out. Plus, you’ll always find the latest version of the book available for download in your realpython.com account.

What if I don’t like the book? We want happy customers only. If you’re not happy with the digital version of the book, send us an email and tell us where it left you hanging. We’ll refund you in full, even 12 months later.

I have another question! Please email us at info@realpython.com and we’ll get back to you as soon as possible.