Python Oop: Object Oriented Programming From Beginner To Pro

Python Oop: Object Oriented Programming From Beginner To Pro
Published 12/2024
MP4 | Video: h264, 1920×1080 | Audio: AAC, 44.1 KHz

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

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

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

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

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

Lecture 37 A super fast crash course in UML

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

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.