Everything you need to develop great object oriented software. Classes, objects, polymorphism, SOLID, Design Patterns.

What you'll learn

Go from complete OOP beginner to being confident and ready to get a job working on OOP software

Learn the basics of OOP: creating classes, objects, attributes, methods, access modifiers, abstract classes, getters & setters, properties, static attributes.

Understand crucial OOP concepts with examples: encapsulation, abstraction, inheritance, polymorphism, coupling, composition, dependency injection

The five SOLID principles show you how to assign responsibilities to classes and manage relationships between them

The "Gang of Four" Design Patterns: proven solutions to recurring problems in software design, so you don't have to reinvent the wheel

Unified Modelling Language (UML) for visually modelling classes and the relationships between them in a standardised way

Requirements

Just the very basics of Python: variables, functions, if statements, for loops.

You need no knowledge of object-oriented programming to take this course. I will teach you from the very basics to an advanced level.

Description

This course is for Python developers, of any level, that want to learn everything needed to write elegant, organised, maintainable object-oriented software.Object-oriented programming (OOP) can be confusing for beginners. Most Python courses just teach you about classes, objects, fields and methods – without teaching the crucial concepts that show why organising software in this way is so powerful.Python developers often then go on to work on object-oriented software, such as web applications built with Django, without having any clue of how to organise their code. This leads to software that is a nightmare to maintain, as adding new features often requires you to make breaking changes to existing working and tested code.I created this course with the goal to demystify OOP for Python developers. Through clear explanations and real-world examples, we will explore essential OOP concepts such as encapsulation, abstraction, polymorphism, composition, inheritance, dependency injection, UML, SOLID principles, and design patterns – giving you everything that you need to develop great, maintainable and elegant object oriented software.What you will learnThe first part of the course assumes that you're a complete OOP beginner, and introduces the very fundamentals of OOP: classes and objects, attributes and methods, access modifiers, static attributes and static methods, properties vs getters and setters. By the end of this section, you'll have the tools to write and understand object-oriented software.But tools alone aren't enough! Writing great software requires understanding the principles that help you organise your code effectively. The rest of the course focuses on these time-tested principles, teaching you how to think, refactor, and communicate about well-designed, maintainable, and extendable OOP software. Each concept is introduced with an example that first violates the principle, followed by a discussion of the issues and a refactored solution – helping you to really understand the principle and its applications.Section Two covers the foundational OOP principles you'll use throughout the rest of your career: encapsulation, abstraction, inheritance, polymorphism, coupling, composition (and its advantages over inheritance), and the fragile base class problem.Section Three introduces Unified Modelling Language (UML) to visually model classes and objects, and the relationships between them in a standardised way.Section Four dives into the SOLID principles, building on the concepts from Section Two. This section will deepen your understanding of how to assign responsibilities to classes and manage relationships between them.Section Five introduces the "Gang of Four" design patterns. These patterns provide proven solutions to recurring problems in software design, reinforcing everything you've learned in the course. You will learn six useful design patterns: State Pattern, Observer Pattern, Facade Pattern, Adapter Pattern, Prototype Pattern and Abstract Factory Pattern.By the end of this course, you'll have the knowledge and confidence to write OOP code that is clean, scalable, and maintainable.

Overview

Section 1: Introduction

Lecture 1 Welcome to Python OOP! Who is this course for?

Lecture 2 What you will learn

Lecture 3 About me

Lecture 4 Setup and Github

Section 2: Part 1: OOP Fundamentals

Lecture 5 Creating classes and objects

Lecture 6 Recap: creating classes and objects

Lecture 7 Combining objects

Lecture 8 Recap: classes, objects, attributes, methods and self

Lecture 9 Example: a Person class

Lecture 10 Accessing and modifying object data

Lecture 11 Access modifiers: protected attributes

Lecture 12 When should you make an attribute protected?

Lecture 13 Python's "Consenting Adults" philosophy and private attributes

Lecture 14 When to use protected vs private attributes

Lecture 15 Creating getter and setter methods

Lecture 16 Why do we create getters and setters?

Lecture 17 Properties: creating a getter property. Properties vs getters and setters

Lecture 18 Properties: creating a setter property

Lecture 19 Static attributes

Lecture 20 Static attributes vs instance attributes

Lecture 21 Static methods

Lecture 22 Static methods: when to use them?

Lecture 23 Protected and private methods

Section 3: Part 2: OOP Principles

Lecture 24 Introduction

Lecture 25 Encapsulation

Lecture 26 Encapsulation: why is it important?

Lecture 27 Abstraction

Lecture 28 Inheritance

Lecture 29 Polymorphism: intro and naive solution

Lecture 30 Polymorphism: refactored solution

Lecture 31 Coupling: intro and naive solution

Lecture 32 Coupling: refactored solution

Lecture 33 Abstract classes and abstract methods

Lecture 34 Composition

Lecture 35 When to use composition vs inheritance

Lecture 36 The Fragile Base Class Problem

Section 4: Part 3: Unified Modelling Language (UML)

Lecture 37 A super fast crash course in UML

Section 5: Part 4: The SOLID Principles

Lecture 38 Introduction

Lecture 39 Single Responsibility Principle (SRP): intro and naive solution

Lecture 40 SRP: refactored solution

Lecture 41 Caveat: using composition in service classes

Lecture 42 Caveat II: using method parameters in service classes

Lecture 43 Open/closed principle (OCP): intro and naive solution

Lecture 44 OCP: refactored solution

Lecture 45 Liskov Substitution Principle (LSP): intro and naive solution

Lecture 46 LSP: refactored solution

Lecture 47 LSP: demonstrating why this solution satisfies LSP

Lecture 48 Interface Segregation Principle (ISP): intro and naive solution

Lecture 49 ISP: refactored solution

Lecture 50 Dependency Inversion Principle (DIP): intro and naive solution

Lecture 51 DIP: UML + what are "high-level" and "low-level" modules?

Lecture 52 DIP: refactored solution with dependency injection

Lecture 53 DIP: UML and discussion

Lecture 54 The benefits of dependency injection

Section 6: Part 5: The "Gang of Four" Design Patterns

Lecture 55 What are design patterns? Why do we need them?

Lecture 56 The three groups of design patterns: Behavioural, Structural and Creational

Lecture 57 Behavioural Design Patterns: intro

Lecture 58 State Pattern: intro

Lecture 59 State Pattern: naive solution

Lecture 60 State Pattern: UML and discussion

Lecture 61 State Pattern: refactored solution

Lecture 62 State Pattern: when to use it (and not use it)

Lecture 63 Observer Pattern: intro

Lecture 64 Observer Pattern: naive solution

Lecture 65 Observer Pattern: UML and discussion

Lecture 66 Observer Pattern: refactored solution

Lecture 67 Observer Pattern: push vs pull communication

Lecture 68 Structural Design Patterns: intro

Lecture 69 Facade Pattern: intro

Lecture 70 Facade Pattern: naive solution

Lecture 71 Facade Pattern: UML and discussion

Lecture 72 Facade Pattern: refactored solution

Lecture 73 Adapter Pattern: intro

Lecture 74 Adapter Pattern: example

Lecture 75 Adapter Pattern: introducing a problem

Lecture 76 Adapter Pattern: UML and discussion

Lecture 77 Adapter Pattern: refactored solution

Lecture 78 Adapter Pattern: should we use inheritance or composition?

Lecture 79 Creational Design Patterns: intro

Lecture 80 Prototype Pattern: intro

Lecture 81 Prototype Pattern: naive solution

Lecture 82 Prototype Pattern: UML and discussion

Lecture 83 Prototype Pattern: refactored solution

Lecture 84 Abstract Factory Pattern: intro

Lecture 85 Abstract Factory Pattern: naive solution

Lecture 86 Abstract Factory Pattern: UML and discussion

Lecture 87 Abstract Factory Pattern: refactored solution

Lecture 88 Abstract Factory Pattern: discussing the refactored solution

Section 7: Conclusion

Lecture 89 Congratulations! Where do I go from here?

Any level of Python developer that wants to fully understand OOP in Python and feel confident working on real OOP software.